[ViewVC] Diff of: cvs/deliantra/server/server/cfperl.xs

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.106 by root, Sat Dec 23 15:49:40 2006 UTC vs.
Revision 1.124 by root, Mon Jan 1 00:41:03 2007 UTC

 #include <EXTERN.h>
 #include <perl.h>
 #include <XSUB.h>
+#include "CoroAPI.h"
 #include "perlxsi.c"
 extern sint64 *levels; // the experience table
 typedef object  object_ornull;
 static f_plug_api object_set_property = cfapi_object_set_property;
 static f_plug_api object_insert       = cfapi_object_insert;
 static PerlInterpreter *perl;
+double runtime;
+global gbl_ev;
-static AV *cb_global, *cb_object, *cb_player, *cb_client, *cb_type, *cb_map;
+static AV *cb_global, *cb_attachable, *cb_object, *cb_player, *cb_client, *cb_type, *cb_map;
+static SV *sv_runtime;
+static HV
+   *stash_cf,
+   *stash_cf_object_wrap,
+   *stash_cf_object_player_wrap,
+   *stash_cf_player_wrap,
+   *stash_cf_map_wrap,
+   *stash_cf_client_wrap,
+   *stash_cf_arch_wrap,
+   *stash_cf_party_wrap,
+   *stash_cf_region_wrap,
+   *stash_cf_living_wrap;
+// helper cast function, returns super class * or 0
+template<class super>
+static super *
+is_a (attachable *at)
+{
+  //return dynamic_cast<super *>(at); // slower, safer
+  if (typeid (*at) == typeid (super))
+    return static_cast<super *>(at);
+  else
+    return 0;
+}
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+unordered_vector<attachable *> attachable::mortals;
+#if 0
+attachable *attachable::rc_first;
+attachable::attachable ()
+{
+  refcnt   = 0;
+  rc_next  = rc_first;
+  rc_first = this;
+}
+#endif
+attachable::~attachable ()
+{
+  assert (!(flags & F_BORROWED));//D//TODO//remove when stable
+#if 0
+  assert (!rc_next);
+  assert (!refcnt);
+#endif
+}
+// check wether the object really is dead
+void
+attachable::do_check ()
+{
+  if (refcnt > 0)
+    return;
+  // try to unborrow the refcnt from perl
+  if (flags & F_BORROWED)
+    {
+      assert (self);//D//TODO//remove when stable
+      flags &= ~F_BORROWED;
+      refcnt_inc ();
+      SvREFCNT_dec (self);
+    }
+  if (refcnt > 0 || self)
+    return;
+  destroy ();
+}
+void
+attachable::do_destroy ()
+{
+  invoke (EVENT_ATTACHABLE_DESTROY, DT_END);
+  //TODO: call generic destroy callback
+  mortals.push_back (this);
+}
+void
+attachable::destroy ()
+{
+  if (destroyed ())
+    return;
+  flags |= F_DESTROYED;
+  do_destroy ();
+}
+void attachable::check_mortals ()
+{
+  for (int i = 0; i < mortals.size (); )
+    {
+      attachable *obj = mortals [i];
+      obj->refcnt_chk (); // unborrow from perl, if necessary
+      if (obj->refcnt || obj->self)
+        {
+#if 0
+          if (mortals.size() > 5)fprintf (stderr, "%d delaying %d:%p:%s %d (self %p:%d)\n", time(0),i, obj, typeid (*obj).name (),
+                                          obj->refcnt, obj->self, obj->self ? SvREFCNT(obj->self): - 1);//D
+#endif
+        ++i; // further delay freeing
+        }//D
+      else
+        {
+          //Dfprintf (stderr, "deleteing %d:%p:%s\n", i, obj,typeid (*obj).name ());//D
+          mortals.erase (i);
+          delete obj;
+        }
+    }
+}
+attachable &
+attachable::operator =(const attachable &src)
+{
+  //if (self || cb)
+    //INVOKE_OBJECT (CLONE, this, ARG_OBJECT (dst));
+  attach = src.attach;
+  return *this;
+}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 static SV *
-newSVptr (void *ptr, const char *klass, HV *hv = newHV ())
+newSVptr (void *ptr, HV *stash, HV *hv = newHV ())
 {
   SV *sv;
   if (!ptr)
     return &PL_sv_undef;
-  sv_magic ((SV *)hv, 0, PERL_MAGIC_ext, (char *)ptr, 0);
+  sv_magicext ((SV *)hv, 0, PERL_MAGIC_ext, 0, (char *)ptr, 0);
-  return sv_bless (newRV_noinc ((SV *)hv), gv_stashpv (klass, 1));
+  return sv_bless (newRV_noinc ((SV *)hv), stash);
 }
