diff --git a/std/armour/combat.c b/std/armour/combat.c
new file mode 100644
index 0000000..e688131
--- /dev/null
+++ b/std/armour/combat.c
@@ -0,0 +1,228 @@
+// MorgenGrauen MUDlib
+//
+// armour/combat.c -- armour standard object
+//
+// $Id: combat.c 9092 2015-01-19 23:57:50Z Zesstra $
+
+#pragma strict_types
+#pragma save_types
+#pragma no_clone
+#pragma pedantic
+#pragma range_check
+
+#define NEED_PROTOTYPES
+
+#include <thing/properties.h>
+#include <thing/commands.h>
+#include <thing/description.h>
+#include <config.h>
+#include <combat.h>
+#include <language.h>
+#include <defines.h>
+#include <new_skills.h>
+
+
+// Globale Variablen
+private nosave closure defend_cl;
+private nosave mapping resistance_strengths=([]);
+
+void create() {
+    // Einige Grundwerte setzen
+    Set(P_ARMOUR_TYPE, AT_ILLEGAL, F_VALUE);
+    Set(P_LAST_USE,time(),F_VALUE);
+}
+
+// Die Funktion, die den Schutzwert berechnet, den die Ruestung bietet
+int QueryDefend(string|string* dam_type, int|mapping spell, object enemy)
+{
+    int     prot;
+    mixed   def_func;
+    object  pl;
+    // Zum Cachen von spell[EINFO_DEFEND], haeufiges Lookup aus dem Mapping
+    // koennte unnoetig Zeit kosten.
+    mapping einfo;
+
+    // AT_MISC-Ruetungen schuetzen normalerweise gar nicht...
+    if (QueryProp(P_ARMOUR_TYPE)==AT_MISC) {
+        // es sei denn, sie haben eine spezielle DefendFunc
+        if (!closurep(defend_cl)) return(0);
+    }
+    else {
+        // ansonsten Ruestungsschutz ermitteln und in EINFO_DEFEND vermerken.
+        // (Beides fuer AT_MISC in jedem Fall unnoetig)
+
+        // Ruestungen schuetzen nur gegen physikalischen Schaden
+        if ((!spell || (mappingp(spell) && spell[SP_PHYSICAL_ATTACK]))
+            && sizeof(filter(dam_type,PHYSICAL_DAMAGE_TYPES)))
+        { 
+          // Schutz bestimmen, Minimum 1, aber nur wenn P_AC > 0
+          int pac = QueryProp(P_AC);
+          if (pac > 0)
+            prot = (pac/4 + random(pac*3/4 + 1)) || 1 ;
+          object stat = find_object("/d/erzmagier/zesstra/pacstat");
+          if (stat)
+            stat->acstat(QueryProp(P_ARMOUR_TYPE),prot,
+                         random(pac)+1);
+
+          // ruestungschutz an defendfunc weitermelden
+          if (mappingp(spell) &&
+              mappingp(einfo=spell[EINFO_DEFEND])) {
+              // Schutz d. akt. Ruestung vermerken.
+              einfo[DEFEND_CUR_ARMOUR_PROT]=prot;
+              // daten der Ruestung vermerken.
+              if (mappingp(einfo[DEFEND_ARMOURS])) {
+                einfo[DEFEND_ARMOURS][ME,DEF_ARMOUR_PROT]=prot;
+              }
+          } // ende vom if (mapping(spell) ...)
+        } // ende vom if (phys Schaden)
+
+    } // ende vom else (wenn kein AT_MISC) 
+
+    // Ist eine DefendFunc gesetzt, wird diese ausgewertet
+    if (closurep(defend_cl)) {
+        if (!objectp(get_type_info(defend_cl,2))) {
+            // Closure gesetzt, aber nicht gueltig, schauen, ob wir sie neu
+            // erstellen koennen.
+            if (objectp(def_func=QueryProp(P_DEFEND_FUNC))) {
+                defend_cl=symbol_function("DefendFunc",def_func);
+            }
+            // sonst loeschen, um spaeter diesen Zweig ganz zu sparen.
+            else defend_cl=0;
+        }
+        // BTW: Es ist ok, wenn defend_cl jetzt 0 ist, dann liefert funcall()
+        // auch 0.
+        // Bei Netztoten keine (zurueckschlagende) DefendFunc
+        if (objectp(pl=QueryProp(P_WORN)) && (!query_once_interactive(pl) ||
+                interactive(pl)) ) {
+          // Der Rueckgabewert der DefendFunc wird zum Schutz addiert
+          prot += funcall(defend_cl, dam_type, spell, enemy);
+          // leider kann die DefendFunc jetzt auch noch das Objekt zerstoert
+          // haben...
+          if (!objectp(this_object()))
+            return prot;
+        }
+    }
+
+    // Zeitpunkt der letzten Benutzung ausgeben
+    SetProp(P_LAST_USE,time());
+
+    // Berechneten Schutz zurueckgeben
+    return prot;
+}
+
+// Es duerfen nur "legale" Ruestungstypen gesetzt werden, ansonsten
+// wird AT_ILLEGAL gesetzt.
+static mixed _set_armour_type(mixed type ) {
+    if (!COMBAT_MASTER->valid_armour_type(type))
+    {
+        Set(P_ARMOUR_TYPE, (type=AT_ILLEGAL), F_VALUE);
+    }
+    else
+    {
+        Set(P_ARMOUR_TYPE, type);
+    }
+    AddId(type);
+
+    resistance_strengths=([]);
+    return type;
+}
+
+
+// Wird etwas an P_DEFEND_FUNC geaendert, muss die zugehoerige closure
+// neu erstellt werden.
+static object _set_defend_func(object arg) {
+  if (objectp(arg) &&
+      closurep(defend_cl=symbol_function("DefendFunc",arg))) {  
+    return Set(P_DEFEND_FUNC, arg, F_VALUE);
+  }
+  defend_cl=0;
+  return(Set(P_DEFEND_FUNC, 0, F_VALUE));
+}
+
+// Auch Ruestungen koennen einen Schadenstyp haben. Dieser kann als string
+// oder array angegeben werden, wird aber intern auf jeden Fall als
+// array gespeichert.
+static mixed _set_dam_type(mixed arg) {
+    if (pointerp(arg))
+    {
+        return Set(P_DAM_TYPE, arg, F_VALUE);
+    }
+    else if (stringp(arg))
+    {
+        return Set(P_DAM_TYPE, ({ arg }), F_VALUE);
+    }
+    return Query(P_DAM_TYPE, F_VALUE);
+}
+
+// Ruestungen koennen Resistenzen setzen. Diese werden jedoch nicht wie
+// "normale" Resistenzen gesetzt, sondern als Prozentwerte der fuer diesen
+// Typ maximal zulaesigen Resistenz. Die Aenderung der Resistenzen darf
+// nur durch die Ruestung selbst erfolgen.
+// Beispiel: ([DT_FIRE: 100, DT_WATER: -150])
+// max. Feuerresistenz, 1.5fache Anfaelligkeit
+static mixed _set_resistance_strengths(mixed resmap) {
+    float  max_res;
+    object worn_by;
+
+    // Es duerfen nur mappings angegeben werden
+    if (!mappingp(resmap))
+    {
+        return -1;
+    }
+
+    // die Maxwerte muessen jeweils durch -100 geteilt sein, da hinterher
+    // mit der Prozentzahl multipliziert wird und die angabe der Vorzeichen
+    // hier umgekehrt wie bei den "normalen" Resistenzen ist. Der
+    // Maximalwert ist vom Ruestungstyp abhaengig.
+    switch (QueryProp(P_ARMOUR_TYPE))
+    {
+        case AT_CLOAK  :
+        case AT_RING   :
+        case AT_AMULET : max_res=-0.0010;
+                         break;
+        case AT_SHIELD :
+        case AT_ARMOUR : max_res=-0.0015;
+                         break;
+        default        : max_res=-0.0005;
+    }
+
+    // Resistenz-Mapping aktualisieren
+    resistance_strengths=([]);
+    foreach(string damtype, int res: resmap)
+    {
+        if (!intp(res)) res=to_int(res);
+        // Mehr als 100 Prozent ist nicht erlaubt
+        if (res>100)
+        {
+            res=100;
+        }
+        else if (res<0)
+        {
+             res=(res/4)*5;
+             // Man kann auch nicht beliebig negativ werden
+             if (res<-1000)
+             {
+                 res=-1000;
+             }
+        }
+        // Der Resistenzwert berechnet sich aus dem Produkt des
+        // Maximalwertes und der Prozentzahl
+        resistance_strengths[damtype]=res*max_res;
+    }
+
+    // Werden die Resistenzen bei einer getragenen Ruestung geaendert,
+    // muss der Traeger davon natuerlich beeinflusst werden.
+    if (objectp(worn_by=QueryProp(P_WORN)))
+    {
+        worn_by->AddResistanceModifier(resistance_strengths,
+                                       QueryProp(P_ARMOUR_TYPE));
+    }
+   return resistance_strengths;
+}
+
+// Bei einem QueryProp(P_RESISTANCE_STRENGTHS) soll das aktuelle
+// Resistenzen-Mapping zurueckgegeben werden
+static mapping _query_resistance_strengths() {
+  return (resistance_strengths||([]));
+}
+
diff --git a/std/armour/container_description.c b/std/armour/container_description.c
new file mode 100644
index 0000000..b1e73ad
--- /dev/null
+++ b/std/armour/container_description.c
@@ -0,0 +1,67 @@
+// MorgenGrauen MUDlib
+//
+// armour/container_description.c -- armour_container description handling
+//
+// $Id: container_description.c 6306 2007-05-20 11:32:03Z Zesstra $
+
+#pragma strict_types
+#pragma save_types
+#pragma pedantic
+#pragma range_check
+#pragma no_clone
+
+inherit "/std/clothing/container_description";
+
+#define NEED_PROTOTYPES
+
+#include <thing/properties.h>
+#include <thing/description.h>
+#include <thing/language.h>
+#include <container.h>
+#include <combat.h>
+#include <thing/material.h>
+#include <defines.h>
+#include <wizlevels.h>
+#include <player/base.h>
+
+string dam_descr() {   
+    string re;
+    mixed desc;
+    int maximum,dam,pos;
+
+    if (!QueryProp(P_NAME) || !QueryProp(P_DAMAGED) || !QueryProp(P_SHORT) ||
+        !(desc=QueryProp(P_DAM_DESC)) || (!stringp(desc) && !pointerp(desc)))
+        return "";
+    re = capitalize(name(WER,2))+" ";
+    maximum = QueryProp(P_AC)+(dam=QueryProp(P_DAMAGED));
+    if (stringp(desc))
+        return (dam>(maximum/2))?(re+desc+".\n"):"";
+    pos = (sizeof(desc)*dam/maximum);
+    if (stringp(desc[pos]))
+        return (re+desc[pos]+".\n");
+    return "";
+}
+
+mapping _query_material() {
+  mixed res,at;
+
+  if (mappingp(res=Query(P_MATERIAL)))
+    return res;
+  at=QueryProp(P_ARMOUR_TYPE);
+  switch(at) {
+    case AT_ARMOUR:
+    case AT_HELMET:
+    case AT_RING:
+    case AT_AMULET:
+    case AT_SHIELD:
+    return ([MAT_MISC_METAL:100]);
+    case AT_CLOAK:
+    case AT_TROUSERS:
+    return ([MAT_CLOTH:100]);
+    case AT_GLOVE:
+    case AT_BOOT:
+    return ([MAT_LEATHER:100]);
+  }
+  return ([MAT_LEATHER:100]);
+}
+
diff --git a/std/armour/description.c b/std/armour/description.c
new file mode 100644
index 0000000..2e26294
--- /dev/null
+++ b/std/armour/description.c
@@ -0,0 +1,62 @@
+// MorgenGrauen MUDlib
+//
+// armour/description.c -- armour description handling
+//
+// $Id: description.c 6306 2007-05-20 11:32:03Z Zesstra $
+
+#pragma strict_types
+#pragma save_types
+#pragma no_clone
+#pragma pedantic
+#pragma range_check
+
+inherit "/std/clothing/description";
+
+//#define NEED_PROTOTYPES
+
+#include <properties.h>
+
+string dam_descr()
+{   string re;
+    mixed desc;
+    int maximum,dam,pos;
+
+    if (!QueryProp(P_NAME) || !QueryProp(P_DAMAGED) || !QueryProp(P_SHORT) ||
+        !(desc=QueryProp(P_DAM_DESC)) || (!stringp(desc) && !pointerp(desc)))
+        return "";
+    re = capitalize(name(WER,2))+" ";
+    maximum = QueryProp(P_AC)+(dam=QueryProp(P_DAMAGED));
+    if (stringp(desc))
+        return (dam>(maximum/2))?(re+desc+".\n"):"";
+    if (maximum==dam)
+        pos=sizeof(desc)-1;
+    else
+        pos = (sizeof(desc)*dam/maximum);
+    if (stringp(desc[pos]))
+        return (re+desc[pos]+".\n");
+    return "";
+}
+
+
+mapping _query_material() {
+  mixed res,at;
+
+  if (mappingp(res=Query(P_MATERIAL)))
+    return res;
+  at=QueryProp(P_ARMOUR_TYPE);
+  switch(at) {
+    case AT_ARMOUR:
+    case AT_HELMET:
+    case AT_RING:
+    case AT_AMULET:
+    case AT_SHIELD:
+    return ([MAT_MISC_METAL:100]);
+    case AT_CLOAK:
+    case AT_TROUSERS:
+    return ([MAT_CLOTH:100]);
+    case AT_GLOVE:
+    case AT_BOOT:
+    return ([MAT_LEATHER:100]);
+  }
+  return ([MAT_LEATHER:100]);
+}
diff --git a/std/armour/moving.c b/std/armour/moving.c
new file mode 100644
index 0000000..de598a8
--- /dev/null
+++ b/std/armour/moving.c
@@ -0,0 +1,18 @@
+// MorgenGrauen MUDlib
+//
+// armour/moving.c -- armour moving object
+//
+// $Id: moving.c 6306 2007-05-20 11:32:03Z Zesstra $
+
+#pragma strict_types
+#pragma save_types
+#pragma no_clone
+#pragma pedantic
+#pragma range_check
+
+// Dies muss eigentlich nix ueber clothing/moving hinausgehendes koennen.
+// Die Ruestungen erben auch alle direkt clothing/moving, dieses File
+// existiert eigentlich nur fuer den Fall, dass Leute ausserhalb von /std von
+// armour/moving erben.
+inherit "/std/clothing/moving";
+
diff --git a/std/armour/wear.c b/std/armour/wear.c
new file mode 100644
index 0000000..fef87c5
--- /dev/null
+++ b/std/armour/wear.c
@@ -0,0 +1,260 @@
+// MorgenGrauen MUDlib
+//
+// armour/wear.c -- armour standard object
+//
+// $Id: combat.c 6243 2007-03-15 21:10:21Z Zesstra $
+
+#pragma strict_types
+#pragma save_types
+#pragma no_clone
+#pragma pedantic
+#pragma range_check
+
+inherit "/std/clothing/wear";
+
+#define NEED_PROTOTYPES
+
+#include <thing/properties.h>
+#include <living/combat.h>
+#include <living/attributes.h>
+#include <language.h>
+#include <defines.h>
+#include <armour.h>
+
+// Uebernimmt viele wesentliche Eigenschaften aus der Kleidung, daher werden
+// hier auch nur div. Funktionen ueberschrieben, die sich leicht
+// unterschiedlich zur Kleidung verhalten.
+
+// Globale Variablen
+private nosave int     logged;
+
+protected void create() {
+  ::create();
+  // P_DAMAGED laesst sich zwar (noch) von aussen setzen, aber bitte nur ueber
+  // die hier definierte Setmethode.
+  // TODO: Direktes Setzen von P_DAMAGED entfernen.
+  Set(P_DAMAGED, PROTECTED, F_MODE_AS);
+}
+
+/* Wenn eine Ruestung vom gleichen Typ im Array ist, gebe diese zurueck. */
+private object TestType(object *armours) {
+    mixed type;
+
+    // Den eigenen Typ feststellen
+    type = QueryProp(P_ARMOUR_TYPE);
+
+    // Zerstoerte Objekte aussortieren
+    armours-=({0});
+
+    foreach(object armour: armours)
+    {
+      if (type==(armour->QueryProp(P_ARMOUR_TYPE)))
+        {
+            // Ruestung vom gleichen Typ gefunden -> zurueckgeben
+            return armour;
+        }
+    }
+    // Keine Ruestung vom gleichen Typ gefunden, also 0 zurueckgeben
+    return 0;
+}
+
+// liefert 1 zurueck, wenn der Spieler die ruestung anziehen darf, 0 sonst.
+protected int _check_wear_restrictions(int silent, int all) {
+  mixed   type,res;
+  object  *armours;
+
+  type = QueryProp(P_ARMOUR_TYPE);
+
+  // Das DoWear() der Kleidung prueft auf genuegend freie Haende,
+  // prueft aber den Fall nicht ab, ob man hier ein Schild hat, was laut Prop
+  // weniger als eine Hand belegt. Daher hier nachholen und korrigieren. Und
+  // direkt mal loggen, damit das gefixt wird.
+  if ( (type==AT_SHIELD) && QueryProp(P_NR_HANDS)<1 ) {
+    SetProp(P_NR_HANDS,1);
+    log_file("INVALID_SHIELD",
+	sprintf("Fixme: AT_SHIELD item without valid P_NR_HANDS: %O\n",
+	  object_name()));
+  }
+
+  armours=(object*)PL->QueryProp(P_ARMOURS) - ({0});
+
+  // Von jedem Ruestungstyp ausser AT_MISC kann man immer nur ein
+  // Teil tragen
+  if ( (type!=AT_MISC) && (res=TestType(armours)) && objectp(res)) {
+    msg(break_string(sprintf(
+	  "Du traegst bereits %s als Schutz der Sorte %s.",
+	  res->name(WEN,1), type),78,
+	  (all?(Name(WER)+": "):0)), all);
+    return(-1);
+  }
+
+  // Ruestungen vom Typ AT_ILLEGAL oder solche mit einem fuer ihren
+  // Ruestungstyp zu hohen Schutzwert koennen nicht angezogen werden
+  if ( (type==AT_ILLEGAL) || (QueryProp(P_AC)>VALID_ARMOUR_CLASS[type])) {
+    write("Ungueltiger Ruestungstyp, bitte Erzmagier verstaendigen.\n");
+        "/p/daemon/ruestungen"->RegisterArmour();      
+    return(-2);
+  }
+
+  // Ruestungen, die ein oder mehrere Attribut veraendern und gegen
+  // das gesetzte Limit verstossen, haben keine Wirkung bezueglich der
+  // Attribute. Dies gibt aber nur ne Meldung aus, angezogen werden darf sie
+  // trotzdem.
+  if (mappingp(res=QueryProp(P_M_ATTR_MOD)) && PL->TestLimitViolation(res) ) {
+    write(break_string(sprintf(
+          "Irgendetwas an Deiner Ausruestung verhindert, dass Du Dich mit "
+          "%s so richtig wohl fuehlst.",name(WEM,1)),78,
+          (all?(Name(WER)+": "):0)));
+  }
+
+  // dann mal aus der Kleidung geerbte Pruefungen ausfuehren und Ergebnis
+  // liefern.
+  return ::_check_wear_restrictions(silent,all);
+}
+
+protected void _informwear(int silent, int all) {
+
+  // Ruestungen koennen Resistenzen beeinflussen
+  PL->AddResistanceModifier(QueryProp(P_RESISTANCE_STRENGTHS),
+                            QueryProp(P_ARMOUR_TYPE));
+
+  // Ruestungen koennen Attribute aendern/blockieren. Also muessen diese
+  // nach dem Anziehen aktualisiert werden
+  PL->register_modifier(ME);
+  PL->UpdateAttributes();
+
+  // P_TOTAL_AC im Traeger updaten (fuer Query()s)
+  PL->QueryProp(P_TOTAL_AC);
+
+  // Alle Ruestungen werden im awmaster registriert, sobald sie von
+  // einem Spieler gezueckt werden
+  if (!logged && query_once_interactive(PL)) {
+    call_other("/secure/awmaster","RegisterArmour",ME);
+    logged=1;
+  }
+  // noch das aus der Kleidung rufen, damit die Anziehmeldungen auch kommen.
+  // ausserdem laeuft das Anstosses von InformWear() von dort.
+  ::_informwear(silent,all);
+}
+
+
+protected int _check_unwear_restrictions(object worn_by, int silent, 
+                                            int all) {
+  // liefert >=0 zureck, wenn die Kleidung/Ruestung ausgezogen werden kann, 
+  // <0 sonst.
+
+  // Schilde belegen (mindestens) eine Hand. Hngl. Wenn man diesen bloeden
+  // Check nicht machen muesste, koennte man sich die ganze Funktion sparen.
+  // Hmpfgrmpfl. Achja, raise_error(), weil das eigentlich ja nicht vorkommen
+  // sollte und gefixt werden soll. Das geht naemlich nur, wenn jemand diese
+  // Prop geaendert, waehrend der Spieler das Schild getragen hatte.
+  if ( (QueryProp(P_ARMOUR_TYPE)==AT_SHIELD) && 
+      QueryProp(P_NR_HANDS)<1 ) {
+    raise_error(sprintf("Fixme: AT_SHIELD beim Ausziehen ohne P_NR_HANDS: %O",
+	  object_name()));
+  }
+  
+  // Ausziehcheck der Kleidung machen
+  return ::_check_unwear_restrictions(worn_by,silent,all);
+}
+
+protected void _informunwear(object worn_by, int silent, int all) {
+  mixed res;
+  // Gesetzte Resistenzen loeschen
+  worn_by->RemoveResistanceModifier(res=QueryProp(P_ARMOUR_TYPE));
+  
+  // Ruestungen koennen Attribute aendern/blockieren. Also muessen diese
+  // nach dem Ausziehen aktualisiert werden
+  worn_by->deregister_modifiers(ME);
+  worn_by->UpdateAttributes();
+
+  // P_TOTAL_AC im Traeger updaten
+  worn_by->QueryProp(P_TOTAL_AC);
+
+  // die geerbte Funktion aus der Kleindung gibt noch meldungen aus und ruft
+  // Informunwear().
+  ::_informunwear(worn_by,silent,all);
+}
+
+// Funktion, die das "trage"/"ziehe * an"-Kommando auswertet
+varargs int do_wear(string str, int silent) {  
+  int all;  
+
+  // Hat der Spieler "trage alles" eingegeben?
+  all=(str=="alles" || str=="alle ruestungen");
+  
+  return(_do_wear(str,silent,all));
+}
+
+// Die Funktion, die das "ziehe * aus"-Kommando auswertet
+varargs int do_unwear(string str, int silent) {
+  int all;
+
+  all=(str=="alles" || str=="alle ruestungen");
+  return(_do_unwear(str,silent,all));
+}
+
+
+// Objekte, die die Beschaedigung einer Ruestung durch direktes Setzen von
+// P_DAMAGED durchfuehren, werden im awmaster geloggt
+static mixed _set_item_damaged(mixed arg) {
+    if (arg && !intp(arg))
+    {
+        return Query(P_DAMAGED, F_VALUE);
+    }
+
+    if (previous_object(1))
+      call_other("/secure/awmaster","RegisterDamager",
+            previous_object(1),QueryProp(P_DAMAGED),arg); 
+
+    return Set(P_DAMAGED, arg, F_VALUE);
+}
+
+// Will man eine Ruestung beschaedigen oder reparieren, so macht man das
+// am besten ueber die Funktion Damage(argument). Positive Argumente
+// bedeuten eine Beschaedigung, negative eine Reparatur. Der Rueckgabewert
+// ist die wirklich durchgefuehrte Aenderung des Beschaedigungswertes
+int Damage(int new_dam) {   
+  int    ac,maximum,old_dam;
+  object w;
+
+  if (!new_dam || !intp(new_dam)) {      
+    return 0;
+  }
+
+  if ( (ac=QueryProp(P_AC))<=0 && (new_dam>0) ) {
+    // Sonst wuerde Beschaedigung zur Reparatur fuehren
+    return 0;
+  }
+
+  // Min-AC und MAX_AC beachten
+  if ((ac-new_dam) < MIN_ARMOUR_CLASS) {      
+    new_dam = ac-MIN_ARMOUR_CLASS;
+  }
+  else if ((ac-new_dam) >
+    (maximum=VALID_ARMOUR_CLASS[QueryProp(P_ARMOUR_TYPE)])) {      
+    new_dam = ac-maximum;
+  }
+
+  // Nie mehr als 100% reparieren
+  if ( ((old_dam=QueryProp(P_DAMAGED))<-new_dam) && (new_dam<0) ) {
+    new_dam=-old_dam;
+  }
+
+  // Aenderungen an der Ruestungsklasse und dem Beschaedigungswert
+  // durchfuehren
+  SetProp(P_AC,(ac-new_dam));
+  // eigene Set-Methode umgehen
+  Set(P_DAMAGED,(old_dam+new_dam),F_VALUE);
+
+  // P_TOTAL_AC im Traeger updaten, wenn vorhanden
+  if (objectp(w=QueryProp(P_WORN)))
+    w->QueryProp(P_TOTAL_AC);
+
+  // Rueckgabewert: Durchgefuehrte Aenderung an P_DAMAGE
+  return new_dam;
+}
+
+public status IsArmour() {return 1;}
+public status IsClothing() {return 0;}
+