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.111 by root, Mon Dec 25 17:11:16 2006 UTC vs.
Revision 1.118 by root, Sat Dec 30 20:32:30 2006 UTC

… …
60static f_plug_api object_set_property = cfapi_object_set_property; 60static f_plug_api object_set_property = cfapi_object_set_property;
61static f_plug_api object_insert = cfapi_object_insert; 61static f_plug_api object_insert = cfapi_object_insert;
62 62
63static PerlInterpreter *perl; 63static PerlInterpreter *perl;
64 64
65double runtime;
66
65global gbl_ev; 67global gbl_ev;
66static AV *cb_global, *cb_attachable, *cb_object, *cb_player, *cb_client, *cb_type, *cb_map; 68static AV *cb_global, *cb_attachable, *cb_object, *cb_player, *cb_client, *cb_type, *cb_map;
69static SV *sv_runtime;
67 70
68static HV 71static HV
69 *stash_cf, 72 *stash_cf,
70 *stash_cf_object_wrap, 73 *stash_cf_object_wrap,
71 *stash_cf_object_player_wrap, 74 *stash_cf_object_player_wrap,
… …
172 ++i; // further delay freeing 175 ++i; // further delay freeing
173 }//D 176 }//D
174 else 177 else
175 { 178 {
176 //Dfprintf (stderr, "deleteing %d:%p:%s\n", i, obj,typeid (*obj).name ());//D 179 //Dfprintf (stderr, "deleteing %d:%p:%s\n", i, obj,typeid (*obj).name ());//D
180 mortals.erase (i);
177 delete obj; 181 delete obj;
178 mortals.erase (i);
179 } 182 }
180 } 183 }
181} 184}
182 185
183attachable & 186attachable &
… …
213 // next line makes sense, but most objects still have refcnt 0 by default 216 // next line makes sense, but most objects still have refcnt 0 by default
214 //at->refcnt_chk (); 217 //at->refcnt_chk ();
215 return 0; 218 return 0;
216} 219}
217 220
218static MGVTBL vtbl_attachable = {0, 0, 0, 0, attachable_free}; 221MGVTBL attachable::vtbl = {0, 0, 0, 0, attachable_free};
219 222
220SV * 223static SV *
221newSVattachable (attachable *obj, HV *stash) 224newSVattachable (attachable *obj, HV *stash)
222{ 225{
223 if (!obj) 226 if (!obj)
224 return &PL_sv_undef; 227 return &PL_sv_undef;
225 228
226 if (!obj->self) 229 if (!obj->self)
227 { 230 {
228 obj->self = newHV (); 231 obj->self = newHV ();
229 sv_magicext ((SV *)obj->self, 0, PERL_MAGIC_ext, &vtbl_attachable, (char *)obj, 0); 232 sv_magicext ((SV *)obj->self, 0, PERL_MAGIC_ext, &attachable::vtbl, (char *)obj, 0);
230 233
231 // borrow the refcnt from the object 234 // borrow the refcnt from the object
232 obj->flags |= attachable::F_BORROWED; 235 obj->flags |= attachable::F_BORROWED;
233 obj->refcnt_dec (); 236 obj->refcnt_dec ();
234 } 237 }
… …
320inline void sv_to (SV *sv, unsigned long &v) { v = SvUV (sv); } 323inline void sv_to (SV *sv, unsigned long &v) { v = SvUV (sv); }
321inline void sv_to (SV *sv, signed long long &v) { v = ( signed long long)SvVAL64 (sv); } 324inline void sv_to (SV *sv, signed long long &v) { v = ( signed long long)SvVAL64 (sv); }
322inline void sv_to (SV *sv, unsigned long long &v) { v = (unsigned long long)SvVAL64 (sv); } 325inline void sv_to (SV *sv, unsigned long long &v) { v = (unsigned long long)SvVAL64 (sv); }
323inline void sv_to (SV *sv, float &v) { v = SvNV (sv); } 326inline void sv_to (SV *sv, float &v) { v = SvNV (sv); }
324inline void sv_to (SV *sv, double &v) { v = SvNV (sv); } 327inline void sv_to (SV *sv, double &v) { v = SvNV (sv); }
325inline void sv_to (SV *sv, client * &v) { v = (client *)SvPTR_ornull (sv, "cf::client"); } 328inline void sv_to (SV *sv, client * &v) { v = (client *)(attachable *)SvPTR_ornull (sv, "cf::client"); }
326inline void sv_to (SV *sv, player * &v) { v = (player *)SvPTR_ornull (sv, "cf::player"); } 329inline void sv_to (SV *sv, player * &v) { v = (player *)(attachable *)SvPTR_ornull (sv, "cf::player"); }
327inline void sv_to (SV *sv, object * &v) { v = (object *)SvPTR_ornull (sv, "cf::object"); } 330inline void sv_to (SV *sv, object * &v) { v = (object *)(attachable *)SvPTR_ornull (sv, "cf::object"); }
328inline void sv_to (SV *sv, archetype * &v) { v = (archetype *)SvPTR_ornull (sv, "cf::arch"); } 331inline void sv_to (SV *sv, archetype * &v) { v = (archetype *)(attachable *)SvPTR_ornull (sv, "cf::arch"); }
329inline void sv_to (SV *sv, maptile * &v) { v = (maptile *)SvPTR_ornull (sv, "cf::map"); } 332inline void sv_to (SV *sv, maptile * &v) { v = (maptile *)(attachable *)SvPTR_ornull (sv, "cf::map"); }
330inline void sv_to (SV *sv, partylist * &v) { v = (partylist *)SvPTR_ornull (sv, "cf::party"); } 333inline void sv_to (SV *sv, partylist * &v) { v = (partylist *)SvPTR_ornull (sv, "cf::party"); }
331inline void sv_to (SV *sv, region * &v) { v = (region *)SvPTR_ornull (sv, "cf::region"); } 334inline void sv_to (SV *sv, region * &v) { v = (region *)SvPTR_ornull (sv, "cf::region"); }
332inline void sv_to (SV *sv, living * &v) { v = (living *)SvPTR_ornull (sv, "cf::living"); } 335inline void sv_to (SV *sv, living * &v) { v = (living *)SvPTR_ornull (sv, "cf::living"); }
333 336
334inline void sv_to (SV *sv, New_Face * &v) { v = &new_faces[FindFace (SvPV_nolen (sv), 0)]; } //TODO 337inline void sv_to (SV *sv, New_Face * &v) { v = &new_faces[FindFace (SvPV_nolen (sv), 0)]; } //TODO
… …
512 { 515 {
513 flags &= ~F_BORROWED; 516 flags &= ~F_BORROWED;
514 refcnt_inc (); 517 refcnt_inc ();
515 SvREFCNT_dec ((SV *)self); 518 SvREFCNT_dec ((SV *)self);
516 } 519 }
517}
518
519/////////////////////////////////////////////////////////////////////////////
520
521#include "kw_hash.h"
522
523object_freezer::object_freezer ()
524: dynbuf (128 * 1024, 64 * 1024)
525{
526 av = newAV ();
527}
528
529object_freezer::~object_freezer ()
530{
531 SvREFCNT_dec (av);
532}
533
534void object_freezer::put (attachable *ext)
535{
536 ext->optimise ();
537
538 if (ext->self)
539 {
540 int idx = AvFILLp ((AV *)av) + 1;
541 av_store (av, idx, newRV_inc ((SV *)ext->self));
542
543 add ((void *)"oid ", 4);
544 add ((sint32)idx);
545 add ('\n');
546 }
547}
548
549bool object_freezer::save (const char *filename)
550{
551 dSP;
552 ENTER;
553 SAVETMPS;
554 PUSHMARK (SP);
555 EXTEND (SP, 3);
556 PUSHs (sv_2mortal (newSVpv (filename, 0)));
557 PUSHs (sv_2mortal (newRV_noinc (newSVpvn ((char *)linearise (), size ()))));
558 PUSHs (sv_2mortal (newRV_inc ((SV *)av)));
559 PUTBACK;
560 call_pv ("cf::object_freezer_save", G_VOID | G_DISCARD | G_EVAL);
561 FREETMPS;
562 LEAVE;
563}
564
565char *object_freezer::as_string ()
566{
567 dSP;
568 ENTER;
569 SAVETMPS;
570 PUSHMARK (SP);
571 EXTEND (SP, 3);
572 PUSHs (sv_2mortal (newRV_noinc (newSVpvn ((char *)linearise (), size ()))));
573 PUSHs (sv_2mortal (newRV_inc ((SV *)av)));
574 PUTBACK;
575
576 char *res = call_pv ("cf::object_freezer_as_string", G_SCALAR | G_EVAL) > 0
577 ? strdup (SvPVbyte_nolen (POPs))
578 : strdup ("[fatal error]");
579
580 FREETMPS;
581 LEAVE;
582
583 return res;
584}
585
586int fprintf (object_freezer &freezer, const char *format, ...)
587{
588 va_list ap;
589
590 va_start (ap, format);
591
592 int len = vsnprintf ((char *)freezer.force (1024), 1024, format, ap);
593
594 if (len >= 0)
595 freezer.alloc (len);
596
597 va_end (ap);
598}
599
600int fputs (const char *s, object_freezer &freezer)
601{
602 freezer.add (s);
603}
604
605static const char thawer_eof[] = "\n\n\n\0\0\0";
606
607object_thawer::object_thawer (const char *filename)
608{
609 static const char eof[] = "\n\n\n\0\0\0";
610
611 av = 0;
612 text = 0;
613 line = 0;
614
615 if (filename)
616 {
617 dSP;
618 ENTER;
619 SAVETMPS;
620 PUSHMARK (SP);
621 XPUSHs (sv_2mortal (newSVpv (filename, 0)));
622 PUTBACK;
623
624 if (2 == call_pv ("cf::object_thawer_load", G_ARRAY | G_EVAL))
625 {
626 SPAGAIN;
627
628 // second value - perl objects
629 {
630 SV *sv = POPs;
631 if (SvROK (sv))
632 av = (AV *)SvREFCNT_inc (SvRV (sv));
633 }
634
635 // first value - text part, pad with 3 zeroes
636 {
637 SV *sv = POPs;
638 STRLEN len;
639 char *sv_ = SvPVbyte (sv, len);
640 text = newSV (len + sizeof (eof));
641 SvCUR_set (text, len);
642 memcpy (SvPVX (text), sv_, len);
643 memcpy (SvEND (text), eof, sizeof (eof)); // just to be sure
644
645 line = SvPVX (text);
646 }
647 }
648
649 PUTBACK;
650 FREETMPS;
651 LEAVE;
652 }
653}
654
655object_thawer::object_thawer (const char *data, AV *perlav)
656{
657 av = perlav;
658 text = newSVpv (data, 0);
659 sv_catpv (text, thawer_eof);
660 line = SvPVbyte_nolen (text);
661}
662
663void object_thawer::get (attachable *obj, int oid)
664{
665 if (!av || oid < 0) // this is actually an error of sorts
666 return;
667
668 // object must be virgin
669 assert (!obj->self);
670
671 SV **svp = av_fetch ((AV *)av, oid, 0);
672
673 if (!svp || !SvROK (*svp))
674 {
675 printf ("trying to thaw duplicate or never-issued oid %d, ignoring.\n", oid);
676 return;
677 }
678
679 obj->self = (HV *)SvRV (*svp);
680 SvRV_set (*svp, &PL_sv_undef);
681
682 sv_magicext ((SV *)obj->self, 0, PERL_MAGIC_ext, &vtbl_attachable, (char *)obj, 0);
683 obj->reattach ();
684
685 // borrow a refcount for the perl object
686 obj->flags |= attachable::F_BORROWED;
687 obj->refcnt_dec ();
688}
689
690object_thawer::~object_thawer ()
691{
692 if (text) SvREFCNT_dec (text);
693 if (av) SvREFCNT_dec (av);
694}
695
696char *fgets (char *s, int n, object_thawer &thawer)
697{
698 char *p = thawer.line;
699 char *q = s;
700
701 if (!p)
702 return 0;
703
704 while (--n)
705 {
706 if (!*p)
707 break;
708
709 *q++ = *p;
710
711 if (*p++ == '\n')
712 break;
713 }
714
715 *q = 0;
716 thawer.line = p;
717
718 return s == q ? 0 : s;
719}
720
721keyword object_thawer::get_kv ()
722{
723 if (!line)
724 return KW_EOF;
725
726 for (;;)
727 {
728 char *p = line;
729
730 if (!*p)
731 return KW_EOF;
732
733 // parse keyword
734 while (*p > ' ')
735 p++;
736
737 int klen = p - line;
738
739 if (*p++ != '\n')
740 {
741 // parse value
742 while (*(unsigned char *)p <= ' ' && *p != '\n') // skip 0x01 .. 0x20
743 ++p;
744
745 last_value = p;
746
747 while (*p != '\n')
748 p++;
749
750 *p++ = 0;
751 }
752 else
753 last_value = 0;
754
755 line [klen] = 0;
756 keyword_idx *kw = kw_lex::match (line, klen);
757
758 //printf ("KV %d<%s,%s>\n", kw ? kw->index : 0, line, last_value);//D
759
760 if (kw)
761 {
762 line = p;
763 return kw->index;
764 }
765 else if (!*line || *line == '#')
766 {
767 // empty/comment line
768 line = p;
769 }
770 else
771 return KW_ERROR;
772 }
773}
774
775void object_thawer::get (shstr &sh) const
776{
777 if (last_value)
778 sh = last_value;
779 else
780 {
781 sh = "<value missing>";
782 LOG (llevError, "keyword requires value: <%s>\n", line);//TODO: add filename
783 }
784}
785
786void object_thawer::get_ml (keyword kend, shstr &sh)
787{
788 char kw[128];
789
790 int klen = keyword_len [kend];
791
792 kw [0] = '\n';
793 memcpy (kw + 1, keyword_str [kend], klen);
794 kw [klen + 1] = '\n';
795 kw [klen + 2] = 0;
796
797 // first test for completely empty msg... "endXXX\n"
798 if (!strncmp (line, kw + 1, klen + 1))
799 {
800 sh = 0;
801
802 line += klen + 1;
803
804 return;
805 }
806 else
807 {
808 // multi-line strings are delimited by "\nendXXX\n" or "endXXX\n" (NULL)
809
810 char *end = strstr (line, kw);
811
812 if (!end)
813 {
814 sh = 0;
815 return;
816 }
817
818 *end = 0;
819 sh = line;
820
821 line = end + keyword_len [kend] + 1;
822
823 while (*line++ != '\n')
824 ;
825 }
826}
827
828sint32 object_thawer::get_sint32 () const
829{
830 char *p = last_value;
831
832 if (!p)
833 return 0;
834
835 sint32 val = 0;
836 bool negate;
837
838 if (*p == '-')
839 {
840 negate = true;
841 ++p;
842 }
843 else
844 negate = false;
845
846 do
847 {
848 val *= 10;
849 val += *p++ - '0';
850 }
851 while (*p);
852
853 return negate ? -val : val;
854}
855
856sint64 object_thawer::get_sint64 () const
857{
858 return last_value ? atoll (last_value) : 0;
859}
860
861double object_thawer::get_double () const
862{
863 return last_value ? atof (last_value) : 0;
864} 520}
865 521
866///////////////////////////////////////////////////////////////////////////// 522/////////////////////////////////////////////////////////////////////////////
867 523
868extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr) 524extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr)
… …
1095 751
1096 // short-circuit processing if no callbacks found/defined 752 // short-circuit processing if no callbacks found/defined
1097 if (!callbacks) 753 if (!callbacks)
1098 return 0; 754 return 0;
1099 755
1100 dSP; 756 CALL_BEGIN (3);
1101 ENTER;
1102 SAVETMPS;
1103
1104 PUSHMARK (SP);
1105 EXTEND (SP, 3);
1106
1107 PUSHs (sv_2mortal (newSViv (event))); // only used for debugging nowadays 757 CALL_ARG_SV (newSViv (event)); // only used for debugging nowadays
1108 PUSHs (sv_2mortal (newRV_noinc ((SV *)callbacks))); 758 CALL_ARG_SV (newRV_noinc ((SV *)callbacks));
1109 759
1110 //TODO: unhack 760 //TODO: unhack
1111 if (object *op = is_a<object>(this)) PUSHs (sv_2mortal (newSVdt (DT_OBJECT, op))); 761 if (object *op = is_a<object>(this)) CALL_ARG_SV (newSVdt (DT_OBJECT, op));
1112 else if (player *pl = is_a<player>(this)) PUSHs (sv_2mortal (newSVdt (DT_PLAYER, pl))); 762 else if (player *pl = is_a<player>(this)) CALL_ARG_SV (newSVdt (DT_PLAYER, pl));
1113 else if (client *ns = is_a<client>(this)) PUSHs (sv_2mortal (newSVdt (DT_CLIENT, ns))); 763 else if (client *ns = is_a<client>(this)) CALL_ARG_SV (newSVdt (DT_CLIENT, ns));
1114 else if (maptile *m = is_a<maptile>(this)) PUSHs (sv_2mortal (newSVdt (DT_MAP, m))); 764 else if (maptile *m = is_a<maptile>(this)) CALL_ARG_SV (newSVdt (DT_MAP, m));
1115 else if (global *gl = is_a<global>(this)) /*nop*/; 765 else if (global *gl = is_a<global>(this)) /*nop*/;
1116 else 766 else
1117 abort (); //TODO 767 abort (); //TODO
1118 768
1119 for (;;) 769 for (;;)
… …
1133 XPUSHs (sv_2mortal (newSVdt_va (ap, dt))); 783 XPUSHs (sv_2mortal (newSVdt_va (ap, dt)));
1134 } 784 }
1135 785
1136 va_end (ap); 786 va_end (ap);
1137 787
1138 PUTBACK; 788 CALL_CALL ("cf::do_invoke", G_SCALAR);
1139 int count = call_pv ("cf::do_invoke", G_SCALAR | G_EVAL);
1140 SPAGAIN;
1141
1142 count = count > 0 ? POPi : 0; 789 count = count > 0 ? POPi : 0;
1143 790
1144 FREETMPS; 791 CALL_END;
1145 LEAVE;
1146 792
1147 return count; 793 return count;
1148} 794}
1149 795
1150SV * 796SV *
… …
1173 return SvNV (cfperl_result (idx)); 819 return SvNV (cfperl_result (idx));
1174} 820}
1175 821
1176///////////////////////////////////////////////////////////////////////////// 822/////////////////////////////////////////////////////////////////////////////
1177 823
824void
825maptile::emergency_save ()
826{
827 CALL_BEGIN (0);
828 CALL_CALL ("cf::map::emergency_save", G_VOID);
829 CALL_END;
830}
831
832maptile *
833maptile::find_map (const char *path, maptile *origin)
834{
835 CALL_BEGIN (2);
836 CALL_ARG (path);
837 CALL_ARG (origin);
838 CALL_CALL ("cf::map::find_map", G_SCALAR);
839
840 maptile *retval;
841
842 if (count)
843 sv_to (POPs, retval);
844 else
845 retval = 0;
846
847 CALL_END;
848
849 return retval;
850}
851
852void
853maptile::do_load ()
854{
855 CALL_BEGIN (1);
856 CALL_ARG (this);
857 CALL_CALL ("cf::map::do_load", G_VOID);
858 CALL_END;
859}
860
861maptile *
862maptile::customise_for (object *op)
863{
864 CALL_BEGIN (2);
865 CALL_ARG (this);
866 CALL_ARG (op);
867 CALL_CALL ("cf::map::customise_for", G_SCALAR);
868
869 maptile *retval;
870
871 if (count)
872 sv_to (POPs, retval);
873 else
874 retval = 0;
875
876 CALL_END;
877
878 return retval ? retval : this;
879}
880
881void
882maptile::change_all_map_light (int change)
883{
884 CALL_BEGIN (1);
885 CALL_ARG (change);
886 CALL_CALL ("cf::map::change_all_map_light", G_VOID);
887 CALL_END;
888}
889
890void
891object::enter_exit (object *exit)
892{
893 if (type != PLAYER)
894 return;
895
896 CALL_BEGIN (2);
897 CALL_ARG (this);
898 CALL_ARG (exit);
899 CALL_CALL ("cf::object::player::enter_exit", G_VOID);
900 CALL_END;
901}
902
903/////////////////////////////////////////////////////////////////////////////
904
1178struct EventAPI *watcher_base::GEventAPI; 905struct EventAPI *watcher_base::GEventAPI;
906struct CoroAPI *coroapi::GCoroAPI;
1179 907
1180static void iw_dispatch (pe_event *ev) 908static void iw_dispatch (pe_event *ev)
1181{ 909{
1182 iw *w = (iw *)ev->ext_data; 910 iw *w = (iw *)ev->ext_data;
1183 w->call (*w); 911 w->call (*w);
… …
1246 stash_cf_arch_wrap = gv_stashpv ("cf::arch::wrap" , 1); 974 stash_cf_arch_wrap = gv_stashpv ("cf::arch::wrap" , 1);
1247 stash_cf_party_wrap = gv_stashpv ("cf::party::wrap" , 1); 975 stash_cf_party_wrap = gv_stashpv ("cf::party::wrap" , 1);
1248 stash_cf_region_wrap = gv_stashpv ("cf::region::wrap", 1); 976 stash_cf_region_wrap = gv_stashpv ("cf::region::wrap", 1);
1249 stash_cf_living_wrap = gv_stashpv ("cf::living::wrap", 1); 977 stash_cf_living_wrap = gv_stashpv ("cf::living::wrap", 1);
1250 978
979 sv_runtime = get_sv ("cf::RUNTIME", 1);
980 sv_upgrade (sv_runtime, SVt_NV);
981
1251 cb_global = get_av ("cf::CB_GLOBAL", 1); 982 cb_global = get_av ("cf::CB_GLOBAL", 1);
1252 cb_attachable = get_av ("cf::CB_ATTACHABLE", 1); 983 cb_attachable = get_av ("cf::CB_ATTACHABLE", 1);
1253 cb_object = get_av ("cf::CB_OBJECT", 1); 984 cb_object = get_av ("cf::CB_OBJECT", 1);
1254 cb_player = get_av ("cf::CB_PLAYER", 1); 985 cb_player = get_av ("cf::CB_PLAYER", 1);
1255 cb_client = get_av ("cf::CB_CLIENT", 1); 986 cb_client = get_av ("cf::CB_CLIENT", 1);
… …
1261 992
1262BOOT: 993BOOT:
1263{ 994{
1264 _connect_to_perl (); 995 _connect_to_perl ();
1265 996
1266 I_EVENT_API (PACKAGE);
1267 watcher_base::GEventAPI = GEventAPI; 997 I_EVENT_API (PACKAGE); watcher_base::GEventAPI = GEventAPI;
1268 I_CORO_API (PACKAGE); 998 I_CORO_API (PACKAGE); coroapi::GCoroAPI = GCoroAPI;
1269 999
1270 newCONSTSUB (stash_cf, "VERSION", newSVpv (VERSION, sizeof (VERSION) - 1)); 1000 newCONSTSUB (stash_cf, "VERSION", newSVpv (VERSION, sizeof (VERSION) - 1));
1271 1001
1272 static const struct { 1002 static const struct {
1273 const char *name; 1003 const char *name;
… …
1760 const_iv (ST_CUSTOM) 1490 const_iv (ST_CUSTOM)
1761 1491
1762 const_iv (ST_CHANGE_CLASS) 1492 const_iv (ST_CHANGE_CLASS)
1763 const_iv (ST_CONFIRM_QUIT) 1493 const_iv (ST_CONFIRM_QUIT)
1764 const_iv (ST_GET_PARTY_PASSWORD) 1494 const_iv (ST_GET_PARTY_PASSWORD)
1495
1496 const_iv (IO_HEADER)
1497 const_iv (IO_OBJECTS)
1498 const_iv (IO_UNIQUES)
1499
1500 // random map generator
1501 const_iv (LAYOUT_NONE)
1502 const_iv (LAYOUT_ONION)
1503 const_iv (LAYOUT_MAZE)
1504 const_iv (LAYOUT_SPIRAL)
1505 const_iv (LAYOUT_ROGUELIKE)
1506 const_iv (LAYOUT_SNAKE)
1507 const_iv (LAYOUT_SQUARE_SPIRAL)
1508
1509 const_iv (RMOPT_RANDOM)
1510 const_iv (RMOPT_CENTERED)
1511 const_iv (RMOPT_LINEAR)
1512 const_iv (RMOPT_BOTTOM_C)
1513 const_iv (RMOPT_BOTTOM_R)
1514 const_iv (RMOPT_IRR_SPACE)
1515 const_iv (RMOPT_WALL_OFF)
1516 const_iv (RMOPT_WALLS_ONLY)
1517 const_iv (RMOPT_NO_DOORS)
1518
1519 const_iv (SYMMETRY_RANDOM)
1520 const_iv (SYMMETRY_NONE)
1521 const_iv (SYMMETRY_X)
1522 const_iv (SYMMETRY_Y)
1523 const_iv (SYMMETRY_XY)
1765 }; 1524 };
1766 1525
1767 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; ) 1526 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
1768 newCONSTSUB (stash_cf, (char *)civ->name, newSViv (civ->iv)); 1527 newCONSTSUB (stash_cf, (char *)civ->name, newSViv (civ->iv));
1769 1528
… …
1797{ 1556{
1798 // reattach to all attachable objects in the game. 1557 // reattach to all attachable objects in the game.
1799 for (sockvec::iterator i = clients.begin (); i != clients.end (); ++i) 1558 for (sockvec::iterator i = clients.begin (); i != clients.end (); ++i)
1800 (*i)->reattach (); 1559 (*i)->reattach ();
1801 1560
1802 for (player *pl = first_player; pl; pl = pl->next) 1561 for_all_players (pl)
1803 pl->reattach (); 1562 pl->reattach ();
1804 1563
1805 for (maptile *m = first_map; m; m = m->next) 1564 //TODO
1806 m->reattach (); 1565 //for (map_container::iterator i = maps.begin (); i != maps.end (); ++i)
1566 // i->second->reattach ();
1807 1567
1808 for (object *op = object::first; op; op = op->next) 1568 for (object *op = object::first; op; op = op->next)
1809 op->reattach (); 1569 op->reattach ();
1810} 1570}
1811 1571
1812NV floor (NV x) 1572NV floor (NV x)
1813 1573
1814NV ceil (NV x) 1574NV ceil (NV x)
1815 1575
1816void server_tick () 1576void server_tick ()
1577 CODE:
1578 runtime = SvNVx (sv_runtime);
1579 server_tick ();
1817 1580
1818void 1581void
1819LOG (int level, char *msg) 1582LOG (int level, char *msg)
1820 PROTOTYPE: $$ 1583 PROTOTYPE: $$
1821 C_ARGS: (LogLevel)level, "%s", msg 1584 C_ARGS: (LogLevel)level, "%s", msg
… …
1861 case 5: RETVAL = settings.playerdir; break; 1624 case 5: RETVAL = settings.playerdir; break;
1862 case 6: RETVAL = settings.datadir ; break; 1625 case 6: RETVAL = settings.datadir ; break;
1863 } 1626 }
1864 OUTPUT: RETVAL 1627 OUTPUT: RETVAL
1865 1628
1629void emergency_save ()
1630
1866void _exit (int status = 0) 1631void _exit (int status = 0)
1867 1632
1868int find_animation (char *text) 1633int find_animation (char *text)
1869 PROTOTYPE: $ 1634 PROTOTYPE: $
1870 1635
… …
1918 CODE: 1683 CODE:
1919 RETVAL = SvROK (obj) && mg_find (SvRV (obj), PERL_MAGIC_ext); 1684 RETVAL = SvROK (obj) && mg_find (SvRV (obj), PERL_MAGIC_ext);
1920 OUTPUT: 1685 OUTPUT:
1921 RETVAL 1686 RETVAL
1922 1687
1688#bool
1689#destroyed (attachable *at)
1690#
1691#void
1692#destroy (attachable *at)
1693
1923MODULE = cf PACKAGE = cf::global 1694MODULE = cf PACKAGE = cf::global
1924 1695
1925int invoke (SV *klass, int event, ...) 1696int invoke (SV *klass, int event, ...)
1926 CODE: 1697 CODE:
1927 if (KLASS_OF (event) != KLASS_GLOBAL) croak ("event class must be GLOBAL"); 1698 if (KLASS_OF (event) != KLASS_GLOBAL) croak ("event class must be GLOBAL");
… …
1982void 1753void
1983set_animation (object *op, int idx) 1754set_animation (object *op, int idx)
1984 CODE: 1755 CODE:
1985 SET_ANIMATION (op, idx); 1756 SET_ANIMATION (op, idx);
1986 1757
1987void
1988object::drain_stat ()
1989
1990void
1991object::drain_specific_stat (int stat)
1992
1993void
1994object::change_luck (int change)
1995
1996void
1997object::add_statbonus ()
1998
1999void
2000object::remove_statbonus ()
2001
2002object *find_best_object_match (object *op, const char *match) 1758object *find_best_object_match (object *op, const char *match)
2003 1759
2004object *find_marked_object (object *op) 1760object *find_marked_object (object *op)
2005 1761
2006int need_identify (object *obj); 1762int need_identify (object *obj);
… …
2019 1775
2020void apply_below (object *op) 1776void apply_below (object *op)
2021 CODE: 1777 CODE:
2022 player_apply_below (op); 1778 player_apply_below (op);
2023 1779
2024void remove (object *op)
2025 CODE:
2026 op->remove ();
2027
2028void
2029object::destroy (bool destroy_inventory = false)
2030
2031void
2032object::destroy_inv (bool drop_to_ground = false)
2033
2034object *cf_object_present_archname_inside (object *op, char *whatstr) 1780object *cf_object_present_archname_inside (object *op, char *whatstr)
2035 1781
2036int cf_object_transfer (object *op, int x, int y, int r = 0, object_ornull *orig = 0) 1782int cf_object_transfer (object *op, int x, int y, int r = 0, object_ornull *orig = 0)
2037 1783
2038int cf_object_change_map (object *op, int x, int y, maptile *map) 1784int cf_object_change_map (object *op, int x, int y, maptile *map)
2039 1785
1786#//TODO
2040object *clone (object *op, int recursive = 0) 1787object *clone_ (object *op, int recursive = 0)
2041 CODE: 1788 CODE:
2042 if (recursive) 1789 if (recursive)
2043 RETVAL = object_create_clone (op); 1790 RETVAL = object_create_clone (op);
2044 else 1791 else
2045 { 1792 {
… …
2150player *contr (object *op) 1897player *contr (object *op)
2151 CODE: 1898 CODE:
2152 RETVAL = op->contr; 1899 RETVAL = op->contr;
2153 OUTPUT: RETVAL 1900 OUTPUT: RETVAL
2154 1901
2155void
2156object::roll_stats ()
2157
2158void
2159object::update_stats ()
2160
2161void
2162object::swap_stats (int a, int b)
2163
2164const char *get_ob_key_value (object *op, const char *key) 1902const char *get_ob_key_value (object *op, const char *key)
2165 1903
2166bool set_ob_key_value (object *op, const char *key, const char *value = 0, int add_key = 1) 1904bool set_ob_key_value (object *op, const char *key, const char *value = 0, int add_key = 1)
2167 1905
2168object *get_nearest_player (object *ob) 1906object *get_nearest_player (object *ob)
… …
2228void esrv_update_item (object *op, int what, object *item) 1966void esrv_update_item (object *op, int what, object *item)
2229 C_ARGS: what, op, item 1967 C_ARGS: what, op, item
2230 1968
2231void clear_los (object *op) 1969void clear_los (object *op)
2232 1970
2233int command_reset (object *op, char *params)
2234
2235int command_teleport (object *op, char *params) 1971int command_teleport (object *op, char *params)
2236 1972
2237int command_summon (object *op, char *params) 1973int command_summon (object *op, char *params)
2238 1974
2239int command_arrest (object *op, char *params) 1975int command_arrest (object *op, char *params)
… …
2254 for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i))); 1990 for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
2255 RETVAL = pl->invoke ((event_type)event, ARG_AV (av), DT_END); 1991 RETVAL = pl->invoke ((event_type)event, ARG_AV (av), DT_END);
2256 OUTPUT: RETVAL 1992 OUTPUT: RETVAL
2257 1993
2258SV *registry (player *pl) 1994SV *registry (player *pl)
2259
2260player *
2261create ()
2262 CODE:
2263 RETVAL = player::create ();
2264 OUTPUT:
2265 RETVAL
2266
2267player *
2268load (const char *path)
2269 CODE:
2270 RETVAL = player::load (path);
2271 OUTPUT:
2272 RETVAL
2273
2274void
2275player::save (bool final = false)
2276
2277void
2278player::connect (client *ns)
2279 1995
2280void 1996void
2281save_stats (player *pl) 1997save_stats (player *pl)
2282 CODE: 1998 CODE:
2283 pl->ob->stats.hp = pl->ob->stats.maxhp; 1999 pl->ob->stats.hp = pl->ob->stats.maxhp;
… …
2368 OUTPUT: RETVAL 2084 OUTPUT: RETVAL
2369 2085
2370 2086
2371MODULE = cf PACKAGE = cf::map PREFIX = cf_map_ 2087MODULE = cf PACKAGE = cf::map PREFIX = cf_map_
2372 2088
2373maptile *first ()
2374 PROTOTYPE:
2375 CODE:
2376 RETVAL = first_map;
2377 OUTPUT: RETVAL
2378
2379int invoke (maptile *map, int event, ...) 2089int invoke (maptile *map, int event, ...)
2380 CODE: 2090 CODE:
2381 if (KLASS_OF (event) != KLASS_MAP) croak ("event class must be MAP"); 2091 if (KLASS_OF (event) != KLASS_MAP) croak ("event class must be MAP");
2382 AV *av = (AV *)sv_2mortal ((SV *)newAV ()); 2092 AV *av = (AV *)sv_2mortal ((SV *)newAV ());
2383 for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i))); 2093 for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
… …
2386 2096
2387SV *registry (maptile *map) 2097SV *registry (maptile *map)
2388 2098
2389INCLUDE: $PERL genacc maptile ../include/map.h | 2099INCLUDE: $PERL genacc maptile ../include/map.h |
2390 2100
2391maptile *new (int width, int height) 2101void
2102maptile::instantiate ()
2103
2104maptile *new ()
2392 PROTOTYPE: 2105 PROTOTYPE:
2393 CODE: 2106 CODE:
2394{ 2107 RETVAL = new maptile;
2395 RETVAL = get_empty_map (width, height);
2396}
2397 OUTPUT: 2108 OUTPUT:
2398 RETVAL 2109 RETVAL
2399 2110
2400void delete_map (maptile *map) 2111void
2112maptile::destroy ()
2401 2113
2402void clean_tmp_map (maptile *map) 2114void
2115maptile::players ()
2116 PPCODE:
2117 if (GIMME_V == G_SCALAR)
2118 XPUSHs (sv_2mortal (to_sv (THIS->players)));
2119 else if (GIMME_V == G_ARRAY)
2120 {
2121 EXTEND (SP, THIS->players);
2122 for_all_players (pl)
2123 if (pl->ob && pl->ob->map == THIS)
2124 PUSHs (sv_2mortal (to_sv (pl->ob)));
2125 }
2403 2126
2404void play_sound_map (maptile *map, int x, int y, int sound_num) 2127void play_sound_map (maptile *map, int x, int y, int sound_num)
2405 2128
2406int out_of_map (maptile *map, int x, int y) 2129int out_of_map (maptile *map, int x, int y)
2407
2408maptile *tile_map (maptile *map, unsigned int dir)
2409 CODE:
2410 RETVAL = dir < 4 ? map->tile_map [dir] : 0;
2411 OUTPUT:
2412 RETVAL
2413
2414char *tile_path (maptile *map, unsigned int dir)
2415 CODE:
2416 if (dir >= 4)
2417 XSRETURN_UNDEF;
2418 RETVAL = map->tile_path [dir];
2419 OUTPUT:
2420 RETVAL
2421
2422maptile *ready_map_name (char *name, int flags = 0)
2423 PROTOTYPE: $;$
2424 ALIAS:
2425 find = 0
2426 get_map = 1
2427
2428maptile *has_been_loaded (char *name)
2429 PROTOTYPE: $
2430
2431int in_memory (maptile *map)
2432 CODE:
2433 RETVAL = map->in_memory;
2434 OUTPUT:
2435 RETVAL
2436 2130
2437void 2131void
2438trigger (maptile *map, long connection, bool state = true) 2132trigger (maptile *map, long connection, bool state = true)
2439 CODE: 2133 CODE:
2440 activate_connection (map, connection, state); 2134 activate_connection (map, connection, state);
… …
2519 2213
2520void fix_walls (maptile *map, int x, int y) 2214void fix_walls (maptile *map, int x, int y)
2521 2215
2522void fix_walls_around (maptile *map, int x, int y) 2216void fix_walls_around (maptile *map, int x, int y)
2523 2217
2218# worst xs function of my life
2219maptile *
2220_create_random_map (\
2221 char *path,\
2222 char *wallstyle,\
2223 char *wall_name,\
2224 char *floorstyle,\
2225 char *monsterstyle,\
2226 char *treasurestyle,\
2227 char *layoutstyle,\
2228 char *doorstyle,\
2229 char *decorstyle,\
2230 char *origin_map,\
2231 char *final_map,\
2232 char *exitstyle,\
2233 char *this_map,\
2234 char *exit_on_final_map,\
2235 int Xsize,\
2236 int Ysize,\
2237 int expand2x,\
2238 int layoutoptions1,\
2239 int layoutoptions2,\
2240 int layoutoptions3,\
2241 int symmetry,\
2242 int difficulty,\
2243 int difficulty_given,\
2244 float difficulty_increase,\
2245 int dungeon_level,\
2246 int dungeon_depth,\
2247 int decoroptions,\
2248 int orientation,\
2249 int origin_y,\
2250 int origin_x,\
2251 int random_seed,\
2252 val64 total_map_hp,\
2253 int map_layout_style,\
2254 int treasureoptions,\
2255 int symmetry_used,\
2256 region *region\
2257)
2258 CODE:
2259{
2260 random_map_params rmp;
2261
2262 assign (rmp.wallstyle , wallstyle);
2263 assign (rmp.wall_name , wall_name);
2264 assign (rmp.floorstyle , floorstyle);
2265 assign (rmp.monsterstyle , monsterstyle);
2266 assign (rmp.treasurestyle , treasurestyle);
2267 assign (rmp.layoutstyle , layoutstyle);
2268 assign (rmp.doorstyle , doorstyle);
2269 assign (rmp.decorstyle , decorstyle);
2270 assign (rmp.origin_map , origin_map);
2271 assign (rmp.final_map , final_map);
2272 assign (rmp.exitstyle , exitstyle);
2273 assign (rmp.this_map , this_map);
2274 assign (rmp.exit_on_final_map, exit_on_final_map);
2275
2276 rmp.Xsize = Xsize;
2277 rmp.Ysize = Ysize;
2278 rmp.expand2x = expand2x;
2279 rmp.layoutoptions1 = layoutoptions1;
2280 rmp.layoutoptions2 = layoutoptions2;
2281 rmp.layoutoptions3 = layoutoptions3;
2282 rmp.symmetry = symmetry;
2283 rmp.difficulty = difficulty;
2284 rmp.difficulty_given = difficulty_given;
2285 rmp.difficulty_increase = difficulty_increase;
2286 rmp.dungeon_level = dungeon_level;
2287 rmp.dungeon_depth = dungeon_depth;
2288 rmp.decoroptions = decoroptions;
2289 rmp.orientation = orientation;
2290 rmp.origin_y = origin_y;
2291 rmp.origin_x = origin_x;
2292 rmp.random_seed = random_seed;
2293 rmp.total_map_hp = total_map_hp;
2294 rmp.map_layout_style = map_layout_style;
2295 rmp.treasureoptions = treasureoptions;
2296 rmp.symmetry_used = symmetry_used;
2297 rmp.region = region;
2298
2299 RETVAL = generate_random_map (path, &rmp);
2300}
2301 OUTPUT:
2302 RETVAL
2303
2524MODULE = cf PACKAGE = cf::arch 2304MODULE = cf PACKAGE = cf::arch
2525 2305
2526archetype *find (const char *name) 2306archetype *find (const char *name)
2527 CODE: 2307 CODE:
2528 RETVAL = archetype::find (name); 2308 RETVAL = archetype::find (name);
… …
2620 PPCODE: 2400 PPCODE:
2621 EXTEND (SP, clients.size ()); 2401 EXTEND (SP, clients.size ());
2622 for (sockvec::iterator i = clients.begin (); i != clients.end (); ++i) 2402 for (sockvec::iterator i = clients.begin (); i != clients.end (); ++i)
2623 PUSHs (sv_2mortal (to_sv (*i))); 2403 PUSHs (sv_2mortal (to_sv (*i)));
2624 2404
2625client *
2626create (int fd, const char *peername)
2627 CODE:
2628 RETVAL = client::create (fd, peername);
2629 OUTPUT:
2630 RETVAL
2631
2632void 2405void
2633client::send_packet (SV *packet) 2406client::send_packet (SV *packet)
2634 CODE: 2407 CODE:
2635{ 2408{
2636 STRLEN len; 2409 STRLEN len;

Diff Legend

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