Added public files
Roughly added all public files. Probably missed some, though.
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
+