-template<class attachable>
+static int
-SV *
+attachable_free (pTHX_ SV *sv, MAGIC *mg)
+{
+  attachable *at = (attachable *)mg->mg_ptr;
+  assert (!(at->flags & attachable::F_BORROWED));//D//TODO//remove when stable
+  at->self = 0;
+  // next line makes sense, but most objects still have refcnt 0 by default
+  //at->refcnt_chk ();
+  return 0;
+}
+MGVTBL attachable::vtbl = {0, 0, 0, 0, attachable_free};
+static SV *
-newSVattachable (attachable *obj, const char *klass)
+newSVattachable (attachable *obj, HV *stash)
 {
   if (!obj)
     return &PL_sv_undef;
   if (!obj->self)
-    obj->self = newSVptr (obj, klass);
+    {
+      obj->self = newHV ();
+      sv_magicext ((SV *)obj->self, 0, PERL_MAGIC_ext, &attachable::vtbl, (char *)obj, 0);
-  return newSVsv (obj->self);
+      // borrow the refcnt from the object
+      obj->flags |= attachable::F_BORROWED;
+      obj->refcnt_dec ();
+    }
+  return sv_bless (newRV_inc ((SV *)obj->self), stash);
 }
 static void
 clearSVptr (SV *sv)
 {
 inline SV *to_sv (unsigned long  v) { return newSVuv (v); }
 inline SV *to_sv (  signed long long v) { return newSVval64 (v); }
 inline SV *to_sv (unsigned long long v) { return newSVval64 (v); }
 inline SV *to_sv (float          v) { return newSVnv (v); }
 inline SV *to_sv (double         v) { return newSVnv (v); }
-inline SV *to_sv (client *       v) { return newSVattachable (v, "cf::client::wrap"); }
+inline SV *to_sv (client *       v) { return newSVattachable (v, stash_cf_client_wrap); }
-inline SV *to_sv (player *       v) { return newSVattachable (v, "cf::player::wrap"); }
+inline SV *to_sv (player *       v) { return newSVattachable (v, stash_cf_player_wrap); }
-inline SV *to_sv (object *       v) { return newSVattachable (v, v && v->type == PLAYER ? "cf::object::player::wrap" : "cf::object::wrap"); }
+inline SV *to_sv (object *       v) { return newSVattachable (v, v && v->type == PLAYER ? stash_cf_object_player_wrap : stash_cf_object_wrap); }
-inline SV *to_sv (maptile *      v) { return newSVattachable (v, "cf::map::wrap"); }
+inline SV *to_sv (maptile *      v) { return newSVattachable (v, stash_cf_map_wrap); }
-inline SV *to_sv (archetype *    v) { return newSVptr (v, "cf::arch::wrap"); }
+inline SV *to_sv (archetype *    v) { return newSVattachable (v, stash_cf_arch_wrap); }
-inline SV *to_sv (partylist *    v) { return newSVptr (v, "cf::party::wrap"); }
+inline SV *to_sv (partylist *    v) { return newSVptr (v, stash_cf_party_wrap); }
-inline SV *to_sv (region *       v) { return newSVptr (v, "cf::region::wrap"); }
+inline SV *to_sv (region *       v) { return newSVptr (v, stash_cf_region_wrap); }
-inline SV *to_sv (living *       v) { return newSVptr (v, "cf::living::wrap"); }
+inline SV *to_sv (living *       v) { return newSVptr (v, stash_cf_living_wrap); }
 inline SV *to_sv (object &       v) { return to_sv (&v); }
 inline SV *to_sv (living &       v) { return to_sv (&v); }
 //TODO:
 inline void sv_to (SV *sv, unsigned long  &v) { v = SvUV (sv); }
 inline void sv_to (SV *sv,   signed long long &v) { v = (  signed long long)SvVAL64 (sv); }
 inline void sv_to (SV *sv, unsigned long long &v) { v = (unsigned long long)SvVAL64 (sv); }
 inline void sv_to (SV *sv, float          &v) { v = SvNV (sv); }
 inline void sv_to (SV *sv, double         &v) { v = SvNV (sv); }
-inline void sv_to (SV *sv, client *       &v) { v = (client *)SvPTR_ornull (sv, "cf::client"); }
+inline void sv_to (SV *sv, client *       &v) { v = (client *)(attachable *)SvPTR_ornull (sv, "cf::client"); }
-inline void sv_to (SV *sv, player *       &v) { v = (player *)SvPTR_ornull (sv, "cf::player"); }
+inline void sv_to (SV *sv, player *       &v) { v = (player *)(attachable *)SvPTR_ornull (sv, "cf::player"); }
-inline void sv_to (SV *sv, object *       &v) { v = (object *)SvPTR_ornull (sv, "cf::object"); }
+inline void sv_to (SV *sv, object *       &v) { v = (object *)(attachable *)SvPTR_ornull (sv, "cf::object"); }
-inline void sv_to (SV *sv, archetype *    &v) { v = (archetype *)SvPTR_ornull (sv, "cf::arch"); }
+inline void sv_to (SV *sv, archetype *    &v) { v = (archetype *)(attachable *)SvPTR_ornull (sv, "cf::arch"); }
-inline void sv_to (SV *sv, maptile *      &v) { v = (maptile *)SvPTR_ornull (sv, "cf::map"); }
+inline void sv_to (SV *sv, maptile *      &v) { v = (maptile *)(attachable *)SvPTR_ornull (sv, "cf::map"); }
 inline void sv_to (SV *sv, partylist *    &v) { v = (partylist *)SvPTR_ornull (sv, "cf::party"); }
 inline void sv_to (SV *sv, region *       &v) { v = (region *)SvPTR_ornull (sv, "cf::region"); }
 inline void sv_to (SV *sv, living *       &v) { v = (living *)SvPTR_ornull (sv, "cf::living"); }
 inline void sv_to (SV *sv, New_Face *     &v) { v = &new_faces[FindFace (SvPV_nolen (sv), 0)]; } //TODO
   if (2 != sscanf (SvPV_nolen (sv), "<%d.%" SCNx64 ">", &version, &v.seq) || 1 != version)
     croak ("unparsable uuid: %s", SvPV_nolen (sv));
 }
-inline void sv_to (SV *sv, object::flags_t::reference v) { v = boolSV (sv); }
+inline void sv_to (SV *sv, object::flags_t::reference v) { v = SvTRUE (sv); }
 static SV *
 newSVdt_va (va_list &ap, data_type type)
 {
   SV *sv;
 }
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 SV *
-registry (attachable_base *ext)
+registry (attachable *ext)
 {
   if (!ext->cb)
     ext->cb = newAV ();
   return newRV_inc ((SV *)ext->cb);
 }
+#if 0
-void attachable_base::clear ()
+void attachable::clear ()
 {
   if (self)
     {
-      if (cb)
-        if (SvROK (*av_fetch (cb, EVENT_OBJECT_DESTROY, 1)))
-          INVOKE_OBJECT (DESTROY, static_cast<object *>(this));
-        else if (SvROK (*av_fetch (cb, EVENT_MAP_DESTROY, 1)))
-          INVOKE_MAP (DESTROY, static_cast<maptile *>(this));
       // disconnect Perl from C, to avoid crashes
       sv_unmagic (SvRV ((SV *)self), PERL_MAGIC_ext);
       // clear the perl hash, might or might not be a good idea
       hv_clear ((HV *)SvRV ((SV *)self));
       cb = 0;
     }
   attach = 0;
 }
