diff --git a/secure/simul_efun/livings.c b/secure/simul_efun/livings.c
new file mode 100644
index 0000000..160fcee
--- /dev/null
+++ b/secure/simul_efun/livings.c
@@ -0,0 +1,348 @@
+// * living_name-Behandlung
+
+#define clean_log(s)
+//#define clean_log(s) log_file("CLEAN_SIM",ctime(time())[4..18]+": "+(s));
+
+private nosave mapping living_name_m, name_living_m, netdead;
+
+private void InitLivingData(mixed wizinfo) {
+  // living_name ist ein Pointer der auch in der extra_wizinfo gehalten 
+  // wird, so kann die simul_efun neu geladen werden, ohne dass dieses
+  // Mapping verloren geht
+  if (!mappingp(living_name_m = wizinfo[LIVING_NAME]))
+    living_name_m = wizinfo[LIVING_NAME] = m_allocate(0, 1);
+
+  // Gleiches gilt fuer das Mapping Name-Living
+  if (!mappingp(name_living_m = wizinfo[NAME_LIVING]))
+    name_living_m = wizinfo[NAME_LIVING] = m_allocate(0, 1);
+
+  // Netztote sind ebenfalls in der extra_wizinfo
+  if (!mappingp(netdead = wizinfo[NETDEAD_MAP]))
+    netdead = wizinfo[NETDEAD_MAP] = ([]);
+}
+
+public varargs string getuuid( object ob )
+{
+    mixed *ret;
+
+    if ( !objectp(ob) )
+       ob = previous_object();
+
+    if ( !query_once_interactive(ob) )
+       return getuid(ob);
+
+    ret = (mixed)master()->get_userinfo( getuid(ob) );
+
+    if ( !pointerp(ret) || sizeof(ret) < 5 )
+       return getuid(ob);
+
+    // Username + "_" + CreationDate
+    return ret[0] + "_" + ret[5];
+}
+
+void set_object_living_name(string livname, object obj)
+{
+  string old;
+  mixed a;
+  int i;
+
+  if (previous_object()==obj || previous_object()==this_object() ||
+      previous_object()==master())
+  {
+    if(!livname || !stringp(livname)) {
+      set_this_object(previous_object());
+      raise_error(sprintf("%O: illegal living name: %O\n", obj, livname));
+    }
+    if (old = living_name_m[obj]) {
+      if (pointerp(a = name_living_m[old])) {
+       a[member(a, obj)] = 0;
+      } else {
+       m_delete(name_living_m, old);
+      }
+    }
+    living_name_m[obj] = livname;
+    if (a = name_living_m[livname]) {
+      if (!pointerp(a)) {
+       name_living_m[livname] = ({a, obj});
+       return;
+      }
+      /* Try to reallocate entry from destructed object */
+      if ((i = member(a, 0)) >= 0) {
+       a[i] = obj;
+       return;
+      }
+      name_living_m[livname] = a + ({obj});
+      return;
+    }
+    name_living_m[livname] = obj;
+  }
+}
+
+void set_living_name(string livname)
+{
+  set_object_living_name(livname,previous_object());
+}
+
+void remove_living_name()
+{
+  string livname;
+
+  if (!previous_object())
+    return;
+  if (livname=living_name_m[previous_object()])
+  {
+    m_delete(living_name_m,previous_object());
+    if (objectp(name_living_m[livname]))
+    {
+      if (name_living_m[livname]==previous_object())
+       m_delete(name_living_m,livname);
+      return;
+    }
+    if (pointerp(name_living_m[livname]))
+    {
+      name_living_m[livname]-=({previous_object()});
+      if (!sizeof(name_living_m[livname]))
+       m_delete(name_living_m,livname);
+    }
+  }
+}
+
+void _set_netdead()
+{
+  if (query_once_interactive(previous_object()))
+    netdead[getuid(previous_object())]=previous_object();
+}
+
+void _remove_netdead()
+{
+  m_delete(netdead,getuid(previous_object()));
+}
+
+object find_netdead(string uuid)
+{
+  int i;
+  string uid;
+  // Wenn sscanf() 2 liefert, ist uuid auch ne uuid.
+  int is_uuid = sscanf(uuid, "%s_%d", uid, i) == 2;
+  if (!is_uuid)
+    uid = uuid;
+ 
+  if (is_uuid && getuuid(netdead[uid]) != uuid)
+      return 0;
+
+  return netdead[uid];
+}
+
+string *dump_netdead()
+{
+  return m_indices(netdead);
+}
+
+object find_living(string livname) {
+  mixed *a, r;
+  int i;
+
+  if (pointerp(r = name_living_m[livname])) {
+    if (member(r,0)>=0)
+      r-=({0});
+    if (!sizeof(r)){
+      m_delete(name_living_m,livname);
+      clean_log(sprintf("find_living loescht %s\n",livname));
+      return 0;
+    }
+    if ( !living(r = (a = r)[0])) {
+      for (i = sizeof(a); --i;) {
+       if (living(a[<i])) {
+         r = a[<i];
+         a[<i] = a[0];
+         return a[0] = r;
+       }
+      }
+    }
+    return r;
+  }
+  return living(r) && r;
+}
+
+object *find_livings(string livname)
+{
+  mixed r;
+
+  if (pointerp(r=name_living_m[livname]))
+    r-=({0});
+  else
+    if (objectp(r))
+      r=({r});
+  if (!pointerp(r)||!sizeof(r))
+    return 0;
+  return r;
+}
+
+object find_player(string uuid) {
+  object *objs;
+  mixed res;
+  int i;
+  string uid;
+
+  if (!stringp(uuid))
+    return 0;
+  // Wenn sscanf() 2 liefert, ist uuid auch ne uuid.
+  int is_uuid = sscanf(uuid, "%s_%d", uid, i) == 2;
+  if (!is_uuid)
+    uid = uuid;
+
+  if (pointerp(res = name_living_m[uid])) {
+    // zerstoerte Objekte ggf. entfernen
+    if (member(res,0)>=0) {
+      res-=({0});
+      name_living_m[uid] = res;
+    }
+    // ggf. Namen ohne Objekte entfernen.
+    if (!sizeof(res)){
+      m_delete(name_living_m,uid);
+      clean_log(sprintf("find_player loescht %s\n",uid));
+      return 0;
+    }
+    objs = res;
+    res = objs[0];
+    // Wenn das 0. Element der Spieler ist, sind wir fertig. Ansonsten suchen
+    // wir den Spieler und schieben ihn an die 0. Stelle im Array.
+    if ( !query_once_interactive(res)) {
+      for (i = sizeof(objs); --i;) {
+       if (objs[<i] && query_once_interactive(objs[<i])) {
+         res = objs[<i];
+         objs[<i] = objs[0];
+         objs[0] = res;
+         break;
+       }
+      }
+      res = (objectp(res) && query_once_interactive(res)) ? res : 0;
+    }
+    // else: in res steht der Spieler schon.
+  }
+  else if (objectp(res)) // r ist nen Einzelobjekt
+    res = query_once_interactive(res) ? res : 0;
+
+  // res ist jetzt ggf. der Spieler. Aber wenn der ne andere als die gesuchte
+  // UUID hat, ist das Ergebnis trotzdem 0.
+  if (is_uuid && getuuid(res)!=uuid)
+      return 0;
+
+  // endlich gefunden
+  return res;
+}
+
+private int check_match( string str, int players_only )
+{
+    mixed match;
+
+    if ( !(match = name_living_m[str]) )
+       return 0;
+
+    if ( !pointerp(match) )
+       match = ({ match });
+
+    match -= ({0});
+
+    if ( sizeof(match) ){
+       if ( players_only )
+           return sizeof(filter( match, #'query_once_interactive/*'*/ ))
+              > 0;
+       else
+           return 1;
+    }
+
+    m_delete( name_living_m, str );
+    clean_log( sprintf("check_match loescht %s\n", str) );
+    return 0;
+}
+
+//TODO:: string|string* exclude
+varargs mixed match_living( string str, int players_only, mixed exclude )
+{
+    int i, s;
+    mixed match, *user;
+
+    if ( !str || str == "" )
+       return 0;
+
+    if ( !pointerp(exclude) )
+       exclude = ({ exclude });
+
+    if ( member(exclude, str) < 0 && check_match(str, players_only) )
+       return str;
+
+    user = m_indices(name_living_m);
+    s = sizeof(str);
+    match = 0;
+
+    for ( i = sizeof(user); i--; )
+       if ( str == user[i][0..s-1] && member( exclude, user[i] ) < 0 )
+           if ( match )
+              return -1;
+           else
+              if ( check_match(user[i], players_only) )
+                  match = user[i];
+
+    if ( !match )
+       return -2;
+
+    return match;
+}
+
+mixed *dump_livings()
+{
+  return sort_array(m_indices(name_living_m),#'>);
+}
+
+// * regelmaessig Listen von Ballast befreien
+private void clean_name_living_m(string *keys, int left, int num)
+{
+  int i, j;
+  mixed a;
+
+  while (left && num--)
+  {
+    if (pointerp(a = name_living_m[keys[--left]]) && member(a, 0)>=0)
+    {
+      a-=({0});
+      name_living_m[keys[left]] = a;
+    }
+    if (!a || (pointerp(a) && !sizeof(a)))
+    {
+      clean_log("Toasting "+keys[left]+"\n");
+      m_delete(name_living_m, keys[left]);
+    } else clean_log(sprintf("KEEPING %s (%O)\n",keys[left],pointerp(a)?sizeof(a):a));
+  }
+  if (left)
+    efun::call_out(#'clean_name_living_m, 1, keys, left, 80);
+  else
+    clean_log("Clean process finished\n");
+}
+
+private void clean_netdead() {
+  int i;
+  string *s;
+  object ob;
+
+  s=m_indices(netdead);
+  for (i=sizeof(s)-1;i>=0;i--)
+    if (!objectp(ob=netdead[s[i]]) || interactive(ob))
+      m_delete(netdead,s[i]);
+}
+
+private void CleanLivingData() {
+  if (find_call_out(#'clean_name_living_m) < 0) {
+    clean_log("Starting clean process\n");
+    efun::call_out(#'clean_name_living_m,
+                 1,
+                 m_indices(name_living_m),
+                 sizeof(name_living_m),
+                 80
+                 );
+  }
+  efun::call_out(#'clean_netdead,2);
+}
+
+#undef clean_log
+