diff --git a/p/daemon/tmp_prop_master.c b/p/daemon/tmp_prop_master.c
new file mode 100644
index 0000000..0ce1de7
--- /dev/null
+++ b/p/daemon/tmp_prop_master.c
@@ -0,0 +1,338 @@
+#pragma strong_types,save_types
+#pragma no_clone,no_shadow
+
+#include <thing/properties.h>
+
+#define SAVEFILE "/p/daemon/save/tmp_prop_master"
+#define PROPMASTER "/p/daemon/tmp_prop_master"
+#define INDEX(a,b) (object_name(a)+"##"+b)
+
+
+#ifdef DEBUG
+#   undef DEBUG
+#endif
+
+#ifdef DEBUG
+#   define DBG(x) if ( find_player("rikus") ) \
+                     tell_object( find_player("rikus"), x );
+#else
+#   define DBG(x)
+#endif
+
+
+mixed *reset_times;
+mapping in_progress;
+
+
+varargs public int remove( int silent );
+public void reset();
+public void print_debug_info();
+static void call_next_update();
+static void do_update();
+public int IsTmpProp( object ob, string prop );
+public void RemoveTmpProp( string prop );
+varargs public void SetTmpProp( object ob, string prop, mixed newval,
+                                int tm, int sp );
+
+
+public void create()
+{
+
+    seteuid(getuid(this_object()));
+    
+    if ( !restore_object(SAVEFILE) ){
+        in_progress = ([]);
+        reset_times = ({});
+    }
+
+    call_next_update();
+}
+
+
+varargs public int remove( int silent )
+{
+    save_object(SAVEFILE);
+    destruct(this_object());
+    
+    return 1;
+}
+
+
+public void reset()
+{
+    save_object(SAVEFILE);
+}
+
+
+public void print_debug_info()
+{
+    printf( "in_progress: %O\nreset_times: %O\n", in_progress, reset_times );
+}
+
+
+static void call_next_update()
+{
+    int dt;
+    
+    while ( remove_call_out("do_update") != -1 )
+        ;
+    
+    if ( sizeof(reset_times) ){
+        dt = reset_times[0][0] - time();
+
+        if ( dt <= 0 )
+            dt = 5;
+        
+        call_out( "do_update", dt );
+    }
+}
+
+
+static void do_update()
+{
+    int i, max;
+    string index;
+    mixed *val;
+
+    DBG( "do_update() aufgerufen!\n" );
+
+    while ( remove_call_out("do_update") != -1 )
+        ;
+    
+    call_out( "do_update", 30 ); // Zur Sicherheit...
+
+    if ( !(max = sizeof(reset_times)) )
+        return;
+    
+    for ( i = 0; i < max && reset_times[i][0] <= time(); i++ ){
+        index = reset_times[i][1];
+
+        if ( !pointerp(val = in_progress[index]) || !objectp(val[0]) )
+	{
+            m_delete( in_progress ,index );
+            continue;
+        }
+
+        DBG( sprintf("Entferne Eintrag %O!\n", index) );
+
+        if ( val[4] ){
+            if ( val[0]->Query(val[1], F_VALUE) == val[3] ){
+                DBG( "Alte Property per SetProp() restauriert!\n" );
+                val[0]->SetProp( val[1], val[2] );
+            }
+        }
+        else {
+            if ( val[0]->Query( val[1], F_QUERY_METHOD ) == val[2] ){
+                val[0]->Set( val[1], 0, F_QUERY_METHOD );
+                DBG( "F_QUERY_METHOD entfernt!\n" );
+            }
+            
+            if ( val[0]->Query( val[1], F_SET_METHOD ) == val[3] ){
+                val[0]->Set( val[1], 0, F_SET_METHOD );
+                DBG( "F_SET_METHOD entfernt!\n" );
+            }
+        }
+
+        m_delete( in_progress ,index );
+    }
+    
+    reset_times = reset_times[i..];
+    call_next_update();
+}
+
+
+// Zur Abfrage, ob eine temporaere Property schon gesetzt ist
+public int IsTmpProp( object ob, string prop )
+{
+    mixed oldval;
+
+    if ( !objectp(ob) || !prop )
+        return 0;
+    
+    if ( (oldval = in_progress[INDEX(ob, prop)])
+         && ob == oldval[0] && prop == oldval[1] )
+        return 1;
+    
+    return 0;
+}
+
+
+// Entfernen einer temporaeren Property.
+// Ist nicht zum Entfernen per Hand gedacht, sondern kann nur vom Objekt selber
+// aufgerufen werden. Geschieht, wenn bei gesetzter temporaerer F_SET_METHOD
+// ein fremdes SetProp() auf die Property kommt.
+public void RemoveTmpProp( string prop )
+{
+    string index;
+    mixed *val;
+    int i;
+    
+    DBG( "RemoveTmpProp!\n");
+    if ( !previous_object() || !stringp(prop) || !sizeof(prop) )
+        return;
+
+    index = INDEX(previous_object(), prop);
+    DBG( sprintf("RemoveTmpProp(%O)!\n", index) );
+
+    if ( !(val = in_progress[index]) ){
+        DBG( "Kein Eintrag vorhanden!\n" );
+        return;
+    }
+
+    if ( objectp(val[0]) ){
+        DBG( "Restauriere alten Zustand ...\n" );
+
+        if ( val[4] ){
+            if ( val[0]->Query(val[1], F_VALUE) == val[3] ){
+                DBG( "Alte Property per SetProp() restauriert!\n" );
+                val[0]->SetProp( val[1], val[2] );
+            }
+        }
+        else {
+            if ( val[0]->Query( val[1], F_QUERY_METHOD ) == val[2] ){
+                val[0]->Set( val[1], 0, F_QUERY_METHOD );
+                DBG( "F_QUERY_METHOD entfernt!\n" );
+            }
+            
+            if ( val[0]->Query( val[1], F_SET_METHOD ) == val[3] ){
+                val[0]->Set( val[1], 0, F_SET_METHOD );
+                DBG( "F_SET_METHOD entfernt!\n" );
+            }
+        }
+    }
+
+    for ( i = sizeof(reset_times); i--; )
+        if ( reset_times[i][1] == index ){
+            reset_times[i..i] = ({});
+            break;
+        }
+    
+    DBG( "Eintrag entfernt!\n" );
+    m_delete( in_progress, index );
+}
+
+
+// Property 'prop' im Objekt 'ob' fuer 'tm' Sekunden auf Wert 'newval' setzen.
+// Wenn der Schalter 'sp' gesetzt ist, wird dafuer SetProp() verwendet,
+// anstatt eine F_QUERY_METHOD zu benutzen.
+//
+// ACHTUNG:
+//
+// Das Setzen von 'sp' ist hoechst fehleranfaellig und sollte nur in wenigen
+// Spezialfaellen geschehen, in denen eine SET-Methode aufgerufen werden muss
+// (wie bei P_LIGHT z.B.). Ansonsten bitte den Default-Aufruf ohne 'sp'
+// verwenden!
+// 
+// Es besteht sonst die Gefahr, dass die Property nicht korrekt zurueckgesetzt
+// wird (wenn dieser Master oder 'ob' zerstoert wird - oder beides wie bei einem
+// Crash) oder dass durch Wechselwirkungen mit anderen Query- oder Set-Methoden
+// ein falscher Wert "restauriert" wird.
+
+varargs public void SetTmpProp( object ob, string prop, mixed newval,
+                                int tm, int sp )
+{
+    string index;
+    mixed oldval, tmp;
+    int max, pos, l, r;
+    closure a, b;
+
+    if ( !objectp(ob) || !stringp(prop) || !sizeof(prop) || tm <= 0 )
+        return;
+
+    index = INDEX(ob, prop);
+    DBG( sprintf("SetTmpProp( %O, %O, %O, %O, %O )!\n", ob, prop, newval,
+                 tm, sp) );
+
+    // wenn bereits ein temporaerer Prozess laeuft, diesen nun beenden!
+    if ( (oldval = in_progress[index])
+         && ob == oldval[0] && prop == oldval[1] ){
+        DBG( "Es laeuft bereits ein Vorgang fuer diese Property!\n" );
+        
+        // Wurde die alte temporaere Property per SetProp() gesetzt, muss der
+        // urspruengliche Wert erst restauriert werden. 
+        if ( oldval[4] ){
+            if ( oldval[0]->Query(oldval[1], F_VALUE) == oldval[3] ){
+            DBG( "Alte Property per SetProp() restauriert!\n" );
+            oldval[0]->SetProp( oldval[1], oldval[2] );
+            }
+        }
+        // Ansonsten einfach die F_QUERY- und F_SET_METHOD loeschen.
+        else {
+            if ( oldval[0]->Query( oldval[1], F_QUERY_METHOD ) == oldval[2] ){
+                oldval[0]->Set( oldval[1], 0, F_QUERY_METHOD );
+                DBG( "F_QUERY_METHOD entfernt!\n" );
+            }
+
+            if ( oldval[0]->Query( oldval[1], F_SET_METHOD ) == oldval[3] ){
+                oldval[0]->Set( oldval[1], 0, F_SET_METHOD );
+                DBG( "F_SET_METHOD entfernt!\n" );
+            }
+        }
+        
+        for ( l = sizeof(reset_times); l--; )
+            if ( reset_times[l][1] == index ){
+                reset_times[l..l] = ({});
+                DBG( "Timer-Eintrag entfernt!\n" );
+                break;
+            }
+    }
+
+    if ( tm < 1000000 )
+        tm += time();
+
+    if ( tm < time() )
+        return;
+
+    if ( !sp ){
+        // Default: F_QUERY_METHOD setzen
+        oldval = ob->Set( prop, newval,  F_QUERY_METHOD );
+
+        // F_SET_METHOD, damit die temporaere Property keinen zwischenzeitlich
+        // gesetzten anderen Wert wieder "restauriert".
+
+        a=symbol_function("RemoveTmpProp",this_object());
+        b=symbol_function("SetProp",ob);
+        tmp=ob->Set(prop,lambda(({'set_value,'prop_name}),({#',,({a,'prop_name}),({#'return,({b,'prop_name,'set_value})})})),F_SET_METHOD);
+    }
+    else{
+        // Fuer Spezialfaelle (P_LIGHT z.B.) wird die Property direkt mit
+        // SetProp() gesetzt und spaeter mit dem alten Wert restauriert.
+        // Achtung - extrem fehleranfaellig und wirklich nur fuer Spezialfaelle!
+
+        // Alten Wert mit Query() sichern anstatt mit QueryProp(), um nicht
+        // irgendwelchen F_QUERY_METHODs auf den Leim zu gehen.
+        oldval = ob->Query( prop, F_VALUE );
+
+        // Rueckgabewert des SetProp() speichern, um spaeter erkennen zu
+        // koennen, ob die Property zwischenzeitlich veraendert wurde.
+        tmp = ob->SetProp( prop, newval );
+    }
+
+    in_progress[index] = ({ ob, prop, oldval, tmp, sp });
+    
+    if ( !(max = sizeof(reset_times)) )
+        pos = 0;
+    else{
+        l = 0;
+        r = max - 1;
+        
+        while ( l < r ){
+            pos = (l + r) / 2;
+            
+            if ( tm < reset_times[pos][0] )
+                r = --pos;
+            else
+                l = ++pos;
+        }
+        
+        while ( pos >= 0 && pos < max && tm < reset_times[pos][0] )
+            pos--;
+    }
+    
+    reset_times = reset_times[0..pos] + ({ ({tm, index}) })
+        + reset_times[pos+1..];
+
+    DBG( sprintf("Property an Stelle %O eingefuegt!\n", pos+1) );
+
+    call_next_update();
+}