+#endif
-void attachable_base::optimise ()
+void attachable::optimise ()
 {
-  if (!self)
+  if (self
-    return;
-  HV *hv = (HV *)SvRV ((SV *)self);
-  if (SvREFCNT ((SV *)self) == 1
-      && SvREFCNT ((SV *)hv) == 1
+      && SvREFCNT (self) == 1
-      && !HvTOTALKEYS (hv))
+      && !HvTOTALKEYS (self))
     {
+      flags &= ~F_BORROWED;
+      refcnt_inc ();
       SvREFCNT_dec ((SV *)self);
-      self = 0;
     }
-}
-void attachable_base::instantiate (data_type type, void *obj)
-{
-  dSP;
-  ENTER;
-  SAVETMPS;
-  PUSHMARK (SP);
-  EXTEND (SP, 2);
-  PUSHs (sv_2mortal (newSVdt (type, obj)));
-  PUSHs (sv_2mortal (newSVpv (attach, 0)));
-  attach = 0;
-  PUTBACK;
-  call_pv ("cf::instantiate", G_DISCARD | G_VOID | G_EVAL);
-  FREETMPS;
-  LEAVE;
-  switch (type)
-    {
-      case DT_OBJECT: INVOKE_OBJECT (INSTANTIATE, obj); break;
-      case DT_MAP:    INVOKE_MAP    (INSTANTIATE, obj); break;
-    }
-}
-/////////////////////////////////////////////////////////////////////////////
-void reattach (data_type type, void *obj)
-{
-  //TODO only do this when the object has _attachment's
-  dSP;
-  ENTER;
-  SAVETMPS;
-  PUSHMARK (SP);
-  XPUSHs (sv_2mortal (newSVdt (type, obj)));
-  PUTBACK;
-  call_pv ("cf::reattach", G_DISCARD | G_VOID | G_EVAL);
-  FREETMPS;
-  LEAVE;
-  switch (type)
-    {
-      case DT_OBJECT: INVOKE_OBJECT (REATTACH, obj); break;
-      case DT_PLAYER: INVOKE_PLAYER (REATTACH, obj); break;
-      case DT_CLIENT: INVOKE_CLIENT (REATTACH, obj); break;
-      case DT_MAP:    INVOKE_MAP    (REATTACH, obj); break;
-    }
-}
-template<class subclass>
-void reattach (attachable<subclass> *obj)
-{
-  obj->optimise ();
-  if (obj->self)
-    reattach ((data_type) cftype<subclass>::dt, (subclass *)obj);
-}
-#include "kw_hash.h"
-object_freezer::object_freezer ()
-: dynbuf (128 * 1024, 64 * 1024)
-{
-  av = newAV ();
-}
-object_freezer::~object_freezer ()
-{
-  SvREFCNT_dec (av);
-}
-void object_freezer::put (attachable_base *ext)
-{
-  ext->optimise ();
-  if (ext->self)
-    {
-      int idx = AvFILLp ((AV *)av) + 1;
-      av_store (av, idx, SvREFCNT_inc (ext->self));
-      add ((void *)"oid ", 4);
-      add ((sint32)idx);
-      add ('\n');
-    }
-}
-bool object_freezer::save (const char *filename)
-{
-  dSP;
-  ENTER;
-  SAVETMPS;
-  PUSHMARK (SP);
-  EXTEND (SP, 3);
-  PUSHs (sv_2mortal (newSVpv (filename, 0)));
-  PUSHs (sv_2mortal (newRV_noinc (newSVpvn ((char *)linearise (), size ()))));
-  PUSHs (sv_2mortal (newRV_inc ((SV *)av)));
-  PUTBACK;
-  call_pv ("cf::object_freezer_save", G_VOID | G_DISCARD | G_EVAL);
-  FREETMPS;
-  LEAVE;
-}
-char *object_freezer::as_string ()
-{
-  dSP;
-  ENTER;
-  SAVETMPS;
-  PUSHMARK (SP);
-  EXTEND (SP, 3);
-  PUSHs (sv_2mortal (newRV_noinc (newSVpvn ((char *)linearise (), size ()))));
-  PUSHs (sv_2mortal (newRV_inc ((SV *)av)));
-  PUTBACK;
-  char *res = call_pv ("cf::object_freezer_as_string", G_SCALAR | G_EVAL) > 0
-              ? strdup (SvPVbyte_nolen (POPs))
-              : strdup ("[fatal error]");
-  FREETMPS;
-  LEAVE;
-  return res;
-}
-int fprintf (object_freezer &freezer, const char *format, ...)
-{
-  va_list ap;
-  va_start (ap, format);
-  int len = vsnprintf ((char *)freezer.force (1024), 1024, format, ap);
-  if (len >= 0)
-    freezer.alloc (len);
-  va_end (ap);
-}
-int fputs (const char *s, object_freezer &freezer)
-{
-  freezer.add (s);
-}
-static const char thawer_eof[] = "\n\n\n\0\0\0";
-object_thawer::object_thawer (const char *filename)
-{
-  static const char eof[] = "\n\n\n\0\0\0";
-  av   = 0;
-  text = 0;
-  line = 0;
-  if (filename)
-    {
-      dSP;
-      ENTER;
-      SAVETMPS;
-      PUSHMARK (SP);
-      XPUSHs (sv_2mortal (newSVpv (filename, 0)));
-      PUTBACK;
-      if (2 == call_pv ("cf::object_thawer_load", G_ARRAY | G_EVAL))
-        {
-          SPAGAIN;
-          // second value - perl objects
-          {
-            SV *sv = POPs;
-            if (SvROK (sv))
-              av = (AV *)SvREFCNT_inc (SvRV (sv));
-          }
-          // first value - text part, pad with 3 zeroes
-          {
-            SV *sv = POPs;
-            STRLEN len;
-            char *sv_ = SvPVbyte (sv, len);
-            text = newSV (len + sizeof (eof));
-            SvCUR_set (text, len);
-            memcpy (SvPVX (text), sv_, len);
-            memcpy (SvEND (text), eof, sizeof (eof)); // just to be sure
-            line = SvPVX (text);
-          }
-        }
-      PUTBACK;
-      FREETMPS;
-      LEAVE;
-    }
-}
-object_thawer::object_thawer (const char *data, AV *perlav)
-{
-  av   = perlav;
-  text = newSVpv (data, 0);
-  sv_catpv (text, thawer_eof);
-  line = SvPVbyte_nolen (text);
-}
-void object_thawer::get (data_type type, void *obj, attachable_base *ext, int oid)
-{
-  if (!av || oid < 0) // this is actually an error of sorts
-    return;
-  // we have to "re-instantiate"/reattach to an object, so nuke ext->attach
-  ext->clear ();
-  SV **svp = av_fetch ((AV *)av, oid, 0);
-  if (!svp || !SvROK (*svp))
-    {
-      printf ("trying to thaw duplicate or never-issued oid %d, ignoring.\n", oid);
-      return;
-    }
-  ext->self = *svp; *svp = &PL_sv_undef;
-  sv_magic (SvRV (ext->self), 0, PERL_MAGIC_ext, (char *)obj, 0);
-  reattach (type, obj);
-}
-object_thawer::~object_thawer ()
-{
-  if (text) SvREFCNT_dec (text);
-  if (av)   SvREFCNT_dec (av);
-}
-char *fgets (char *s, int n, object_thawer &thawer)
-{
-  char *p = thawer.line;
-  char *q = s;
-  if (!p)
-    return 0;
-  while (--n)
-    {
-      if (!*p)
-        break;
-      *q++ = *p;
-      if (*p++ == '\n')
-        break;
-    }
-  *q = 0;
-  thawer.line = p;
-  return s == q ? 0 : s;
-}
-keyword object_thawer::get_kv ()
-{
-  if (!line)
-    return KW_EOF;
-  for (;;)
-    {
-      char *p = line;
-      if (!*p)
-        return KW_EOF;
-      // parse keyword
-      while (*p > ' ')
-        p++;
-      int klen = p - line;
-      if (*p++ != '\n')
-        {
-          // parse value
-          while (*(unsigned char *)p <= ' ' && *p != '\n') // skip 0x01 .. 0x20
-            ++p;
-          last_value = p;
-          while (*p != '\n')
-            p++;
-          *p++ = 0;
-        }
-      else
-        last_value = 0;
-      line [klen] = 0;
-      keyword_idx *kw = kw_lex::match (line, klen);
-      //printf ("KV %d<%s,%s>\n", kw ? kw->index : 0, line, last_value);//D
-      if (kw)
-        {
-          line = p;
-          return kw->index;
-        }
-      else if (!*line || *line == '#')
-        {
-          // empty/comment line
-          line = p;
-        }
-      else
-        return KW_ERROR;
-    }
-}
-void object_thawer::get (shstr &sh) const
-{
-  if (last_value)
-    sh = last_value;
-  else
-    {
-      sh = "<value missing>";
-      LOG (llevError, "keyword requires value: <%s>\n", line);//TODO: add filename
-    }
-}
-void object_thawer::get_ml (keyword kend, shstr &sh)
-{
-  char kw[128];
-  int klen = keyword_len [kend];
-  kw [0] = '\n';
-  memcpy (kw + 1, keyword_str [kend], klen);
-  kw [klen + 1] = '\n';
-  kw [klen + 2] = 0;
-  // first test for completely empty msg... "endXXX\n"
-  if (!strncmp (line, kw + 1, klen + 1))
-    {
-      sh = 0;
-      line += klen + 1;
-      return;
-    }
-  else
-    {
-      // multi-line strings are delimited by "\nendXXX\n" or "endXXX\n" (NULL)
-      char *end = strstr (line, kw);
-      if (!end)
-        {
-          sh = 0;
-          return;
-        }
-      *end = 0;
-      sh = line;
-      line = end + keyword_len [kend] + 1;
-      while (*line++ != '\n')
-        ;
-    }
-}
-sint32 object_thawer::get_sint32 () const
-{
-  char *p = last_value;
-  if (!p)
-    return 0;
-  sint32 val = 0;
-  bool negate;
-  if (*p == '-')
-    {
-      negate = true;
-      ++p;
-    }
-  else
-    negate = false;
-  do
-    {
-      val *= 10;
-      val += *p++ - '0';
-    }
-  while (*p);
-  return negate ? -val : val;
-}
-sint64 object_thawer::get_sint64 () const
-{
-  return last_value ? atoll (last_value) : 0;
-}
-double object_thawer::get_double () const
-{
-  return last_value ? atof (last_value) : 0;
 }
 /////////////////////////////////////////////////////////////////////////////
 extern "C" int cfperl_initPlugin (const char *iversion, f_plug_api gethooksptr)
   PL_exit_flags |= PERL_EXIT_DESTRUCT_END;
   char *argv[] = {
     "",
     "-e"
-    "use Event;"      // required for bootstrap
+    "use Event; use Coro;" // required for bootstrap
-    "cf->bootstrap;"  // required for datadir :*>
+    "cf->bootstrap;"       // required for datadir :*>
     "unshift @INC, cf::datadir ();"
     "require cf;"
   };
   if (perl_parse (perl, xs_init, 2, argv, (char **)NULL) || perl_run (perl))
   dSP;
   PUSHMARK (SP);
   PUTBACK;
   call_pv ("cf::main", G_DISCARD | G_VOID);
