diff --git a/secure/awmaster.c b/secure/awmaster.c
new file mode 100644
index 0000000..cccdb1d
--- /dev/null
+++ b/secure/awmaster.c
@@ -0,0 +1,433 @@
+// MorgenGrauen MUDlib
+//
+// awmaster.c -- Armours- and Weapons-Master
+//
+#pragma strict_types
+#pragma no_clone
+#pragma no_shadow
+#pragma no_inherit
+#pragma verbose_errors
+#pragma combine_strings
+#pragma pedantic
+#pragma range_check
+#pragma warn_deprecated
+
+#include <combat.h>
+#include <language.h>
+#include <properties.h>
+#include <wizlevels.h>
+
+#define SAVEFILE  "/secure/ARCH/awmaster"
+#define ADUMPFILE "/log/ARCH/RUESTUNGEN"
+#define DDUMPFILE "/log/ARCH/DAMAGERS"
+#define WDUMPFILE "/log/ARCH/WAFFEN"
+
+#define AWF_PUTON  1
+#define AWF_PUTOFF 2
+#define AWF_BOOST  4
+#define AWF_ZAUBER 8
+#define AWF_RESIST 16
+
+#define AWM_TYPE      0
+#define AWM_CLASS     1
+#define AWM_EFF_CLASS 2
+#define AWM_FLAGS     3
+#define AWM_WEIGHT    4
+#define AWM_VALUE     5
+#define AWM_HANDS     6
+#define AWM_D_TYPE    7
+#define AWM_X_CLASS   8
+#define AWM_TIME      9
+
+mapping armours,weapons,damagers;
+private int save_me_soon;
+
+private int allowed()
+{
+  if (previous_object() && geteuid(previous_object())==ROOTID)
+    return 1;
+  if (!process_call() && previous_object() && this_interactive() && ARCH_SECURITY)
+    return 1;
+  return 0;
+}
+
+void create()
+{
+    seteuid(getuid(this_object()));
+
+    if (!restore_object(SAVEFILE))
+    {
+        armours = ([]);
+        weapons = ([]);
+        damagers = ([]);
+    }
+    if (widthof(damagers) == 1) {
+      mapping tmp = damagers;
+      damagers = m_allocate(sizeof(tmp),2);
+      foreach(string r, int flag: tmp) {
+        damagers[r,0]=flag;
+      }
+    }
+}
+
+void save_me(int now)
+{
+  if (now)
+    save_object(SAVEFILE);
+  else
+    save_me_soon=1;
+}
+
+void reset() {
+  if (save_me_soon)
+  {
+    save_me_soon=0;
+    save_me(1);
+  }
+}
+
+public varargs int remove(int silent) {
+  save_me(1);
+  destruct(this_object());
+  return 1;
+}
+
+int xflags(object ob){
+    int re;
+    mapping m;
+    if (!ob || !objectp(ob))
+        return 0;
+    re=0;
+    if (((object)ob->QueryProp(P_WEAR_FUNC))==ob  ||
+        ((object)ob->QueryProp(P_WIELD_FUNC))==ob )
+        re += AWF_PUTON;
+    if (((object)ob->QueryProp(P_REMOVE_FUNC))==ob  ||
+        ((object)ob->QueryProp(P_UNWIELD_FUNC))==ob )
+        re += AWF_PUTOFF;
+    if (((object)ob->QueryProp(P_DEFEND_FUNC))==ob ||
+        ((object)ob->QueryProp(P_HIT_FUNC))==ob    )
+        re += AWF_BOOST;
+    // ists nen Mapping und nicht leer?
+    if (mappingp(m=(mapping)ob->QueryProp(P_RESISTANCE_STRENGTHS))
+        && sizeof(m))
+        re += AWF_RESIST;
+    return re;
+}
+
+void RegisterArmour()
+{   object  ob;
+    string  id;
+    int     flag,h;
+
+    if (!objectp(ob=previous_object()) || 
+      member(inherit_list(ob),"/std/armour.c")==-1)
+      return;
+    id = explode(object_name(ob),"#")[0];
+    if (member(armours,id))
+    {
+        armours[id][AWM_TIME]=time();
+        flag=0;
+        if ((h=(int)ob->QueryProp(P_AC)) > armours[id][AWM_CLASS])
+        {
+            armours[id][AWM_CLASS]=h;
+            flag=1;
+        }
+        if ((h=(int)ob->QueryProp(P_EFFECTIVE_AC)) > armours[id][AWM_EFF_CLASS])
+        {
+            armours[id][AWM_EFF_CLASS]=h;
+            flag=1;
+        }
+        if ((h=(int)ob->QueryProp(P_NR_HANDS)) < armours[id][AWM_HANDS])
+        {
+            armours[id][AWM_HANDS]=h;
+            flag=1;
+        }
+        if ((h=xflags(ob)) != armours[id][AWM_FLAGS])
+        {
+            armours[id][AWM_FLAGS]=h;
+            flag=1;
+        }
+    }
+    else
+    {
+      armours += ([ id : 
+        ([
+            AWM_TYPE      : ob->QueryProp(P_ARMOUR_TYPE) ,
+            AWM_CLASS     : ob->QueryProp(P_AC) ,
+            AWM_EFF_CLASS : ob->QueryProp(P_EFFECTIVE_AC) ,
+            AWM_FLAGS     : xflags(ob),
+            AWM_WEIGHT    : ob->QueryProp(P_WEIGHT) ,
+            AWM_VALUE     : ob->QueryProp(P_VALUE) ,
+            AWM_HANDS     : ob->QueryProp(P_NR_HANDS) , // Fuer Schilde
+            AWM_D_TYPE    : ob->QueryProp(P_DAM_TYPE) ,
+            AWM_X_CLASS   : ob->QueryProp(P_EFFECTIVE_WC) ||
+                            ob->QueryProp(P_WC),
+            AWM_TIME      : time()
+        ]) ]);
+    }
+    save_me(0);
+}
+
+void RegisterWeapon()
+{   object  ob;
+    string  id;
+    int     flag,h;
+
+    if (!objectp(ob=previous_object()) ||
+      member(inherit_list(ob),"/std/weapon.c")==-1)
+      return;
+    id = explode(object_name(ob),"#")[0];
+    if (member(weapons,id))
+    {
+        weapons[id][AWM_TIME] = time();
+        flag=0;
+        if ((h=(int)ob->QueryProp(P_WC)) > weapons[id][AWM_CLASS])
+        {
+            weapons[id][AWM_CLASS]=h;
+            flag=1;
+        }
+        if ((h=(int)ob->QueryProp(P_EFFECTIVE_WC)) > weapons[id][AWM_EFF_CLASS])
+        {
+            weapons[id][AWM_EFF_CLASS]=h;
+            flag=1;
+        }
+        if ((h=(int)ob->QueryProp(P_NR_HANDS)) < weapons[id][AWM_HANDS])
+        {
+            weapons[id][AWM_HANDS]=h;
+            flag=1;
+        }
+        if ((h=xflags(ob)) != weapons[id][AWM_FLAGS])
+        {
+            weapons[id][AWM_FLAGS]=h;
+            flag=1;
+        }
+    }
+    else
+    {
+      weapons += ([ id :
+        ([
+            AWM_TYPE      : ob->QueryProp(P_WEAPON_TYPE) ,
+            AWM_CLASS     : ob->QueryProp(P_WC) ,
+            AWM_EFF_CLASS : ob->QueryProp(P_EFFECTIVE_WC) ,
+            AWM_FLAGS     : xflags(ob),
+            AWM_WEIGHT    : ob->QueryProp(P_WEIGHT) ,
+            AWM_VALUE     : ob->QueryProp(P_VALUE) ,
+            AWM_HANDS     : ob->QueryProp(P_NR_HANDS) ,
+            AWM_D_TYPE    : ob->QueryProp(P_DAM_TYPE) ,
+            AWM_X_CLASS   : ob->QueryProp(P_EFFECTIVE_AC) || 
+                            ob->QueryProp(P_AC),
+            AWM_TIME      : time()
+        ]) ]);
+    }
+    save_me(0);
+}
+
+void RegisterDamager(object dam_ob,int old_dam, int new_dam)
+{   object ob;
+    int flag;
+    string fn;
+
+    if (!objectp(ob=previous_object()) ||
+      (member(inherit_list(ob),"/std/weapon.c")==-1 &&
+       member(inherit_list(ob),"/std/armour.c")==-1 ))
+      return;
+    if (old_dam>new_dam) // Repair
+        flag=2;
+    else if (new_dam>old_dam) // Damage
+        flag=1;
+    else
+        return;
+    if (!objectp(dam_ob))
+        return;
+    if (!(fn=old_explode(object_name(dam_ob),"#")[0]) || !stringp(fn))
+        return;
+    damagers[fn,0]=damagers[fn,0]|flag;
+    damagers[fn,1]=time(); 
+    save_me(0);
+}
+
+string dtdump(mixed arg)
+{   string re;
+    int i,w;
+
+    if (stringp(arg))
+        return capitalize(arg);
+    if (!pointerp(arg) || !stringp(arg[0]))
+        return "<NONE>";
+    if ((i=sizeof(arg))==1)
+        return capitalize(arg[0]);
+    w = (31-i)/i;
+    if (w--<1)
+        return "<MANY>";
+    for (re="",--i;i>=0;i--)
+    {
+        if (!stringp(arg[i]))
+            re += "-";
+        else
+            re += capitalize(arg[i][0..w]);
+        if (i)
+            re += "|";
+    }
+    return re;
+}
+
+int Dump(mixed what, int sortidx)
+{   string  file,*ind;
+    mapping dump;
+
+    if (!allowed())
+        return -1;
+
+    if (!what)
+    {
+        write("Nimm doch mal einen richtigen Parameter!\n");
+        return 0;
+    }
+    if (stringp(what) && sizeof(what)>0)
+    {
+        what==what[0..0];
+        if (what=="a")
+            what=1;
+        else if (what=="w")
+            what=2;
+        else if (what=="d")
+            what=3;
+        else
+        {
+            write("Nimm doch mal einen richtigen Parameter!\n");
+            return 0;
+        }
+    }
+    if (!intp(what) || what<1 || what>3)
+    {
+        write("Nimm doch mal einen richtigen Parameter!\n");
+        return 0;
+    }
+    if (what==3) // Die 'damagers' haben ein anderes Ausgabeformat
+    {
+        printf("AWM: Dumping 'damagers' to '%s'\n",DDUMPFILE);
+        if (sizeof(damagers) < 1) {
+            write("AWM: Dump aborted, mapping empty.\n");
+            return 1;
+        }
+        if (file_size(DDUMPFILE)>1)
+            rm(DDUMPFILE);
+        
+        // nach letzter Aktualisierung sortieren.
+        mixed sorted = sort_array(m_indices(damagers),
+            function int (string a, string b) {
+                return damagers[a,1] < damagers[b,1];
+            } );
+
+        string ausgabe = sprintf(
+            "--- Damagers-Dump --- %s --- %s ---\n\n"+
+            "%:15s D R [Filename]\n",
+            dtime(time()),capitalize(getuid(this_interactive())),
+            "Datum/Zeit");
+        foreach(string rue : sorted) {
+            ausgabe += sprintf("%:15s %1s %1s %s\n",
+                strftime("%y%m%d-%H:%M:%S",damagers[rue,1]),
+                (damagers[rue,0]&1?"+":"-"),
+                (damagers[rue,0]&2?"+":"-"),
+                rue);
+        }
+        
+        write_file(DDUMPFILE, ausgabe);
+        return 1;
+    }
+    if (what==2)
+        what=0;
+    file=(what?ADUMPFILE:WDUMPFILE);
+
+    printf("AWM: Dumping '%s' to '%s'\n",
+        (what?"armours":"weapons"),file);
+    
+    dump=(what?armours:weapons);
+    
+    if (sortidx) {
+      ind = sort_array(m_indices(dump),
+          function int (string a, string b)
+          {return dump[a][sortidx] < dump[b][sortidx];} );
+    }
+    else
+      ind = sort_array(m_indices(dump),#'>);
+    
+    if (sizeof(ind) < 1)
+    {
+        write("AWM: Dump aborted, mapping empty.\n");
+        return 1;
+    }
+
+    if (file_size(file)>1)
+        rm(file);
+    
+    string ausgabe = sprintf(
+        "--- %s-Dump --- %s --- %s ---\n\n"+
+        "[Filename], Datum/Zeit\n"+
+        "    ____Typ___ CLS ECL XCL NFBR WGHT. VALUE H %30.30'_'|s\n",
+        (what?"Ruestungs":"Waffen"),dtime(time()),
+        capitalize(getuid(this_interactive())),"DamType(s)");
+
+    foreach(string index : ind)
+    {
+        ausgabe += sprintf(
+            "[%s] %s\n    %10s %3d %3d %3d %1s%1s%1s%1s %5d %5d %1d %-30.30s\n",
+            index, strftime("%y%m%d-%H:%M:%S",dump[index][AWM_TIME]),
+            dump[index][AWM_TYPE],
+            dump[index][AWM_CLASS],
+            dump[index][AWM_EFF_CLASS],
+            dump[index][AWM_X_CLASS],
+           (dump[index][AWM_FLAGS]&AWF_PUTON?"+":"-"),
+           (dump[index][AWM_FLAGS]&AWF_PUTOFF?"+":"-"),
+           (dump[index][AWM_FLAGS]&AWF_BOOST?"+":"-"),
+           (dump[index][AWM_FLAGS]&AWF_RESIST?"+":"-"),
+            dump[index][AWM_WEIGHT],
+            dump[index][AWM_VALUE],
+            dump[index][AWM_HANDS],
+            dtdump(dump[index][AWM_D_TYPE]) );
+    }
+    write_file(file,ausgabe);
+    write("AWM: Done.\n");
+    return 1;
+}
+
+int Unregister(string what)
+{
+    if (!allowed())
+        return -1;
+    if (!what)
+    {
+        write("Du solltest schon einen Filenamen angeben!\n");
+        return 0;
+    } 
+    if (member(armours,what))
+    {
+        m_delete(armours,what);
+        write("Unregistered "+what+" from 'armours'.\n");
+        return 1;
+    }
+    if (member(weapons,what))
+    {
+        m_delete(weapons,what);
+        write("Unregistered "+what+" from 'weapons'.\n");
+        return 1;
+    }
+    if (member(damagers,what))
+    {
+        m_delete(damagers,what);
+        write("Unregistered "+what+" from 'damagers'.\n");
+        return 1;
+    }
+    save_me(0);
+    return 0;
+}
+
+int ResetDamagers()
+{
+    if (!allowed())
+        return -1;
+    damagers = m_allocate(0,2);
+    save_me(1);
+    return 1;
+}
+