diff --git a/doc/props/P_SENSITIVE b/doc/props/P_SENSITIVE
index 23d1fee..c1e8051 100644
--- a/doc/props/P_SENSITIVE
+++ b/doc/props/P_SENSITIVE
@@ -1,125 +1,154 @@
+
 P_SENSITIVE
-NAME:
-     P_SENSITIVE                   "sensitive"
+***********
 
-DEFINIERT IN:
-     /sys/thing/moving.h
 
-BESCHREIBUNG:
-     Diese Property kann in Objekten gesetzt werden, die auf bestimmte
-     Schadensarten empfindlich reagieren sollen. Moegliche Anwendungsfaelle:
-     - Das Lebewesen, in dessen Inventar sich ein Objekt befindet, erleidet
-       einen Angriff mit der fraglichen Schadensart (Beispiel: eine 
-       Pusteblume, die bei Angriff mit Luftschaden auseinanderfaellt).
-     - Zwei Objekte treffen im gleichen Environment aufeinander, wobei
-       eines empfindlich auf eine Schadensart reagiert, und das zweite diese
-       Schadensart mitbringt, d.h. die Empfindlichkeit ausloesen kann.
-       (Beispiel: ein feuerempfindlicher Postsack wird angesengt, wenn eine
-        brennende Fackel ins gleiche Inventar kommt.)
-       Das Ausloesen dieser Empfindlichkeit ist unabhaengig davon, welches 
-       Objekt zuerst da war.
+NAME
+====
 
-     Die Property enthaelt ein Array aus Arrays:
-       ({<sensprops_1>, <sensprops_2>, ..., <sensprops_n>})
-     
-     wobei jeder Eintrag <sensprops> jeweils folgende Struktur hat:
-       ({string list_key, string damtype, int treshold, mixed options })
-     
-     Die Eintraege haben dabei folgende Bedeutung:
-     
-     list_key: Kann einen von folgenden drei Werten annehmen 
-          1) SENSITIVE_INVENTORY, passive Eigenschaft; zeigt an, dass das
-             Objekt empfindlich auf aktive Objekte reagiert, die in das
-             Inventory des Containers hineinbewegt werden
-          2) SENSITIVE_ATTACK, passive Eigenschaft; zeigt an, dass das 
-             Objekt empfindlich auf aeussere Einfluesse bzw. Angriffe 
-             auf ein Lebewesen reagiert, in dessen Inventar es sich befindet
-          3) SENSITIVE_INVENTORY_TRIGGER, aktive Eigenschaft; zeigt an, dass
-             das Objekt eine Ausstrahlung auf andere Objekte im Inventar
-             hat. Wird ausgeloest, wenn das Objekt ins Inventar hineinbewegt
-             wird.
-     damtype: eine Schadensart (DT_FIRE, DT_WATER, ...)
-     treshold: hat zwei Bedeutungen abhaengig von dem Wert in list_key:
-          1) Fuer Objekte mit SENSITIVE_INVENTORY oder SENSITIVE_ATTCK ist
-             dies der Schadenswert, ab dem das Objekt benachrichtigt werden 
-             soll.
-             Hier wird ein Wert in "Defend-Einheiten" erwartet, d.h. das
-             Zehnfache dessen, was am Ende in LP abgezogen wuerde.
-          2) Fuer Objekte mit SENSITIVE_INVENTORY_TRIGGER ist dies der 
-             Schadenswert, mit dem das Objekt andere bereits im Inventar
-             des Containers befindliche Objekte beeinflusst, die eine 
-             entsprechende Empfindlichkeit gesetzt haben
-     options: Optionale Daten, die der programmierende Magier selbst
-            definieren kann. Werden an die in den betroffenen Objekten
-            aufgerufenen Funktionen durchgereicht.
+   P_SENSITIVE                   "sensitive"
 
-     Ein SENSITIVE_ATTACK-Objekt, dessen Trigger-Bedingungen erfuellt sind,
-     wird durch folgenden Funktionsaufruf darueber informiert:
-       trigger_sensitive_attack(object enemy, string damtype, int damage,
-                 mixed spell, mixed options)
-     
-     Ein SENSITIVE_INVENTORY-Objekt, dessen Trigger-Bedingungen erfuellt sind,
-     wird durch folgenden Funktionsaufruf darueber informiert:
-       trigger_sensitive_inv(object whodid, string damtype, int threshold,
-                 mixed options, mixed options)
 
-     Die beiden Funktionen muessen selbst ge-/ueberschrieben werden.
+DEFINIERT IN
+============
 