+}
+void
+attachable::instantiate ()
+{
+  if (attach)
+    {
+      invoke (EVENT_ATTACHABLE_INSTANTIATE, ARG_STRING (attach), DT_END);
+      attach = 0;
+    }
+}
+void
+attachable::reattach ()
+{
+  optimise ();
+  //TODO: check for _attachment's, very important for restarts
+  invoke (EVENT_ATTACHABLE_REATTACH, DT_END);
 }
 static event_klass klass_of[NUM_EVENT_TYPES] = {
 # define def(type,name) KLASS_ ## type,
 #  include "eventinc.h"
             }
         }
     }
 }
+void
+attachable::gather_callbacks (AV *&callbacks, event_type event) const
+{
+  ::gather_callbacks (callbacks, cb_attachable, event);
+  if (cb)
+    ::gather_callbacks (callbacks, cb, event);
+}
+void
+global::gather_callbacks (AV *&callbacks, event_type event) const
+{
+  ::gather_callbacks (callbacks, cb_object, event);
+}
+void
+object::gather_callbacks (AV *&callbacks, event_type event) const
+{
+  if (subtype && type + subtype * NUM_SUBTYPES <= AvFILLp (cb_type))
+    {
+      SV *registry = AvARRAY (cb_type)[type + subtype * NUM_SUBTYPES];
+      if (registry && SvROK (registry) && SvTYPE (SvRV (registry)) == SVt_PVAV)
+        ::gather_callbacks (callbacks, (AV *)SvRV (registry), event);
+    }
+  if (type <= AvFILLp (cb_type))
+    {
+      SV *registry = AvARRAY (cb_type)[type];
+      if (registry && SvROK (registry) && SvTYPE (SvRV (registry)) == SVt_PVAV)
+        ::gather_callbacks (callbacks, (AV *)SvRV (registry), event);
+    }
+  attachable::gather_callbacks (callbacks, event);
+  ::gather_callbacks (callbacks, cb_object, event);
+}
+void
+archetype::gather_callbacks (AV *&callbacks, event_type event) const
+{
+  attachable::gather_callbacks (callbacks, event);
+  //TODO//::gather_callbacks (callbacks, cb_archetype, event);
+}
+void
+client::gather_callbacks (AV *&callbacks, event_type event) const
+{
+  attachable::gather_callbacks (callbacks, event);
+  ::gather_callbacks (callbacks, cb_client, event);
+}
+void
+player::gather_callbacks (AV *&callbacks, event_type event) const
+{
+  attachable::gather_callbacks (callbacks, event);
+  ::gather_callbacks (callbacks, cb_player, event);
+}
+void
+maptile::gather_callbacks (AV *&callbacks, event_type event) const
+{
+  attachable::gather_callbacks (callbacks, event);
+  ::gather_callbacks (callbacks, cb_map, event);
+}
+bool
-bool cfperl_invoke (event_type event, ...)
+attachable::invoke (event_type event, ...)
 {
   data_type dt;
   va_list ap;
   va_start (ap, event);
-  AV *callbacks = 0;
-  object *op;
-  player *pl;
-  maptile *map;
-  client *ns;
-  // callback call ordering is:
+  // callback call ordering should be:
   // 1. per-object callback
   // 2. per-class object
   // 3. per-type callback
   // 4. global callbacks
+  AV *callbacks = 0;
-  gather_callbacks (callbacks, cb_global, event);
+  gather_callbacks (callbacks, event);
-  switch (KLASS_OF (event))
-    {
-      case KLASS_GLOBAL:
-        break;
-      case KLASS_OBJECT:
-        dt = (data_type) va_arg (ap, int);
-        assert (("first argument must be of type object", dt == DT_OBJECT));
-        op = va_arg (ap, object *);
-        if (op->cb)
-          gather_callbacks (callbacks, op->cb, event);
-        if (op->type)
-          {
-            if (op->subtype && op->type + op->subtype * NUM_SUBTYPES <= AvFILLp (cb_type))
-              {
-                SV *registry = AvARRAY (cb_type)[op->type + op->subtype * NUM_SUBTYPES];
-                if (registry && SvROK (registry) && SvTYPE (SvRV (registry)) == SVt_PVAV)
-                  gather_callbacks (callbacks, (AV *)SvRV (registry), event);
-              }
-            if (op->type <= AvFILLp (cb_type))
-              {
-                SV *registry = AvARRAY (cb_type)[op->type];
-                if (registry && SvROK (registry) && SvTYPE (SvRV (registry)) == SVt_PVAV)
-                  gather_callbacks (callbacks, (AV *)SvRV (registry), event);
-              }
-          }
-        gather_callbacks (callbacks, cb_object, event);
-        break;
-      case KLASS_PLAYER:
-        dt = (data_type) va_arg (ap, int);
-        assert (("first argument must be of type player", dt == DT_PLAYER));
-        pl = va_arg (ap, player *);
-        if (pl->cb)
-          gather_callbacks (callbacks, pl->cb, event);
-        gather_callbacks (callbacks, cb_player, event);
-        break;
-      case KLASS_MAP:
-        dt = (data_type) va_arg (ap, int);
-        assert (("first argument must be of type object", dt == DT_MAP));
-        map = va_arg (ap, maptile *);
-        if (map->cb)
-          gather_callbacks (callbacks, map->cb, event);
-        gather_callbacks (callbacks, cb_map, event);
-        break;
-      case KLASS_CLIENT:
-        dt = (data_type) va_arg (ap, int);
-        assert (("first argument must be of type client", dt == DT_CLIENT));
-        ns = va_arg (ap, client *);
-        if (ns->cb)
-          gather_callbacks (callbacks, ns->cb, event);
-        gather_callbacks (callbacks, cb_client, event);
-        break;
-      default:
-        assert (("unsupported event klass in cfperl_invoke", 0));
-    }
   // short-circuit processing if no callbacks found/defined
   if (!callbacks)
     return 0;
-  dSP;
+  CALL_BEGIN (3);
-  ENTER;
-  SAVETMPS;
-  PUSHMARK (SP);
-  EXTEND (SP, 3);
-  PUSHs (sv_2mortal (newSViv (event))); // only used for debugging nowadays
+  CALL_ARG_SV (newSViv (event)); // only used for debugging nowadays
-  PUSHs (sv_2mortal (newRV_noinc ((SV *)callbacks)));
+  CALL_ARG_SV (newRV_noinc ((SV *)callbacks));
-  switch (KLASS_OF (event))
+  //TODO: unhack
-    {
+  if (object *op = is_a<object>(this))       CALL_ARG_SV (newSVdt (DT_OBJECT, op));
-      case KLASS_OBJECT: PUSHs (sv_2mortal (newSVdt (DT_OBJECT, op)));  break;
+  else if (player *pl = is_a<player>(this))  CALL_ARG_SV (newSVdt (DT_PLAYER, pl));
-      case KLASS_PLAYER: PUSHs (sv_2mortal (newSVdt (DT_PLAYER, pl)));  break;
+  else if (client *ns = is_a<client>(this))  CALL_ARG_SV (newSVdt (DT_CLIENT, ns));
-      case KLASS_CLIENT: PUSHs (sv_2mortal (newSVdt (DT_CLIENT, ns)));  break;
+  else if (maptile *m = is_a<maptile>(this)) CALL_ARG_SV (newSVdt (DT_MAP, m));
-      case KLASS_MAP:    PUSHs (sv_2mortal (newSVdt (DT_MAP,    map))); break;
+  else if (global *gl = is_a<global>(this))  /*nop*/;
-    }
+  else
+    abort (); //TODO
   for (;;)
     {
       dt = (data_type) va_arg (ap, int);
       if (dt == DT_END)
         break;
-      if (dt == DT_AV)
+      else if (dt == DT_AV)
         {
           AV *av = va_arg (ap, AV *);
           for (int i = 0; i <= av_len (av); ++i)
             XPUSHs (*av_fetch (av, i, 1));
         XPUSHs (sv_2mortal (newSVdt_va (ap, dt)));
     }
   va_end (ap);
-  PUTBACK;
+  CALL_CALL ("cf::do_invoke", G_SCALAR);
-  int count = call_pv ("cf::do_invoke", G_SCALAR | G_EVAL);
-  SPAGAIN;
   count = count > 0 ? POPi : 0;
-  FREETMPS;
+  CALL_END;
-  LEAVE;
   return count;
 }
 SV *
   return SvNV (cfperl_result (idx));
 }
 /////////////////////////////////////////////////////////////////////////////
