diff --git a/std/thing/properties.c b/std/thing/properties.c
new file mode 100644
index 0000000..06592bf
--- /dev/null
+++ b/std/thing/properties.c
@@ -0,0 +1,326 @@
+// MorgenGrauen MUDlib
+//
+// thing/properties.c -- most general class (property handling)
+//
+// $Id: properties.c 6951 2008-08-09 23:08:31Z Zesstra $
+
+// Properties.c -- Propertyverwaltung
+// (c) 1993 Hate@MorgenGrauen, Mateese@NightFall
+//          Idea and Code      Flames and Destructions
+// -> *grin* thats the point actually :) 
+//
+// Ueberarbeitet von Jof       am 12.06.1994
+// Ueberarbeitet von Mandragon am 11.05.2003
+
+#pragma strict_types
+#pragma save_types
+#pragma range_check
+#pragma no_clone
+#pragma pedantic
+
+#define NEED_PROTOTYPES
+
+#include "/sys/thing/properties.h"
+#include "/secure/wizlevels.h"
+
+
+// the mapping where the actual properties are stored. Direct initialization.
+private nosave mapping *prop = ({ ([]), ([]), ([]), ([]) });
+
+// the mapping that is used for saving
+private mapping properties;
+
+// security-flag
+private nosave int closure_call;
+
+// Initialisierung der Props. Kann leider momentan nicht private sein, weil
+// Padreic son komisches Objekt hat, was die Funktion hier ruft.
+// TODO: irgendwann mal private machen.
+// TODO: Da props jetzt einfach bei der Deklaration initlisiert wird,
+// eruebrigt sich diese Funktion eigentlich. Bis auf Padreics Objekt...
+protected void InitializeProperties() {
+  prop = ({ ([]), ([]), ([]), ([]) });
+  return;
+}
+
+// Props nur dann initialisieren, wenn sie es noch nicht sind
+protected void create() {
+  // Blueprints in /std benoetigenkeinen Reset ....
+  if (object_name()=="/std/thing/properties")
+    set_next_reset(-1);
+}
+
+protected void create_super() {
+  set_next_reset(-1);
+}
+
+// Welche externen Objekte duerfen zugreifen?
+nomask private int allowed()
+{
+    if ( (previous_object() && IS_ARCH(getuid(previous_object())) &&
+          this_interactive() && IS_ARCH(this_interactive())) ||
+         (previous_object() && getuid(previous_object()) == ROOTID &&
+          geteuid(previous_object()) == ROOTID) )
+        return 1;
+    return 0;
+}
+
+
+// Set() -- provides direct access to a property, no filters
+public varargs mixed Set( string name, mixed Value, int Type, int extern )
+{
+
+  if (!objectp(this_object()))
+    return 0;
+
+  // Properties, die SECURED oder PROTECTED sind, duerfen nur vom Objekt
+  // selber, EM+ oder ROOT veraendert werden
+  if ((prop[F_MODE][name]&(PROTECTED|SECURED))&&
+      (closure_call||extern||extern_call()) &&
+       previous_object() != this_object() && !allowed())
+    return -1;
+  
+  // Das SECURED-Flag darf bei Properties nicht mehr geloescht werden
+  if ((prop[F_MODE][name]&SECURED)&&
+      (Type==F_MODE||Type==F_MODE_AD)&&(Value & SECURED))
+    return -2;
+  
+  // Setzen duerfen das SECURED-Flag nur das Objekt selber, EM+ oder ROOT
+  if ((Type==F_MODE||Type==F_MODE_AS)&&(Value&SECURED)&&
+      (closure_call ||extern || extern_call()) &&
+       previous_object() != this_object() && !allowed() )
+    return -3;
+
+  switch(Type)
+  {
+    // Je nach Modus Flags veraendern
+    case F_MODE_AS:  prop[F_MODE][name]|= Value;
+                     return prop[F_MODE][name];
+    case F_MODE_AD:  prop[F_MODE][name]&= ~Value;
+                     if (!prop[F_MODE][name]) prop[F_MODE]-=([name]);
+                     return prop[F_MODE][name];
+    case F_MODE:     prop[F_MODE][name]^= Value;
+                     if (!prop[F_MODE][name]) prop[F_MODE]-=([name]);
+                     return prop[F_MODE][name];
+    case F_SET_METHOD:
+      // -1 als Setz-Methode: Nosetmethod setzen
+      if (Value == -1)
+      {
+        prop[F_SET_METHOD]-=([name]);
+        prop[F_MODE][name] |= NOSETMETHOD;
+        return 0;
+      }
+      // Kein break!
+    case F_QUERY_METHOD:
+      // Ungebundene Lambda_Closure? Binden!
+      if (closurep(Value)&&!query_closure_object(Value))
+      {
+        if (extern_call() &&
+             (getuid(previous_object()) != getuid()||
+              geteuid(previous_object()) != geteuid()))
+          return prop[Type][name];
+        
+        Value = bind_lambda( Value,this_object());
+      }
+      // Kein break!
+    default:
+      if (!Value) prop[Type]-=([name]);
+      else prop[Type][name] = Value;
+  }
+
+  // Gesamtwert zurueckgeben
+  return prop[Type][name];
+}
+
+
+// Direktes Auslesen der Property ohne Filter ...
+public varargs mixed Query( string name, int Type )
+{
+    if (pointerp(prop)) return prop[Type][name];
+    return 0;
+}
+
+// Property setzen unter Verwendung evtl. vorhandener Zugriffsfunktionen
+public mixed SetProp( string name, mixed Value )
+{
+  closure func;
+  mixed result;
+   
+  // nur fuer heute
+  if (!objectp(this_object()))
+    return 0;
+
+  // NOSETMETHOD: Darf nicht gesetzt werden
+  if (prop[F_MODE][name] & NOSETMETHOD ) return -1;
+
+  // Set-Method abfragen, so vorhanden
+  if (func=prop[F_SET_METHOD][name])
+  {
+    int flag;
+
+    // Wert als Set-Method? gleich zurueckgeben
+    if (!closurep(func)) return func;
+
+    // An dieser Stelle muss func eine Closure sein. Da Set() ungebundene
+    // Lambdas bindet, kann es auch nur eine gebundene Closure sein und das
+    // Objekt existiert auch noch (sonst waere func == 0).
+
+    // closure_call setzen, falls noch nicht gesetzt
+    if ((flag=closure_call<time()))
+      closure_call = time()+59;
+
+    // Dann mal die Closure aufrufen. Bei Fehler selbige loeschen
+    if (catch(result=funcall(func, Value, name);publish))
+    {
+      prop[F_SET_METHOD]-=([name]);
+    }
+      
+    // Wenn closure_call gesetzt wurde, wieder loeschen
+    if (flag) closure_call = 0;
+
+    // Und zurueckgeben
+    return result; 
+  }
+
+  // _set_*-Methode vorhanden? falls ja, aufrufen.i
+  // TODO: Closurecache einfuehren und Funktionaufruf nur noch machen, wenn es
+  // die _set_* auch gibt?
+  if (call_resolved(&result,this_object(),"_set_"+name,Value ))
+        return result;
+
+  // Letzte Moeglichkeit: Muss eine 'normale' Property sein
+  return Set( name, Value, F_VALUE, extern_call() );
+}
+
+
+// Property auslesen unter Verwendung evtl. vorhandener Zugriffsfunktionen
+public mixed QueryProp( string name )
+{
+  closure func;
+  mixed result;
+ 
+  // nur fuer heute
+  if (!objectp(this_object()))
+    return;
+
+  // Query-Methode vorhanden?
+  if ( func = prop[F_QUERY_METHOD][name] )
+  {
+    int flag;
+
+    // Wert als Query-Method? Gleich zurueckgeben ...
+    if (!closurep(func)) return func;
+ 
+    // An dieser Stelle muss func eine Closure sein. Da Set() ungebundene
+    // Lambdas bindet, kann es auch nur eine gebundene Closure sein und das
+    // Objekt existiert auch noch (sonst waere func == 0).
+   
+    // closure_call setzen, falls noch nicht gesetzt
+    if ((flag=closure_call<time()))
+      closure_call = time()+59;
+    
+    // Dann Mal die Closure aufrufen. Bei Fehler selbige loeschen
+    if (catch(result=funcall(func);publish))
+    {
+      prop[F_QUERY_METHOD]-=([name]);
+    }
+    // Wenn closure_call gesetzt wurde, wieder loeschen    
+    if (flag) closure_call = 0;
+    
+    // Und zurueckgeben
+    return result;
+  }
+  
+  // _query_*-Methode vorhanden? falls ja, aufrufen.
+  // TODO: Closurecache und nur rufen, wenn es _query_* auch gibt?
+  if (call_resolved(&result,this_object(),"_query_"+name))
+    return result;
+  
+  // Hilft alles nichts. Es ist eine 'normale' Property ...
+  return prop[F_VALUE][name];
+}
+
+
+// Das gesamte Property-Mapping auf einen Schlag setzen
+public void SetProperties( mapping props )
+{
+  string *names;
+  int i, j, same_object;
+ 
+  // Kein Mapping? Schlecht ...
+  if(!mappingp(props)) return;
+
+  // Setzen wir selber?
+  same_object = (!closure_call &&
+                 (!extern_call()||previous_object()==this_object()||
+                  allowed()));
+  names = m_indices(props);
+  
+  // Das SECURED-Flag darf nur durch das Objekt selber gesetzt werden:
+  // Alle SECURED-Flags aus props loeschen
+  if (!same_object)
+  {
+    j=sizeof(names);
+    while(j--) props[names[j], F_MODE] &= ~SECURED;
+  }
+
+  j=sizeof(names);
+  while(j--)
+  {
+    // Properties, die schon SECURED oder PROTECTED sind, duerfen
+    // nur vom Objekt selber manipuliert werden
+    if (same_object||!(prop[F_MODE][names[j]] & (PROTECTED|SECURED)) )
+    {
+      i=4;
+      while(i--)
+      {
+        if(props[names[j],i])
+          prop[i][names[j]] = props[names[j], i];
+        else
+          prop[i]-=([names[j]]);
+      }
+    }
+  }
+  return;
+}
+
+
+// Ein Mapping mit allen Properties zurueckgeben
+public mapping QueryProperties()
+{
+  mapping props;
+  int i, j;
+  string *names;
+
+  props = m_allocate( 0, 4 );
+  
+  if (pointerp(prop))
+  {
+    i=4;
+    while(i--)
+    {
+      names = m_indices(prop[i]);
+      j=sizeof(names);
+      while(j--) props[names[j], i] = prop[i][names[j]];
+    }
+  }
+  return props;
+}
+
+// Die Properties als urspruengliches Array zurueckgeben
+public mixed *__query_properties()
+{
+  if ( pointerp(prop) )
+    return(deep_copy(prop));
+  else
+    return ({ ([]),([]),([]),([]) });
+}
+
+
+// mapping Properties setzen zum Speichern (per save_object())
+// Aufruf nur aus simul_efun heraus
+public void  _set_save_data(mixed data) { properties = data; }
+
+// mapping Properties zum Restoren zurueckgeben
+public mixed _get_save_data()           { return properties; }
+