-BEMERKUNGEN:
-     1. P_SENSITIVE-Objekte kosten Rechenzeit bei jedem Angriff oder jedem
-        move() - daher bitte sparsam verwenden
-     2. Ist P_SENSITIVE nicht statisch, sondern wird es situationsabhaengig 
-        geaendert, muss man das environment() jeweils selbst ueber seine 
-        neue Empfindlichkeit benachrichtigen. Dies geschieht mit den 
-        Funktionen RemoveSensitiveObject() bzw.InsertSensitiveObject(), 
-        siehe deren Manpages.
+   /sys/thing/moving.h
 
-BEISPIEL:
-     Beispiel 1:
-     Beispielcode eines Objektes mit SENSITIVE_ATTACK und SENSITIVE_INVENTORY
-     siehe hier: /doc/beispiele/testobjekte/attack_busy_sensitive_testobj.c
 
-     Beispiel 2:
-     Ein Eiszapfen, der bei Feuerangriffen oder bei heissen Gegenstaenden im
-     gemeinsamen Environment zerschmelzen soll:
+BESCHREIBUNG
+============
 
-     void create() {
-       SetProp( P_SENSITIVE, ({ ({SENSITIVE_ATTACK,     DT_FIRE, 100}),
-                                 ({SENSITIVE_INVENTORY, DT_FIRE, 100}) }) );
-       [...]
+   Diese Property kann in Objekten gesetzt werden, die auf bestimmte
+   Schadensarten empfindlich reagieren sollen. Moegliche Anwendungsfaelle:
+   - Das Lebewesen, in dessen Inventar sich ein Objekt befindet, erleidet
+     einen Angriff mit der fraglichen Schadensart (Beispiel: eine
+     Pusteblume, die bei Angriff mit Luftschaden auseinanderfaellt).
+   - Zwei Objekte treffen im gleichen Environment aufeinander, wobei
+     eines empfindlich auf eine Schadensart reagiert, und das zweite diese
+     Schadensart mitbringt, d.h. die Empfindlichkeit ausloesen kann.
+     (Beispiel: ein feuerempfindlicher Postsack wird angesengt, wenn eine
+      brennende Fackel ins gleiche Inventar kommt.)
+     Das Ausloesen dieser Empfindlichkeit ist unabhaengig davon, welches
+     Objekt zuerst da war.
+
+   Die Property enthaelt ein Array aus Arrays:
+     ({<sensprops_1>, <sensprops_2>, ..., <sensprops_n>})
+
+
+
+   wobei jeder Eintrag <sensprops> jeweils folgende Struktur hat:
+     ({string list_key, string damtype, int treshold, mixed options })
+
+
+
+   Die Eintraege haben dabei folgende Bedeutung:
+
+
+
+   list_key: Kann einen von folgenden drei Werten annehmen
+        1) SENSITIVE_INVENTORY, passive Eigenschaft; zeigt an, dass das
+           Objekt empfindlich auf aktive Objekte reagiert, die in das
+           Inventory des Containers hineinbewegt werden
+        2) SENSITIVE_ATTACK, passive Eigenschaft; zeigt an, dass das
+           Objekt empfindlich auf aeussere Einfluesse bzw. Angriffe
+           auf ein Lebewesen reagiert, in dessen Inventar es sich befindet
+        3) SENSITIVE_INVENTORY_TRIGGER, aktive Eigenschaft; zeigt an, dass
+           das Objekt eine Ausstrahlung auf andere Objekte im Inventar
+           hat. Wird ausgeloest, wenn das Objekt ins Inventar hineinbewegt
+           wird.
+   damtype: eine Schadensart (DT_FIRE, DT_WATER, ...)
+   treshold: hat zwei Bedeutungen abhaengig von dem Wert in list_key:
+        1) Fuer Objekte mit SENSITIVE_INVENTORY oder SENSITIVE_ATTCK ist
+           dies der Schadenswert, ab dem das Objekt benachrichtigt werden
+           soll.
+           Hier wird ein Wert in "Defend-Einheiten" erwartet, d.h. das
+           Zehnfache dessen, was am Ende in LP abgezogen wuerde.
+        2) Fuer Objekte mit SENSITIVE_INVENTORY_TRIGGER ist dies der
+           Schadenswert, mit dem das Objekt andere bereits im Inventar
+           des Containers befindliche Objekte beeinflusst, die eine
+           entsprechende Empfindlichkeit gesetzt haben
+   options: Optionale Daten, die der programmierende Magier selbst
+          definieren kann. Werden an die in den betroffenen Objekten
+          aufgerufenen Funktionen durchgereicht.
+
+   Ein SENSITIVE_ATTACK-Objekt, dessen Trigger-Bedingungen erfuellt sind,
+   wird durch folgenden Funktionsaufruf darueber informiert:
+     trigger_sensitive_attack(object enemy, string damtype, int damage,
+               mixed spell, mixed options)
+
+
+
+   Ein SENSITIVE_INVENTORY-Objekt, dessen Trigger-Bedingungen erfuellt sind,
+   wird durch folgenden Funktionsaufruf darueber informiert:
+     trigger_sensitive_inv(object whodid, string damtype, int threshold,
+               mixed options, mixed options)
+
+   Die beiden Funktionen muessen selbst ge-/ueberschrieben werden.
+
+
+BEMERKUNGEN
+===========
+
+   1. P_SENSITIVE-Objekte kosten Rechenzeit bei jedem Angriff oder jedem
+      move() - daher bitte sparsam verwenden
+   2. Ist P_SENSITIVE nicht statisch, sondern wird es situationsabhaengig
+      geaendert, muss man das environment() jeweils selbst ueber seine
+      neue Empfindlichkeit benachrichtigen. Dies geschieht mit den
+      Funktionen RemoveSensitiveObject() bzw.InsertSensitiveObject(),
+      siehe deren Manpages.
+
+
+BEISPIEL
+========
+
+   Beispiel 1:
+   Beispielcode eines Objektes mit SENSITIVE_ATTACK und SENSITIVE_INVENTORY
+   siehe hier: /doc/beispiele/testobjekte/attack_busy_sensitive_testobj.c
+
+   Beispiel 2:
+   Ein Eiszapfen, der bei Feuerangriffen oder bei heissen Gegenstaenden im
+   gemeinsamen Environment zerschmelzen soll:
+
+   void create() {
+     SetProp( P_SENSITIVE, ({ ({SENSITIVE_ATTACK,     DT_FIRE, 100}),
+                               ({SENSITIVE_INVENTORY, DT_FIRE, 100}) }) );
+     [...]
+   }
+
+   varargs void trigger_sensitive_attack() {
+     remove();
+   }
+
+   varargs void trigger_sensitive_inv() {
+     call_out("remove",0);  // verzoegert, wegen move()
+   }
+
+   varargs int remove(int silent) {
+     if(!silent) {
+       object room = all_environment(this_object())[<1];
+       tell_room(room, Name()+" zerschmilzt.\n");
      }
+     return ::remove();
+   }
 