+void
+maptile::emergency_save ()
+{
+  CALL_BEGIN (0);
+  CALL_CALL ("cf::map::emergency_save", G_VOID);
+  CALL_END;
+}
+maptile *
+maptile::load_map_sync (const char *path, maptile *origin)
+{
+  CALL_BEGIN (2);
+  CALL_ARG (path);
+  CALL_ARG (origin);
+  CALL_CALL ("cf::map::load_map_sync", G_SCALAR);
+  maptile *retval;
+  if (count)
+    sv_to (POPs, retval);
+  else
+    retval = 0;
+  CALL_END;
+  return retval;
+}
+void
+maptile::change_all_map_light (int change)
+{
+  CALL_BEGIN (1);
+  CALL_ARG (change);
+  CALL_CALL ("cf::map::change_all_map_light", G_VOID);
+  CALL_END;
+}
+void
+object::enter_exit (object *exit)
+{
+  if (type != PLAYER)
+    return;
+  CALL_BEGIN (2);
+  CALL_ARG (this);
+  CALL_ARG (exit);
+  CALL_CALL ("cf::object::player::enter_exit", G_VOID);
+  CALL_END;
+}
+/////////////////////////////////////////////////////////////////////////////
 struct EventAPI *watcher_base::GEventAPI;
+struct CoroAPI  *coroapi::GCoroAPI;
+int coroapi::cede_counter;
 static void iw_dispatch (pe_event *ev)
 {
   iw *w = (iw *)ev->ext_data;
   w->call (*w);
       pe->poll = events;
       if (pe->poll) start ();
     }
 }
