diff --git a/doc/sphinx/man/props/P_SENSITIVE b/doc/sphinx/man/props/P_SENSITIVE
new file mode 100644
index 0000000..c1e8051
--- /dev/null
+++ b/doc/sphinx/man/props/P_SENSITIVE
@@ -0,0 +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.
+
+   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();
+   }
+
+   - 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
+
+Letzte Aenderung: 10. Januar 2015, Arathorn