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.110 by root, Mon Dec 25 14:43:23 2006 UTC vs.
Revision 1.124 by root, Mon Jan 1 00:41:03 2007 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 &
… …
208attachable_free (pTHX_ SV *sv, MAGIC *mg) 211attachable_free (pTHX_ SV *sv, MAGIC *mg)
209{ 212{
210 attachable *at = (attachable *)mg->mg_ptr; 213 attachable *at = (attachable *)mg->mg_ptr;
211 assert (!(at->flags & attachable::F_BORROWED));//D//TODO//remove when stable 214 assert (!(at->flags & attachable::F_BORROWED));//D//TODO//remove when stable
212 at->self = 0; 215 at->self = 0;
216 // next line makes sense, but most objects still have refcnt 0 by default
213 at->refcnt_chk (); 217 //at->refcnt_chk ();
214 return 0; 218 return 0;
215} 219}
216 220
217static MGVTBL vtbl_attachable = {0, 0, 0, 0, attachable_free}; 221MGVTBL attachable::vtbl = {0, 0, 0, 0, attachable_free};
218 222
219SV * 223static SV *
220newSVattachable (attachable *obj, HV *stash) 224newSVattachable (attachable *obj, HV *stash)
221{ 225{
222 if (!obj) 226 if (!obj)
223 return &PL_sv_undef; 227 return &PL_sv_undef;
224 228
225 if (!obj->self) 229 if (!obj->self)
226 { 230 {
227 obj->self = newHV (); 231 obj->self = newHV ();
228 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);
229 233
230 // borrow the refcnt from the object 234 // borrow the refcnt from the object
231 obj->flags |= attachable::F_BORROWED; 235 obj->flags |= attachable::F_BORROWED;
232 obj->refcnt_dec (); 236 obj->refcnt_dec ();
233 } 237 }
… …
319inline void sv_to (SV *sv, unsigned long &v) { v = SvUV (sv); } 323inline void sv_to (SV *sv, unsigned long &v) { v = SvUV (sv); }
320inline 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); }
321inline 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); }
322inline void sv_to (SV *sv, float &v) { v = SvNV (sv); } 326inline void sv_to (SV *sv, float &v) { v = SvNV (sv); }
323inline void sv_to (SV *sv, double &v) { v = SvNV (sv); } 327inline void sv_to (SV *sv, double &v) { v = SvNV (sv); }
324inline 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"); }
325inline 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"); }
326inline 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"); }
327inline 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"); }
328inline 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"); }
329inline 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"); }
330inline 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"); }
331inline 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"); }
332 336
333inline 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
… …
511 { 515 {
512 flags &= ~F_BORROWED; 516 flags &= ~F_BORROWED;
513 refcnt_inc (); 517 refcnt_inc ();
514 SvREFCNT_dec ((SV *)self); 518 SvREFCNT_dec ((SV *)self);
515 } 519 }
516}
517
518/////////////////////////////////////////////////////////////////////////////
519
520#include "kw_hash.h"
521
522object_freezer::object_freezer ()
523: dynbuf (128 * 1024, 64 * 1024)
524{
525 av = newAV ();
526}
527
528object_freezer::~object_freezer ()
529{
530 SvREFCNT_dec (av);
531}
532
533void object_freezer::put (attachable *ext)
534{
535 ext->optimise ();
536
537 if (ext->self)
538 {
539 int idx = AvFILLp ((AV *)av) + 1;
540 av_store (av, idx, newRV_inc ((SV *)ext->self));
541
542 add ((void *)"oid ", 4);
543 add ((sint32)idx);
544 add ('\n');
545 }
546}
547
548bool object_freezer::save (const char *filename)
549{
550 dSP;
551 ENTER;
552 SAVETMPS;
553 PUSHMARK (SP);
554 EXTEND (SP, 3);
555 PUSHs (sv_2mortal (newSVpv (filename, 0)));
556 PUSHs (sv_2mortal (newRV_noinc (newSVpvn ((char *)linearise (), size ()))));
557 PUSHs (sv_2mortal (newRV_inc ((SV *)av)));
558 PUTBACK;
559 call_pv ("cf::object_freezer_save", G_VOID | G_DISCARD | G_EVAL);
560 FREETMPS;
561 LEAVE;
562}
563
564char *object_freezer::as_string ()
565{
566 dSP;
567 ENTER;
568 SAVETMPS;
569 PUSHMARK (SP);
570 EXTEND (SP, 3);
571 PUSHs (sv_2mortal (newRV_noinc (newSVpvn ((char *)linearise (), size ()))));
572 PUSHs (sv_2mortal (newRV_inc ((SV *)av)));
573 PUTBACK;
574
575 char *res = call_pv ("cf::object_freezer_as_string", G_SCALAR | G_EVAL) > 0
576 ? strdup (SvPVbyte_nolen (POPs))
577 : strdup ("[fatal error]");
578
579 FREETMPS;
580 LEAVE;
581
582 return res;
583}
584
585int fprintf (object_freezer &freezer, const char *format, ...)
586{
587 va_list ap;
588
589 va_start (ap, format);
590
591 int len = vsnprintf ((char *)freezer.force (1024), 1024, format, ap);
592
593 if (len >= 0)
594 freezer.alloc (len);
595
596 va_end (ap);
597}
598
599int fputs (const char *s, object_freezer &freezer)
600{
601 freezer.add (s);
602}
603
604static const char thawer_eof[] = "\n\n\n\0\0\0";
605
606object_thawer::object_thawer (const char *filename)
607{
608 static const char eof[] = "\n\n\n\0\0\0";
609
610 av = 0;
611 text = 0;
612 line = 0;
613
614 if (filename)
615 {
616 dSP;
617 ENTER;
618 SAVETMPS;
619 PUSHMARK (SP);
620 XPUSHs (sv_2mortal (newSVpv (filename, 0)));
621 PUTBACK;
622
623 if (2 == call_pv ("cf::object_thawer_load", G_ARRAY | G_EVAL))
624 {
625 SPAGAIN;
626
627 // second value - perl objects
628 {
629 SV *sv = POPs;
630 if (SvROK (sv))
631 av = (AV *)SvREFCNT_inc (SvRV (sv));
632 }
633
634 // first value - text part, pad with 3 zeroes
635 {
636 SV *sv = POPs;
637 STRLEN len;
638 char *sv_ = SvPVbyte (sv, len);
639 text = newSV (len + sizeof (eof));
640 SvCUR_set (text, len);
641 memcpy (SvPVX (text), sv_, len);
642 memcpy (SvEND (text), eof, sizeof (eof)); // just to be sure
643
644 line = SvPVX (text);
645 }
646 }
647
648 PUTBACK;
649 FREETMPS;
650 LEAVE;
651 }
652}
653
654object_thawer::object_thawer (const char *data, AV *perlav)
655{
656 av = perlav;
657 text = newSVpv (data, 0);
658 sv_catpv (text, thawer_eof);
659 line = SvPVbyte_nolen (text);
660}
661
662void object_thawer::get (attachable *obj, int oid)
663{
664 if (!av || oid < 0) // this is actually an error of sorts
665 return;
666
667 // object must be virgin
668 assert (!obj->self);
669
670 SV **svp = av_fetch ((AV *)av, oid, 0);
671
672 if (!svp || !SvROK (*svp))
673 {
674 printf ("trying to thaw duplicate or never-issued oid %d, ignoring.\n", oid);
675 return;
676 }
677
678 obj->self = (HV *)SvRV (*svp);
679 SvRV_set (*svp, &PL_sv_undef);
680
681 sv_magicext ((SV *)obj->self, 0, PERL_MAGIC_ext, &vtbl_attachable, (char *)obj, 0);
682 obj->reattach ();
683
684 // borrow a refcount for the perl object
685 obj->flags |= attachable::F_BORROWED;
686 obj->refcnt_dec ();
687}
688
689object_thawer::~object_thawer ()
690{
691 if (text) SvREFCNT_dec (text);
692 if (av) SvREFCNT_dec (av);
693}
694
695char *fgets (char *s, int n, object_thawer &thawer)
696{
697 char *p = thawer.line;
698 char *q = s;
699
700 if (!p)
701 return 0;
702
703 while (--n)
704 {
705 if (!*p)
706 break;
707
708 *q++ = *p;
709
710 if (*p++ == '\n')
711 break;
712 }
713
714 *q = 0;
715 thawer.line = p;
716
717 return s == q ? 0 : s;
718}
719
720keyword object_thawer::get_kv ()
721{
722 if (!line)
723 return KW_EOF;
724
725 for (;;)
726 {
727 char *p = line;
728
729 if (!*p)
730 return KW_EOF;
731
732 // parse keyword
733 while (*p > ' ')
734 p++;
735
736 int klen = p - line;
737
738 if (*p++ != '\n')
739 {
740 // parse value
741 while (*(unsigned char *)p <= ' ' && *p != '\n') // skip 0x01 .. 0x20
742 ++p;
743
744 last_value = p;
745
746 while (*p != '\n')
747 p++;
748
749 *p++ = 0;
750 }
751 else
752 last_value = 0;
753
754 line [klen] = 0;
755 keyword_idx *kw = kw_lex::match (line, klen);
756
757 //printf ("KV %d<%s,%s>\n", kw ? kw->index : 0, line, last_value);//D
758
759 if (kw)
760 {
761 line = p;
762 return kw->index;
763 }
764 else if (!*line || *line == '#')
765 {
766 // empty/comment line
767 line = p;
768 }
769 else
770 return KW_ERROR;
771 }
772}
773
774void object_thawer::get (shstr &sh) const
775{
776 if (last_value)
777 sh = last_value;
778 else
779 {
780 sh = "<value missing>";
781 LOG (llevError, "keyword requires value: <%s>\n", line);//TODO: add filename
782 }
783}
784
785void object_thawer::get_ml (keyword kend, shstr &sh)
786{
787 char kw[128];
788
789 int klen = keyword_len [kend];
790
791 kw [0] = '\n';
792 memcpy (kw + 1, keyword_str [kend], klen);
793 kw [klen + 1] = '\n';
794 kw [klen + 2] = 0;
795
796 // first test for completely empty msg... "endXXX\n"
797 if (!strncmp (line, kw + 1, klen + 1))
798 {
799 sh = 0;
800
801 line += klen + 1;
802
803 return;
804 }
805 else
806 {
807 // multi-line strings are delimited by "\nendXXX\n" or "endXXX\n" (NULL)
808
809 char *end = strstr (line, kw);
810
811 if (!end)
812 {
813 sh = 0;
814 return;
815 }
816
817 *end = 0;
818 sh = line;
819
820 line = end + keyword_len [kend] + 1;
821
822 while (*line++ != '\n')
823 ;
824 }
825}
826
827sint32 object_thawer::get_sint32 () const
828{
829 char *p = last_value;
830
831 if (!p)
832 return 0;
833
834 sint32 val = 0;
835 bool negate;
836
837 if (*p == '-')
838 {
839 negate = true;
840 ++p;
841 }
842 else
843 negate = false;
844
845 do
846 {
847 val *= 10;
848 val += *p++ - '0';
849 }
850 while (*p);
851
852 return negate ? -val : val;
853}
854
855sint64 object_thawer::get_sint64 () const
856{
857 return last_value ? atoll (last_value) : 0;
858}
859
860double object_thawer::get_double () const
861{
862 return last_value ? atof (last_value) : 0;
863} 520}
864 521
865///////////////////////////////////////////////////////////////////////////// 522/////////////////////////////////////////////////////////////////////////////
866 523
867extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr) 524extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr)
… …
1094 751
1095 // short-circuit processing if no callbacks found/defined 752 // short-circuit processing if no callbacks found/defined
1096 if (!callbacks) 753 if (!callbacks)
1097 return 0; 754 return 0;
1098 755
1099 dSP; 756 CALL_BEGIN (3);
1100 ENTER;
1101 SAVETMPS;
1102
1103 PUSHMARK (SP);
1104 EXTEND (SP, 3);
1105
1106 PUSHs (sv_2mortal (newSViv (event))); // only used for debugging nowadays 757 CALL_ARG_SV (newSViv (event)); // only used for debugging nowadays
1107 PUSHs (sv_2mortal (newRV_noinc ((SV *)callbacks))); 758 CALL_ARG_SV (newRV_noinc ((SV *)callbacks));
1108 759
1109 //TODO: unhack 760 //TODO: unhack
1110 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));
1111 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));
1112 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));
1113 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));
1114 else if (global *gl = is_a<global>(this)) /*nop*/; 765 else if (global *gl = is_a<global>(this)) /*nop*/;
1115 else 766 else
1116 abort (); //TODO 767 abort (); //TODO
1117 768
1118 for (;;) 769 for (;;)
… …
1132 XPUSHs (sv_2mortal (newSVdt_va (ap, dt))); 783 XPUSHs (sv_2mortal (newSVdt_va (ap, dt)));
1133 } 784 }
1134 785
1135 va_end (ap); 786 va_end (ap);
1136 787
1137 PUTBACK; 788 CALL_CALL ("cf::do_invoke", G_SCALAR);
1138 int count = call_pv ("cf::do_invoke", G_SCALAR | G_EVAL);
1139 SPAGAIN;
1140
1141 count = count > 0 ? POPi : 0; 789 count = count > 0 ? POPi : 0;
1142 790
1143 FREETMPS; 791 CALL_END;
1144 LEAVE;
1145 792
1146 return count; 793 return count;
1147} 794}
1148 795
1149SV * 796SV *
… …
1172 return SvNV (cfperl_result (idx)); 819 return SvNV (cfperl_result (idx));
1173} 820}
1174 821
1175///////////////////////////////////////////////////////////////////////////// 822/////////////////////////////////////////////////////////////////////////////
1176 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::load_map_sync (const char *path, maptile *origin)
834{
835 CALL_BEGIN (2);
836 CALL_ARG (path);
837 CALL_ARG (origin);
838 CALL_CALL ("cf::map::load_map_sync", 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::change_all_map_light (int change)
854{
855 CALL_BEGIN (1);
856 CALL_ARG (change);
857 CALL_CALL ("cf::map::change_all_map_light", G_VOID);
858 CALL_END;
859}
860
861void
862object::enter_exit (object *exit)
863{
864 if (type != PLAYER)
865 return;
866
867 CALL_BEGIN (2);
868 CALL_ARG (this);
869 CALL_ARG (exit);
870 CALL_CALL ("cf::object::player::enter_exit", G_VOID);
871 CALL_END;
872}
873
874/////////////////////////////////////////////////////////////////////////////
875
1177struct EventAPI *watcher_base::GEventAPI; 876struct EventAPI *watcher_base::GEventAPI;
877struct CoroAPI *coroapi::GCoroAPI;
878
879int coroapi::cede_counter;
1178 880
1179static void iw_dispatch (pe_event *ev) 881static void iw_dispatch (pe_event *ev)
1180{ 882{
1181 iw *w = (iw *)ev->ext_data; 883 iw *w = (iw *)ev->ext_data;
1182 w->call (*w); 884 w->call (*w);
… …
1245 stash_cf_arch_wrap = gv_stashpv ("cf::arch::wrap" , 1); 947 stash_cf_arch_wrap = gv_stashpv ("cf::arch::wrap" , 1);
1246 stash_cf_party_wrap = gv_stashpv ("cf::party::wrap" , 1); 948 stash_cf_party_wrap = gv_stashpv ("cf::party::wrap" , 1);
1247 stash_cf_region_wrap = gv_stashpv ("cf::region::wrap", 1); 949 stash_cf_region_wrap = gv_stashpv ("cf::region::wrap", 1);
1248 stash_cf_living_wrap = gv_stashpv ("cf::living::wrap", 1); 950 stash_cf_living_wrap = gv_stashpv ("cf::living::wrap", 1);
1249 951
952 sv_runtime = get_sv ("cf::RUNTIME", 1);
953 sv_upgrade (sv_runtime, SVt_NV);
954
1250 cb_global = get_av ("cf::CB_GLOBAL", 1); 955 cb_global = get_av ("cf::CB_GLOBAL", 1);
1251 cb_attachable = get_av ("cf::CB_ATTACHABLE", 1); 956 cb_attachable = get_av ("cf::CB_ATTACHABLE", 1);
1252 cb_object = get_av ("cf::CB_OBJECT", 1); 957 cb_object = get_av ("cf::CB_OBJECT", 1);
1253 cb_player = get_av ("cf::CB_PLAYER", 1); 958 cb_player = get_av ("cf::CB_PLAYER", 1);
1254 cb_client = get_av ("cf::CB_CLIENT", 1); 959 cb_client = get_av ("cf::CB_CLIENT", 1);
… …
1260 965
1261BOOT: 966BOOT:
1262{ 967{
1263 _connect_to_perl (); 968 _connect_to_perl ();
1264 969
1265 I_EVENT_API (PACKAGE);
1266 watcher_base::GEventAPI = GEventAPI; 970 I_EVENT_API (PACKAGE); watcher_base::GEventAPI = GEventAPI;
1267 I_CORO_API (PACKAGE); 971 I_CORO_API (PACKAGE); coroapi::GCoroAPI = GCoroAPI;
1268 972
1269 newCONSTSUB (stash_cf, "VERSION", newSVpv (VERSION, sizeof (VERSION) - 1)); 973 newCONSTSUB (stash_cf, "VERSION", newSVpv (VERSION, sizeof (VERSION) - 1));
1270 974
1271 static const struct { 975 static const struct {
1272 const char *name; 976 const char *name;
… …
1586 const_iv (P_BLOCKSVIEW) 1290 const_iv (P_BLOCKSVIEW)
1587 const_iv (P_PLAYER) 1291 const_iv (P_PLAYER)
1588 const_iv (P_NO_MAGIC) 1292 const_iv (P_NO_MAGIC)
1589 const_iv (P_IS_ALIVE) 1293 const_iv (P_IS_ALIVE)
1590 const_iv (P_NO_CLERIC) 1294 const_iv (P_NO_CLERIC)
1591 const_iv (P_NEED_UPDATE)
1592 const_iv (P_OUT_OF_MAP) 1295 const_iv (P_OUT_OF_MAP)
1593 const_iv (P_NEW_MAP) 1296 const_iv (P_NEW_MAP)
1297 const_iv (P_UPTODATE)
1594 1298
1595 const_iv (UP_OBJ_INSERT) 1299 const_iv (UP_OBJ_INSERT)
1596 const_iv (UP_OBJ_REMOVE) 1300 const_iv (UP_OBJ_REMOVE)
1597 const_iv (UP_OBJ_CHANGE) 1301 const_iv (UP_OBJ_CHANGE)
1598 const_iv (UP_OBJ_FACE) 1302 const_iv (UP_OBJ_FACE)
… …
1759 const_iv (ST_CUSTOM) 1463 const_iv (ST_CUSTOM)
1760 1464
1761 const_iv (ST_CHANGE_CLASS) 1465 const_iv (ST_CHANGE_CLASS)
1762 const_iv (ST_CONFIRM_QUIT) 1466 const_iv (ST_CONFIRM_QUIT)
1763 const_iv (ST_GET_PARTY_PASSWORD) 1467 const_iv (ST_GET_PARTY_PASSWORD)
1468
1469 const_iv (IO_HEADER)
1470 const_iv (IO_OBJECTS)
1471 const_iv (IO_UNIQUES)
1472
1473 // random map generator
1474 const_iv (LAYOUT_NONE)
1475 const_iv (LAYOUT_ONION)
1476 const_iv (LAYOUT_MAZE)
1477 const_iv (LAYOUT_SPIRAL)
1478 const_iv (LAYOUT_ROGUELIKE)
1479 const_iv (LAYOUT_SNAKE)
1480 const_iv (LAYOUT_SQUARE_SPIRAL)
1481
1482 const_iv (RMOPT_RANDOM)
1483 const_iv (RMOPT_CENTERED)
1484 const_iv (RMOPT_LINEAR)
1485 const_iv (RMOPT_BOTTOM_C)
1486 const_iv (RMOPT_BOTTOM_R)
1487 const_iv (RMOPT_IRR_SPACE)
1488 const_iv (RMOPT_WALL_OFF)
1489 const_iv (RMOPT_WALLS_ONLY)
1490 const_iv (RMOPT_NO_DOORS)
1491
1492 const_iv (SYMMETRY_RANDOM)
1493 const_iv (SYMMETRY_NONE)
1494 const_iv (SYMMETRY_X)
1495 const_iv (SYMMETRY_Y)
1496 const_iv (SYMMETRY_XY)
1764 }; 1497 };
1765 1498
1766 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; ) 1499 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
1767 newCONSTSUB (stash_cf, (char *)civ->name, newSViv (civ->iv)); 1500 newCONSTSUB (stash_cf, (char *)civ->name, newSViv (civ->iv));
1768 1501
… …
1796{ 1529{
1797 // reattach to all attachable objects in the game. 1530 // reattach to all attachable objects in the game.
1798 for (sockvec::iterator i = clients.begin (); i != clients.end (); ++i) 1531 for (sockvec::iterator i = clients.begin (); i != clients.end (); ++i)
1799 (*i)->reattach (); 1532 (*i)->reattach ();
1800 1533
1801 for (player *pl = first_player; pl; pl = pl->next) 1534 for_all_players (pl)
1802 pl->reattach (); 1535 pl->reattach ();
1803 1536
1804 for (maptile *m = first_map; m; m = m->next) 1537 //TODO
1805 m->reattach (); 1538 //for (map_container::iterator i = maps.begin (); i != maps.end (); ++i)
1539 // i->second->reattach ();
1806 1540
1807 for (object *op = object::first; op; op = op->next) 1541 for (object *op = object::first; op; op = op->next)
1808 op->reattach (); 1542 op->reattach ();
1809} 1543}
1810 1544
1811NV floor (NV x) 1545NV floor (NV x)
1812 1546
1813NV ceil (NV x) 1547NV ceil (NV x)
1814 1548
1815void server_tick () 1549void server_tick ()
1550 CODE:
1551 runtime = SvNVx (sv_runtime);
1552 server_tick ();
1816 1553
1817void 1554void
1818LOG (int level, char *msg) 1555LOG (int level, char *msg)
1819 PROTOTYPE: $$ 1556 PROTOTYPE: $$
1820 C_ARGS: (LogLevel)level, "%s", msg 1557 C_ARGS: (LogLevel)level, "%s", msg
… …
1860 case 5: RETVAL = settings.playerdir; break; 1597 case 5: RETVAL = settings.playerdir; break;
1861 case 6: RETVAL = settings.datadir ; break; 1598 case 6: RETVAL = settings.datadir ; break;
1862 } 1599 }
1863 OUTPUT: RETVAL 1600 OUTPUT: RETVAL
1864 1601
1602void abort ()
1603
1604void emergency_save ()
1605
1865void _exit (int status = 0) 1606void _exit (int status = 0)
1866 1607
1867int find_animation (char *text) 1608int find_animation (char *text)
1868 PROTOTYPE: $ 1609 PROTOTYPE: $
1869 1610
… …
1917 CODE: 1658 CODE:
1918 RETVAL = SvROK (obj) && mg_find (SvRV (obj), PERL_MAGIC_ext); 1659 RETVAL = SvROK (obj) && mg_find (SvRV (obj), PERL_MAGIC_ext);
1919 OUTPUT: 1660 OUTPUT:
1920 RETVAL 1661 RETVAL
1921 1662
1663#bool
1664#destroyed (attachable *at)
1665#
1666#void
1667#destroy (attachable *at)
1668
1922MODULE = cf PACKAGE = cf::global 1669MODULE = cf PACKAGE = cf::global
1923 1670
1924int invoke (SV *klass, int event, ...) 1671int invoke (SV *klass, int event, ...)
1925 CODE: 1672 CODE:
1926 if (KLASS_OF (event) != KLASS_GLOBAL) croak ("event class must be GLOBAL"); 1673 if (KLASS_OF (event) != KLASS_GLOBAL) croak ("event class must be GLOBAL");
… …
1981void 1728void
1982set_animation (object *op, int idx) 1729set_animation (object *op, int idx)
1983 CODE: 1730 CODE:
1984 SET_ANIMATION (op, idx); 1731 SET_ANIMATION (op, idx);
1985 1732
1986void
1987object::drain_stat ()
1988
1989void
1990object::drain_specific_stat (int stat)
1991
1992void
1993object::change_luck (int change)
1994
1995void
1996object::add_statbonus ()
1997
1998void
1999object::remove_statbonus ()
2000
2001object *find_best_object_match (object *op, const char *match) 1733object *find_best_object_match (object *op, const char *match)
2002 1734
2003object *find_marked_object (object *op) 1735object *find_marked_object (object *op)
2004 1736
2005int need_identify (object *obj); 1737int need_identify (object *obj);
… …
2018 1750
2019void apply_below (object *op) 1751void apply_below (object *op)
2020 CODE: 1752 CODE:
2021 player_apply_below (op); 1753 player_apply_below (op);
2022 1754
2023void remove (object *op)
2024 CODE:
2025 op->remove ();
2026
2027void
2028object::destroy (bool destroy_inventory = false)
2029
2030void
2031object::destroy_inv (bool drop_to_ground = false)
2032
2033object *cf_object_present_archname_inside (object *op, char *whatstr) 1755object *cf_object_present_archname_inside (object *op, char *whatstr)
2034 1756
2035int cf_object_transfer (object *op, int x, int y, int r = 0, object_ornull *orig = 0) 1757int cf_object_transfer (object *op, int x, int y, int r = 0, object_ornull *orig = 0)
2036 1758
2037int cf_object_change_map (object *op, int x, int y, maptile *map) 1759int cf_object_change_map (object *op, int x, int y, maptile *map)
2038 1760
1761#//TODO
2039object *clone (object *op, int recursive = 0) 1762object *clone_ (object *op, int recursive = 0)
2040 CODE: 1763 CODE:
2041 if (recursive) 1764 if (recursive)
2042 RETVAL = object_create_clone (op); 1765 RETVAL = object_create_clone (op);
2043 else 1766 else
2044 { 1767 {
… …
2149player *contr (object *op) 1872player *contr (object *op)
2150 CODE: 1873 CODE:
2151 RETVAL = op->contr; 1874 RETVAL = op->contr;
2152 OUTPUT: RETVAL 1875 OUTPUT: RETVAL
2153 1876
2154void
2155object::roll_stats ()
2156
2157void
2158object::update_stats ()
2159
2160void
2161object::swap_stats (int a, int b)
2162
2163const char *get_ob_key_value (object *op, const char *key) 1877const char *get_ob_key_value (object *op, const char *key)
2164 1878
2165bool set_ob_key_value (object *op, const char *key, const char *value = 0, int add_key = 1) 1879bool set_ob_key_value (object *op, const char *key, const char *value = 0, int add_key = 1)
2166 1880
2167object *get_nearest_player (object *ob) 1881object *get_nearest_player (object *ob)
… …
2203 RETVAL = op->contr; 1917 RETVAL = op->contr;
2204 OUTPUT: RETVAL 1918 OUTPUT: RETVAL
2205 1919
2206void check_score (object *op) 1920void check_score (object *op)
2207 1921
2208void cf_player_message (object *obj, char *txt, int flags = NDI_ORANGE | NDI_UNIQUE) 1922void message (object *op, char *txt, int flags = NDI_ORANGE | NDI_UNIQUE)
1923 CODE:
1924 new_draw_info (flags, 0, op, txt);
2209 1925
2210object *cf_player_send_inventory (object *op) 1926object *cf_player_send_inventory (object *op)
2211 1927
2212char *cf_player_get_ip (object *op) 1928char *cf_player_get_ip (object *op)
2213 ALIAS: ip = 0 1929 ALIAS: ip = 0
… …
2226 1942
2227void esrv_update_item (object *op, int what, object *item) 1943void esrv_update_item (object *op, int what, object *item)
2228 C_ARGS: what, op, item 1944 C_ARGS: what, op, item
2229 1945
2230void clear_los (object *op) 1946void clear_los (object *op)
2231
2232int command_reset (object *op, char *params)
2233 1947
2234int command_teleport (object *op, char *params) 1948int command_teleport (object *op, char *params)
2235 1949
2236int command_summon (object *op, char *params) 1950int command_summon (object *op, char *params)
2237 1951
… …
2253 for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i))); 1967 for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
2254 RETVAL = pl->invoke ((event_type)event, ARG_AV (av), DT_END); 1968 RETVAL = pl->invoke ((event_type)event, ARG_AV (av), DT_END);
2255 OUTPUT: RETVAL 1969 OUTPUT: RETVAL
2256 1970
2257SV *registry (player *pl) 1971SV *registry (player *pl)
2258
2259player *
2260create ()
2261 CODE:
2262 RETVAL = player::create ();
2263 OUTPUT:
2264 RETVAL
2265
2266player *
2267load (const char *path)
2268 CODE:
2269 RETVAL = player::load (path);
2270 OUTPUT:
2271 RETVAL
2272
2273void
2274player::save (bool final = false)
2275
2276void
2277player::connect (client *ns)
2278 1972
2279void 1973void
2280save_stats (player *pl) 1974save_stats (player *pl)
2281 CODE: 1975 CODE:
2282 pl->ob->stats.hp = pl->ob->stats.maxhp; 1976 pl->ob->stats.hp = pl->ob->stats.maxhp;
… …
2367 OUTPUT: RETVAL 2061 OUTPUT: RETVAL
2368 2062
2369 2063
2370MODULE = cf PACKAGE = cf::map PREFIX = cf_map_ 2064MODULE = cf PACKAGE = cf::map PREFIX = cf_map_
2371 2065
2372maptile *first ()
2373 PROTOTYPE:
2374 CODE:
2375 RETVAL = first_map;
2376 OUTPUT: RETVAL
2377
2378int invoke (maptile *map, int event, ...) 2066int invoke (maptile *map, int event, ...)
2379 CODE: 2067 CODE:
2380 if (KLASS_OF (event) != KLASS_MAP) croak ("event class must be MAP"); 2068 if (KLASS_OF (event) != KLASS_MAP) croak ("event class must be MAP");
2381 AV *av = (AV *)sv_2mortal ((SV *)newAV ()); 2069 AV *av = (AV *)sv_2mortal ((SV *)newAV ());
2382 for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i))); 2070 for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
… …
2385 2073
2386SV *registry (maptile *map) 2074SV *registry (maptile *map)
2387 2075
2388INCLUDE: $PERL genacc maptile ../include/map.h | 2076INCLUDE: $PERL genacc maptile ../include/map.h |
2389 2077
2390maptile *new (int width, int height) 2078void
2079maptile::instantiate ()
2080
2081maptile *new ()
2391 PROTOTYPE: 2082 PROTOTYPE:
2392 CODE: 2083 CODE:
2393{ 2084 RETVAL = new maptile;
2394 RETVAL = get_empty_map (width, height);
2395}
2396 OUTPUT: 2085 OUTPUT:
2397 RETVAL 2086 RETVAL
2398 2087
2399void delete_map (maptile *map) 2088void
2089maptile::destroy ()
2400 2090
2401void clean_tmp_map (maptile *map) 2091void
2092maptile::players ()
2093 PPCODE:
2094 if (GIMME_V == G_SCALAR)
2095 XPUSHs (sv_2mortal (to_sv (THIS->players)));
2096 else if (GIMME_V == G_ARRAY)
2097 {
2098 EXTEND (SP, THIS->players);
2099 for_all_players (pl)
2100 if (pl->ob && pl->ob->map == THIS)
2101 PUSHs (sv_2mortal (to_sv (pl->ob)));
2102 }
2402 2103
2403void play_sound_map (maptile *map, int x, int y, int sound_num) 2104void play_sound_map (maptile *map, int x, int y, int sound_num)
2404 2105
2405int out_of_map (maptile *map, int x, int y) 2106int out_of_map (maptile *map, int x, int y)
2406
2407maptile *tile_map (maptile *map, unsigned int dir)
2408 CODE:
2409 RETVAL = dir < 4 ? map->tile_map [dir] : 0;
2410 OUTPUT:
2411 RETVAL
2412
2413char *tile_path (maptile *map, unsigned int dir)
2414 CODE:
2415 if (dir >= 4)
2416 XSRETURN_UNDEF;
2417 RETVAL = map->tile_path [dir];
2418 OUTPUT:
2419 RETVAL
2420
2421maptile *ready_map_name (char *name, int flags = 0)
2422 PROTOTYPE: $;$
2423 ALIAS:
2424 find = 0
2425 get_map = 1
2426
2427maptile *has_been_loaded (char *name)
2428 PROTOTYPE: $
2429
2430int in_memory (maptile *map)
2431 CODE:
2432 RETVAL = map->in_memory;
2433 OUTPUT:
2434 RETVAL
2435 2107
2436void 2108void
2437trigger (maptile *map, long connection, bool state = true) 2109trigger (maptile *map, long connection, bool state = true)
2438 CODE: 2110 CODE:
2439 activate_connection (map, connection, state); 2111 activate_connection (map, connection, state);
… …
2511 case 4: RETVAL = newSVuv ( GET_MAP_MOVE_BLOCK (obj, x, y)); break; 2183 case 4: RETVAL = newSVuv ( GET_MAP_MOVE_BLOCK (obj, x, y)); break;
2512 case 5: RETVAL = newSVuv ( GET_MAP_MOVE_SLOW (obj, x, y)); break; 2184 case 5: RETVAL = newSVuv ( GET_MAP_MOVE_SLOW (obj, x, y)); break;
2513 case 6: RETVAL = newSVuv ( GET_MAP_MOVE_ON (obj, x, y)); break; 2185 case 6: RETVAL = newSVuv ( GET_MAP_MOVE_ON (obj, x, y)); break;
2514 case 7: RETVAL = newSVuv ( GET_MAP_MOVE_OFF (obj, x, y)); break; 2186 case 7: RETVAL = newSVuv ( GET_MAP_MOVE_OFF (obj, x, y)); break;
2515 } 2187 }
2516 OUTPUT: 2188 OUTPUT: RETVAL
2189
2190void fix_walls (maptile *map, int x, int y)
2191
2192void fix_walls_around (maptile *map, int x, int y)
2193
2194const char *
2195region_name (maptile *m)
2196 CODE:
2197 RETVAL = get_name_of_region_for_map (m);
2198 OUTPUT: RETVAL
2199
2200# worst xs function of my life
2201maptile *
2202_create_random_map (\
2203 char *path,\
2204 char *wallstyle,\
2205 char *wall_name,\
2206 char *floorstyle,\
2207 char *monsterstyle,\
2208 char *treasurestyle,\
2209 char *layoutstyle,\
2210 char *doorstyle,\
2211 char *decorstyle,\
2212 char *origin_map,\
2213 char *final_map,\
2214 char *exitstyle,\
2215 char *this_map,\
2216 char *exit_on_final_map,\
2217 int Xsize,\
2218 int Ysize,\
2219 int expand2x,\
2220 int layoutoptions1,\
2221 int layoutoptions2,\
2222 int layoutoptions3,\
2223 int symmetry,\
2224 int difficulty,\
2225 int difficulty_given,\
2226 float difficulty_increase,\
2227 int dungeon_level,\
2228 int dungeon_depth,\
2229 int decoroptions,\
2230 int orientation,\
2231 int origin_y,\
2232 int origin_x,\
2233 int random_seed,\
2234 val64 total_map_hp,\
2235 int map_layout_style,\
2236 int treasureoptions,\
2237 int symmetry_used,\
2238 region *region\
2239)
2240 CODE:
2241{
2242 random_map_params rmp;
2243
2244 assign (rmp.wallstyle , wallstyle);
2245 assign (rmp.wall_name , wall_name);
2246 assign (rmp.floorstyle , floorstyle);
2247 assign (rmp.monsterstyle , monsterstyle);
2248 assign (rmp.treasurestyle , treasurestyle);
2249 assign (rmp.layoutstyle , layoutstyle);
2250 assign (rmp.doorstyle , doorstyle);
2251 assign (rmp.decorstyle , decorstyle);
2252 assign (rmp.exitstyle , exitstyle);
2253 assign (rmp.exit_on_final_map, exit_on_final_map);
2254
2255 rmp.origin_map = origin_map;
2256 rmp.final_map = final_map;
2257 rmp.this_map = this_map;
2258 rmp.Xsize = Xsize;
2259 rmp.Ysize = Ysize;
2260 rmp.expand2x = expand2x;
2261 rmp.layoutoptions1 = layoutoptions1;
2262 rmp.layoutoptions2 = layoutoptions2;
2263 rmp.layoutoptions3 = layoutoptions3;
2264 rmp.symmetry = symmetry;
2265 rmp.difficulty = difficulty;
2266 rmp.difficulty_given = difficulty_given;
2267 rmp.difficulty_increase = difficulty_increase;
2268 rmp.dungeon_level = dungeon_level;
2269 rmp.dungeon_depth = dungeon_depth;
2270 rmp.decoroptions = decoroptions;
2271 rmp.orientation = orientation;
2272 rmp.origin_y = origin_y;
2273 rmp.origin_x = origin_x;
2274 rmp.random_seed = random_seed;
2275 rmp.total_map_hp = total_map_hp;
2276 rmp.map_layout_style = map_layout_style;
2277 rmp.treasureoptions = treasureoptions;
2278 rmp.symmetry_used = symmetry_used;
2279 rmp.region = region;
2280
2281 RETVAL = generate_random_map (path, &rmp);
2282}
2283 OUTPUT:
2517 RETVAL 2284 RETVAL
2518
2519void fix_walls (maptile *map, int x, int y)
2520
2521void fix_walls_around (maptile *map, int x, int y)
2522 2285
2523MODULE = cf PACKAGE = cf::arch 2286MODULE = cf PACKAGE = cf::arch
2524 2287
2525archetype *find (const char *name) 2288archetype *find (const char *name)
2526 CODE: 2289 CODE:
… …
2542 PROTOTYPE: 2305 PROTOTYPE:
2543 CODE: 2306 CODE:
2544 RETVAL = get_firstparty (); 2307 RETVAL = get_firstparty ();
2545 OUTPUT: RETVAL 2308 OUTPUT: RETVAL
2546 2309
2547partylist *next (partylist *party) 2310INCLUDE: $PERL genacc partylist ../include/player.h |
2548 CODE:
2549 RETVAL = party->next;
2550 OUTPUT: RETVAL
2551
2552const char *name (partylist *party)
2553 CODE:
2554 RETVAL = party->partyname;
2555 OUTPUT: RETVAL
2556
2557const char *password (partylist *party)
2558 CODE:
2559 RETVAL = party->passwd;
2560 OUTPUT: RETVAL
2561 2311
2562MODULE = cf PACKAGE = cf::region 2312MODULE = cf PACKAGE = cf::region
2563 2313
2564region *first () 2314region *first ()
2565 PROTOTYPE: 2315 PROTOTYPE:
2566 CODE: 2316 CODE:
2567 RETVAL = first_region; 2317 RETVAL = first_region;
2568 OUTPUT: RETVAL 2318 OUTPUT: RETVAL
2569 2319
2570region *next (region *reg) 2320region *find (char *name)
2321 PROTOTYPE: $
2571 CODE: 2322 CODE:
2572 RETVAL = reg->next; 2323 RETVAL = get_region_by_name (name);
2573 OUTPUT: RETVAL 2324 OUTPUT: RETVAL
2574 2325
2575const char *name (region *reg) 2326INCLUDE: $PERL genacc region ../include/map.h |
2576 CODE:
2577 RETVAL = reg->name;
2578 OUTPUT: RETVAL
2579
2580region *parent (region *reg)
2581 CODE:
2582 RETVAL = reg->parent;
2583 OUTPUT: RETVAL
2584
2585const char *longname (region *reg)
2586 CODE:
2587 RETVAL = reg->longname;
2588 OUTPUT: RETVAL
2589
2590const char *msg (region *reg)
2591 CODE:
2592 RETVAL = reg->msg;
2593 OUTPUT: RETVAL
2594 2327
2595MODULE = cf PACKAGE = cf::living 2328MODULE = cf PACKAGE = cf::living
2596 2329
2597INCLUDE: $PERL genacc living ../include/living.h | 2330INCLUDE: $PERL genacc living ../include/living.h |
2598 2331
… …
2619 PPCODE: 2352 PPCODE:
2620 EXTEND (SP, clients.size ()); 2353 EXTEND (SP, clients.size ());
2621 for (sockvec::iterator i = clients.begin (); i != clients.end (); ++i) 2354 for (sockvec::iterator i = clients.begin (); i != clients.end (); ++i)
2622 PUSHs (sv_2mortal (to_sv (*i))); 2355 PUSHs (sv_2mortal (to_sv (*i)));
2623 2356
2624client *
2625create (int fd, const char *peername)
2626 CODE:
2627 RETVAL = client::create (fd, peername);
2628 OUTPUT:
2629 RETVAL
2630
2631void 2357void
2632client::send_packet (SV *packet) 2358client::send_packet (SV *packet)
2633 CODE: 2359 CODE:
2634{ 2360{
2635 STRLEN len; 2361 STRLEN len;

Diff Legend

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