+void
+_connect_to_perl ()
+{
+  stash_cf = gv_stashpv ("cf"        , 1);
+  stash_cf_object_wrap        = gv_stashpv ("cf::object::wrap", 1);
+  stash_cf_object_player_wrap = gv_stashpv ("cf::object::player::wrap", 1);
+  stash_cf_player_wrap	      = gv_stashpv ("cf::player::wrap", 1);
+  stash_cf_map_wrap           = gv_stashpv ("cf::map::wrap"   , 1);
+  stash_cf_client_wrap        = gv_stashpv ("cf::client::wrap", 1);
+  stash_cf_arch_wrap          = gv_stashpv ("cf::arch::wrap"  , 1);
+  stash_cf_party_wrap         = gv_stashpv ("cf::party::wrap" , 1);
+  stash_cf_region_wrap        = gv_stashpv ("cf::region::wrap", 1);
+  stash_cf_living_wrap        = gv_stashpv ("cf::living::wrap", 1);
+  sv_runtime = get_sv ("cf::RUNTIME", 1);
+  sv_upgrade (sv_runtime, SVt_NV);
+  cb_global      = get_av ("cf::CB_GLOBAL", 1);
+  cb_attachable  = get_av ("cf::CB_ATTACHABLE", 1);
+  cb_object      = get_av ("cf::CB_OBJECT", 1);
+  cb_player      = get_av ("cf::CB_PLAYER", 1);
+  cb_client      = get_av ("cf::CB_CLIENT", 1);
+  cb_type        = get_av ("cf::CB_TYPE"  , 1);
+  cb_map         = get_av ("cf::CB_MAP"   , 1);
+}
 MODULE = cf             PACKAGE = cf         PREFIX = cf_
 BOOT:
 {
-  HV *stash = gv_stashpv ("cf", 1);
+  _connect_to_perl ();
-  I_EVENT_API (PACKAGE);
-  watcher_base::GEventAPI = GEventAPI;
+  I_EVENT_API (PACKAGE); watcher_base::GEventAPI = GEventAPI;
+  I_CORO_API  (PACKAGE); coroapi::GCoroAPI       = GCoroAPI;
-  newCONSTSUB (stash, "VERSION", newSVpv (VERSION, sizeof (VERSION) - 1));
+  newCONSTSUB (stash_cf, "VERSION", newSVpv (VERSION, sizeof (VERSION) - 1));
   static const struct {
     const char *name;
     IV iv;
   } *civ, const_iv[] = {
     const_iv (P_BLOCKSVIEW)
     const_iv (P_PLAYER)
     const_iv (P_NO_MAGIC)
     const_iv (P_IS_ALIVE)
     const_iv (P_NO_CLERIC)
-    const_iv (P_NEED_UPDATE)
     const_iv (P_OUT_OF_MAP)
     const_iv (P_NEW_MAP)
+    const_iv (P_UPTODATE)
     const_iv (UP_OBJ_INSERT)
     const_iv (UP_OBJ_REMOVE)
     const_iv (UP_OBJ_CHANGE)
     const_iv (UP_OBJ_FACE)
     const_iv (MAP_IN_MEMORY)
     const_iv (MAP_SWAPPED)
     const_iv (MAP_LOADING)
     const_iv (MAP_SAVING)
+    const_iv (KLASS_ATTACHABLE)
     const_iv (KLASS_GLOBAL)
     const_iv (KLASS_OBJECT)
     const_iv (KLASS_CLIENT)
     const_iv (KLASS_PLAYER)
     const_iv (KLASS_MAP)
     const_iv (ST_CUSTOM)
     const_iv (ST_CHANGE_CLASS)
     const_iv (ST_CONFIRM_QUIT)
     const_iv (ST_GET_PARTY_PASSWORD)
+    const_iv (IO_HEADER)
+    const_iv (IO_OBJECTS)
+    const_iv (IO_UNIQUES)
+    // random map generator
+    const_iv (LAYOUT_NONE)
+    const_iv (LAYOUT_ONION)
+    const_iv (LAYOUT_MAZE)
+    const_iv (LAYOUT_SPIRAL)
+    const_iv (LAYOUT_ROGUELIKE)
+    const_iv (LAYOUT_SNAKE)
+    const_iv (LAYOUT_SQUARE_SPIRAL)
+    const_iv (RMOPT_RANDOM)
+    const_iv (RMOPT_CENTERED)
+    const_iv (RMOPT_LINEAR)
+    const_iv (RMOPT_BOTTOM_C)
+    const_iv (RMOPT_BOTTOM_R)
+    const_iv (RMOPT_IRR_SPACE)
+    const_iv (RMOPT_WALL_OFF)
+    const_iv (RMOPT_WALLS_ONLY)
+    const_iv (RMOPT_NO_DOORS)
+    const_iv (SYMMETRY_RANDOM)
+    const_iv (SYMMETRY_NONE)
+    const_iv (SYMMETRY_X)
+    const_iv (SYMMETRY_Y)
+    const_iv (SYMMETRY_XY)
   };
   for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
-    newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
+    newCONSTSUB (stash_cf, (char *)civ->name, newSViv (civ->iv));
   static const struct {
     const char *name;
     int skip;
     IV klass;
     {
       AV *event = newAV ();
       av_push (event, newSVpv ((char *)eiv->name + eiv->skip, 0));
       av_push (event, newSViv (eiv->klass));
       av_store (av, eiv->iv, newRV_noinc ((SV *)event));
-      newCONSTSUB (stash, (char *)eiv->name, newSViv (eiv->iv));
+      newCONSTSUB (stash_cf, (char *)eiv->name, newSViv (eiv->iv));
     }
 }
-void _init_vars ()
+void _connect_to_perl ()
-	CODE:
-        cb_global  = get_av ("cf::CB_GLOBAL", 1);
-        cb_object  = get_av ("cf::CB_OBJECT", 1);
-        cb_player  = get_av ("cf::CB_PLAYER", 1);
-        cb_client  = get_av ("cf::CB_CLIENT", 1);
-        cb_type    = get_av ("cf::CB_TYPE"  , 1);
-        cb_map     = get_av ("cf::CB_MAP"   , 1);
 void _global_reattach ()
 	CODE:
 {
         // reattach to all attachable objects in the game.
         for (sockvec::iterator i = clients.begin (); i != clients.end (); ++i)
-          reattach (*i);
+          (*i)->reattach ();
-        for (player *pl = first_player; pl; pl = pl->next)
+        for_all_players (pl)
-          reattach (pl);
+          pl->reattach ();
-        for (maptile *map = first_map; map; map = map->next)
+        //TODO
-          reattach (map);
+        //for (map_container::iterator i = maps.begin (); i != maps.end (); ++i)
+        //  i->second->reattach ();
         for (object *op = object::first; op; op = op->next)
-          reattach (op);
+          op->reattach ();
 }
 NV floor (NV x)
 NV ceil (NV x)
 void server_tick ()
+	CODE:
+        runtime = SvNVx (sv_runtime);
+        server_tick ();
 void
 LOG (int level, char *msg)
 	PROTOTYPE: $$
 	C_ARGS: (LogLevel)level, "%s", msg
             case 5: RETVAL = settings.playerdir; break;
             case 6: RETVAL = settings.datadir  ; break;
           }
 	OUTPUT: RETVAL
+void abort ()
+void emergency_save ()
 void _exit (int status = 0)
 int find_animation (char *text)
 	PROTOTYPE: $
 	CODE:
         RETVAL = SvROK (obj) && mg_find (SvRV (obj), PERL_MAGIC_ext);
 	OUTPUT:
 	RETVAL