-     varargs void trigger_sensitive_attack() {
-       remove();
-     }
+   - wird eine Fackel mit
+     SetProp(P_SENSITIVE,({({SENSITIVE_INVENTORY_TRIGGER,DT_FIRE,250})}))
+     in das gleiche environment() wie dieser Zapfen bewegt wird, loest
+     diese im Zapfen trigger_sensitive_inv() aus
+   - wird ein Angriff mit DT_FIRE und initialem Schaden > 100 auf das
+     environment() veruebt, loest dies im Zapfen trigger_sensitive_attack()
+     aus
 
-     varargs void trigger_sensitive_inv() {
-       call_out("remove",0);  // verzoegert, wegen move()
-     }
 
-     varargs int remove(int silent) {
-       if(!silent) {
-         object room = all_environment(this_object())[<1];
-         tell_room(room, Name()+" zerschmilzt.\n");
-       }
-       return ::remove();
-     }
+SIEHE AUCH
+==========
 
-     - wird eine Fackel mit
-       SetProp(P_SENSITIVE,({({SENSITIVE_INVENTORY_TRIGGER,DT_FIRE,250})}))
-       in das gleiche environment() wie dieser Zapfen bewegt wird, loest
-       diese im Zapfen trigger_sensitive_inv() aus
-     - wird ein Angriff mit DT_FIRE und initialem Schaden > 100 auf das
-       environment() veruebt, loest dies im Zapfen trigger_sensitive_attack()
-       aus
-
-SIEHE AUCH:
-     Properties: P_SENSITIVE_ATTACK, P_SENSITIVE_INVENTORY,
-                 P_SENSITIVE_INVENTORY_TRIGGER
-     Funktionen: InsertSensitiveObject(L), RemoveSensitiveObject(L),
-                 CheckSensitiveAttack(L), Defend(), 
-                 insert_sensitive_inv(L), insert_sensitive_inv_trigger(L),
-                 trigger_sensitive_inv(L), trigger_sensitive_attack(L)
-     Defines:    /sys/sensitive.h
+   Properties: P_SENSITIVE_ATTACK, P_SENSITIVE_INVENTORY,
+               P_SENSITIVE_INVENTORY_TRIGGER
+   Funktionen: InsertSensitiveObject(L), RemoveSensitiveObject(L),
+               CheckSensitiveAttack(L), Defend(),
+               insert_sensitive_inv(L), insert_sensitive_inv_trigger(L),
+               trigger_sensitive_inv(L), trigger_sensitive_attack(L)
+   Defines:    /sys/sensitive.h
 
 Letzte Aenderung: 10. Januar 2015, Arathorn