+#bool
+#destroyed (attachable *at)
+#
+#void
+#destroy (attachable *at)
 MODULE = cf        PACKAGE = cf::global
 int invoke (SV *klass, int event, ...)
 	CODE:
         if (KLASS_OF (event) != KLASS_GLOBAL) croak ("event class must be GLOBAL");
 	AV *av = (AV *)sv_2mortal ((SV *)newAV ());
         for (int i = 1; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
-        RETVAL = INVOKE_((event_type)event, ARG_AV (av));
+        RETVAL = gbl_ev.invoke ((event_type)event, ARG_AV (av), DT_END);
 	OUTPUT: RETVAL
 MODULE = cf        PACKAGE = cf::object         PREFIX = cf_object_
 INCLUDE: $PERL genacc object ../include/object.h |
 int invoke (object *op, int event, ...)
 	CODE:
         if (KLASS_OF (event) != KLASS_OBJECT) croak ("event class must be OBJECT");
 	AV *av = (AV *)sv_2mortal ((SV *)newAV ());
         for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
-        RETVAL = INVOKE_((event_type)event, ARG_OBJECT (op), ARG_AV (av));
+        RETVAL = op->invoke ((event_type)event, ARG_AV (av), DT_END);
 	OUTPUT: RETVAL
 SV *registry (object *op)
 void mortals ()
 void
 set_animation (object *op, int idx)
 	CODE:
         SET_ANIMATION (op, idx);
-void
-object::drain_stat ()
-void
-object::drain_specific_stat (int stat)
-void
-object::change_luck (int change)
-void
-object::add_statbonus ()
-void
-object::remove_statbonus ()
 object *find_best_object_match (object *op, const char *match)
 object *find_marked_object (object *op)
-int need_identify (const object *obj);
+int need_identify (object *obj);
 int apply_shop_mat (object *shop_mat, object *op);
 int move (object *op, int dir, object *originator = op)
 	CODE:
 void apply_below (object *op)
 	CODE:
         player_apply_below (op);
-void remove (object *op)
-	CODE:
-        op->remove ();
-void
-object::destroy (int recursive = 0)
 object *cf_object_present_archname_inside (object *op, char *whatstr)
 int cf_object_transfer (object *op, int x, int y, int r = 0, object_ornull *orig = 0)
 int cf_object_change_map (object *op, int x, int y, maptile *map)
+#//TODO
-object *clone (object *op, int recursive = 0)
+object *clone_ (object *op, int recursive = 0)
 	CODE:
         if (recursive)
           RETVAL = object_create_clone (op);
         else
 	  {
 	OUTPUT: RETVAL
 int query_money (object *op)
 	ALIAS: money = 0
-int query_cost (object *op, object *who, int flags)
+val64 query_cost (object *op, object *who, int flags)
 	ALIAS: cost = 0
 void spring_trap (object *op, object *victim)
 int check_trigger (object *op, object *cause)
 player *contr (object *op)
 	CODE:
         RETVAL = op->contr;
         OUTPUT: RETVAL
-void
-object::roll_stats ()
-void
-object::update_stats ()
-void
-object::swap_stats (int a, int b)
 const char *get_ob_key_value (object *op, const char *key)
 bool set_ob_key_value (object *op, const char *key, const char *value = 0, int add_key = 1)
         RETVAL = op->contr;
 	OUTPUT: RETVAL
 void check_score (object *op)
-void cf_player_message (object *obj, char *txt, int flags = NDI_ORANGE | NDI_UNIQUE)
+void message (object *op, char *txt, int flags = NDI_ORANGE | NDI_UNIQUE)
+	CODE:
+        new_draw_info (flags, 0, op, txt);
 object *cf_player_send_inventory (object *op)
 char *cf_player_get_ip (object *op)
 	ALIAS: ip = 0
 void esrv_update_item (object *op, int what, object *item)
         C_ARGS: what, op, item
 void clear_los (object *op)
-int command_reset (object *op, char *params)
 int command_teleport (object *op, char *params)
 int command_summon (object *op, char *params)
 int invoke (player *pl, int event, ...)
 	CODE:
         if (KLASS_OF (event) != KLASS_PLAYER) croak ("event class must be PLAYER");
 	AV *av = (AV *)sv_2mortal ((SV *)newAV ());
         for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
-        RETVAL = INVOKE_((event_type)event, ARG_PLAYER (pl), ARG_AV (av));
+        RETVAL = pl->invoke ((event_type)event, ARG_AV (av), DT_END);
 	OUTPUT: RETVAL
 SV *registry (player *pl)
-player *
-create ()
-	CODE:
-        RETVAL = player::create ();
-	OUTPUT:
-        RETVAL
-player *
-load (const char *path)
-	CODE:
-        RETVAL = player::load (path);
-	OUTPUT:
-        RETVAL
-void
-player::save (bool final = false)
-void
-player::connect (client *ns)
 void
 save_stats (player *pl)
 	CODE:
         pl->ob->stats.hp    = pl->ob->stats.maxhp;
         OUTPUT: RETVAL
 MODULE = cf        PACKAGE = cf::map            PREFIX = cf_map_
-maptile *first ()
-	PROTOTYPE:
-        CODE:
-        RETVAL = first_map;
-        OUTPUT: RETVAL
 int invoke (maptile *map, int event, ...)
 	CODE:
         if (KLASS_OF (event) != KLASS_MAP) croak ("event class must be MAP");
 	AV *av = (AV *)sv_2mortal ((SV *)newAV ());
         for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
-        RETVAL = INVOKE_((event_type)event, ARG_MAP (map), ARG_AV (av));
+        RETVAL = map->invoke ((event_type)event, ARG_AV (av), DT_END);
 	OUTPUT: RETVAL
 SV *registry (maptile *map)
 INCLUDE: $PERL genacc maptile ../include/map.h |
-maptile *new (int width, int height)
+void
+maptile::instantiate ()
+maptile *new ()
 	PROTOTYPE:
 	CODE:
-{
+        RETVAL = new maptile;
-        RETVAL = get_empty_map (width, height);
-}
 	OUTPUT:
         RETVAL
-void delete_map (maptile *map)
+void
+maptile::destroy ()
-void clean_tmp_map (maptile *map)
+void
+maptile::players ()
+	PPCODE:
+        if (GIMME_V == G_SCALAR)
+          XPUSHs (sv_2mortal (to_sv (THIS->players)));
+        else if (GIMME_V == G_ARRAY)
+          {
+            EXTEND (SP, THIS->players);
+            for_all_players (pl)
+              if (pl->ob && pl->ob->map == THIS)
+                PUSHs (sv_2mortal (to_sv (pl->ob)));
+          }
 void play_sound_map (maptile *map, int x, int y, int sound_num)
 int out_of_map (maptile *map, int x, int y)
-maptile *tile_map (maptile *map, unsigned int dir)
-	CODE:
-        RETVAL = dir < 4 ? map->tile_map [dir] : 0;
-	OUTPUT:
-        RETVAL
-char *tile_path (maptile *map, unsigned int dir)
-	CODE:
-        if (dir >= 4)
-          XSRETURN_UNDEF;
-        RETVAL = map->tile_path [dir];
-	OUTPUT:
-        RETVAL
-maptile *ready_map_name (char *name, int flags = 0)
-	PROTOTYPE: $;$
-	ALIAS:
-        find    = 0
-        get_map = 1
-maptile *has_been_loaded (char *name)
-	PROTOTYPE: $
-int in_memory (maptile *map)
-	CODE:
-        RETVAL = map->in_memory;
-	OUTPUT:
-        RETVAL
 void
 trigger (maptile *map, long connection, bool state = true)
         CODE:
         activate_connection (map, connection, state);
           move_block_at = 4
           move_slow_at  = 5
           move_on_at    = 6
           move_off_at   = 7
         INIT:
-	if (x >= MAP_WIDTH (obj) || y >= MAP_HEIGHT (obj)) XSRETURN_UNDEF;
+	if (x >= obj->width || y >= obj->height) XSRETURN_UNDEF;
         CODE:
         switch (ix)
           {
             case 0: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_OB         (obj, x, y)); break;
             case 1: RETVAL = newSVcfapi (CFAPI_POBJECT, GET_MAP_TOP        (obj, x, y)); break;
             case 4: RETVAL = newSVuv    (               GET_MAP_MOVE_BLOCK (obj, x, y)); break;
             case 5: RETVAL = newSVuv    (               GET_MAP_MOVE_SLOW  (obj, x, y)); break;
             case 6: RETVAL = newSVuv    (               GET_MAP_MOVE_ON    (obj, x, y)); break;
             case 7: RETVAL = newSVuv    (               GET_MAP_MOVE_OFF   (obj, x, y)); break;
           }
-        OUTPUT:
+        OUTPUT: RETVAL
+void fix_walls (maptile *map, int x, int y)
+void fix_walls_around (maptile *map, int x, int y)
+const char *
+region_name (maptile *m)
+	CODE:
+        RETVAL = get_name_of_region_for_map (m);
+	OUTPUT: RETVAL
+# worst xs function of my life
+maptile *
+_create_random_map (\
+	char *path,\
+	char *wallstyle,\
+	char *wall_name,\
+	char *floorstyle,\
+	char *monsterstyle,\
+	char *treasurestyle,\
+	char *layoutstyle,\
+	char *doorstyle,\
+	char *decorstyle,\
+	char *origin_map,\
+	char *final_map,\
+	char *exitstyle,\
+	char *this_map,\
+	char *exit_on_final_map,\
+	int Xsize,\
+	int Ysize,\
+	int expand2x,\
+	int layoutoptions1,\
+	int layoutoptions2,\
+	int layoutoptions3,\
+	int symmetry,\
+	int difficulty,\
+	int difficulty_given,\
+	float difficulty_increase,\
+	int dungeon_level,\
+	int dungeon_depth,\
+	int decoroptions,\
+	int orientation,\
+	int origin_y,\
+	int origin_x,\
+	int random_seed,\
+	val64 total_map_hp,\
+	int map_layout_style,\
+	int treasureoptions,\
+	int symmetry_used,\
+	region *region\
+)
+	CODE:
+{
+  	random_map_params rmp;
+        assign (rmp.wallstyle        , wallstyle);
+        assign (rmp.wall_name        , wall_name);
+        assign (rmp.floorstyle       , floorstyle);
+        assign (rmp.monsterstyle     , monsterstyle);
+        assign (rmp.treasurestyle    , treasurestyle);
+        assign (rmp.layoutstyle      , layoutstyle);
+        assign (rmp.doorstyle        , doorstyle);
+        assign (rmp.decorstyle       , decorstyle);
+        assign (rmp.exitstyle        , exitstyle);
+        assign (rmp.exit_on_final_map, exit_on_final_map);
+        rmp.origin_map          = origin_map;
+        rmp.final_map           = final_map;
+        rmp.this_map            = this_map;
+        rmp.Xsize               = Xsize;
+        rmp.Ysize               = Ysize;
+        rmp.expand2x            = expand2x;
+        rmp.layoutoptions1      = layoutoptions1;
+        rmp.layoutoptions2      = layoutoptions2;
+        rmp.layoutoptions3      = layoutoptions3;
+        rmp.symmetry            = symmetry;
+        rmp.difficulty          = difficulty;
+        rmp.difficulty_given    = difficulty_given;
+        rmp.difficulty_increase = difficulty_increase;
+        rmp.dungeon_level       = dungeon_level;
+        rmp.dungeon_depth       = dungeon_depth;
+        rmp.decoroptions        = decoroptions;
+        rmp.orientation         = orientation;
+        rmp.origin_y            = origin_y;
+        rmp.origin_x            = origin_x;
+        rmp.random_seed         = random_seed;
+        rmp.total_map_hp        = total_map_hp;
+        rmp.map_layout_style    = map_layout_style;
+        rmp.treasureoptions     = treasureoptions;
+        rmp.symmetry_used       = symmetry_used;
+        rmp.region              = region;
+        RETVAL = generate_random_map (path, &rmp);
+}
+	OUTPUT:
         RETVAL
-void fix_walls (maptile *map, int x, int y)
-void fix_walls_around (maptile *map, int x, int y)
 MODULE = cf        PACKAGE = cf::arch
 archetype *find (const char *name)
         CODE:
 	PROTOTYPE:
         CODE:
         RETVAL = get_firstparty ();
         OUTPUT: RETVAL
-partylist *next (partylist *party)
+INCLUDE: $PERL genacc partylist ../include/player.h |
-        CODE:
-        RETVAL = party->next;
-        OUTPUT: RETVAL
-const char *name (partylist *party)
-        CODE:
-        RETVAL = party->partyname;
-        OUTPUT: RETVAL
-const char *password (partylist *party)
-        CODE:
-        RETVAL = party->passwd;
-        OUTPUT: RETVAL
 MODULE = cf        PACKAGE = cf::region
-region  *first ()
+region *first ()
 	PROTOTYPE:
         CODE:
         RETVAL = first_region;
         OUTPUT: RETVAL
-region *next (region *reg)
+region *find (char *name)
+	PROTOTYPE: $
         CODE:
-        RETVAL = reg->next;
+        RETVAL = get_region_by_name (name);
         OUTPUT: RETVAL
-const char *name (region *reg)
+INCLUDE: $PERL genacc region ../include/map.h |
-        CODE:
-        RETVAL = reg->name;
-        OUTPUT: RETVAL
-region *parent (region *reg)
-        CODE:
-        RETVAL = reg->parent;
-        OUTPUT: RETVAL
-const char *longname (region *reg)
-        CODE:
-        RETVAL = reg->longname;
-        OUTPUT: RETVAL
-const char *msg (region *reg)
-        CODE:
-        RETVAL = reg->msg;
-        OUTPUT: RETVAL
 MODULE = cf        PACKAGE = cf::living
 INCLUDE: $PERL genacc living ../include/living.h |
 int invoke (client *ns, int event, ...)
 	CODE:
         if (KLASS_OF (event) != KLASS_CLIENT) croak ("event class must be CLIENT");
 	AV *av = (AV *)sv_2mortal ((SV *)newAV ());
         for (int i = 2; i < items; i++) av_push (av, SvREFCNT_inc (ST (i)));
-        RETVAL = INVOKE_((event_type)event, ARG_CLIENT (ns), ARG_AV (av));
+        RETVAL = ns->invoke ((event_type)event, ARG_AV (av), DT_END);
 	OUTPUT: RETVAL
 SV *registry (client *ns)
 void
 	PPCODE:
         EXTEND (SP, clients.size ());
         for (sockvec::iterator i = clients.begin (); i != clients.end (); ++i)
           PUSHs (sv_2mortal (to_sv (*i)));
-client *
-create (int fd, const char *peername)
-	CODE:
-        RETVAL = client::create (fd, peername);
-	OUTPUT:
-        RETVAL
 void
 client::send_packet (SV *packet)
 	CODE:
 {
 	STRLEN len;

Diff Legend

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

Comparing deliantra/server/server/cfperl.xs (file contents): Revision 1.106 by root, Sat Dec 23 15:49:40 2006 UTC vs. Revision 1.124 by root, Mon Jan 1 00:41:03 2007 UTC

Diff Legend

Comparing deliantra/server/server/cfperl.xs (file contents):
Revision 1.106 by root, Sat Dec 23 15:49:40 2006 UTC vs.
Revision 1.124 by root, Mon Jan 1 00:41:03 2007 UTC