diff --git a/doc/sphinx/man/lfun/Defend b/doc/sphinx/man/lfun/Defend
new file mode 100644
index 0000000..aa53945
--- /dev/null
+++ b/doc/sphinx/man/lfun/Defend
@@ -0,0 +1,175 @@
+
+Defend()
+********
+
+
+FUNKTION
+========
+
+   public int Defend(int dam, string|string* dam_type, int|mapping spell,
+                      object enemy)
+
+
+DEFINIERT IN
+============
+
+   /std/living/combat
+
+
+ARGUMENTE
+=========
+
+   int dam                  initiale Staerke des Angriffs (10 dam ~ 1 HP)
+   string* dam_type         Art(en) des Schadens, der angerichtet werden
+                            soll
+                            Muss ein Array von Schadenstypen sein,
+                            alte Objekte uebergeben hier manchmal strings.
+   int/mapping spell        - 0 fuer normale Angriffe (keine Zauber)
+                            - 1 fuer Zauber (Standardruestungen ignorieren)
+                            - mapping fuer mehr Informationen
+                            Heute bitte nach Moeglichkeit ein Mapping
+                            uebergeben.
+   object enemy             der Feind/Schadenverursacher
+
+
+BESCHREIBUNG
+============
+
+   1. Generell
+   Wenn das Lebewesen angegriffen wird, wird geprueft, wie stark die
+   Ruestungen und koerpereigenen Abwehrkraefte sind und die Staerke des
+   Schadens dementsprechend vermindert.
+   Ggf. wird der Schaden zugefuegt und der Feind in  die Liste der Feinde
+   aufgenommen. Der Schaden betraegt:
+    (dam-Summe(Ruestungsstaerken)-random(P_BODY+A_DEX))*CheckResistance/10
+   aber nicht unter 0.
+
+   2. Der Parameter 'spell'
+   Ist 'spell' 0, dann gilt der Angriff als normale physische Attacke
+   Uebergibt man als 'spell'-Parameter ein Mapping, so gibt es dafuer
+   diverse Flags, die das Ergebnis manipulieren (in new_skills.h
+   enthalten). Nichtangabe eines Flags gilt als 0.
+
+   - SP_PHYSICAL_ATTACK ---------- 0/1
+              1, wenn Ruestungen wirken sollen, 0 sonst
+              -> entspricht !spell, wenn dieses Int ist
+   - SP_NO_ENEMY ----------------- 0/1
+              1, falls der Angriff nicht toedlich ist, es also keinen echten
+              Gegner gibt
+              -> es wird dann reduce_hit_points() gerufen statt do_damage()
+   - SP_NO_ACTIVE_DEFENSE -------- 0/1
+              1, falls aktive Abwehren (wie zurueckschlagende Amulette,
+              Karateabwehren oder Ausweichmanoever) unterbleiben sollen
+              -> zB bei Kratzen durch Dornen oder Fall aus grosser Hoehe
+                 ist aktive Abwehr oder Ausweichen unlogisch
+   - SP_RECURSIVE ---------------- 0/1
+              1, falls der Spell aus einem Defend gerufen wurde (oder einer
+              DefendFunc)
+              -> verhindert Rekursionsprobleme
+   - SP_NAME --------------------- string
+              Name des Spells
+   - SP_REDUCE_ARMOUR ------------ Mapping: keys AT_X/P_BODY, values int>=0
+              Die Schutzwirkung durch P_AC/Magie einer Ruestung wird
+              typabhaengig reduziert. Aufbau eines Mappings im Beispiel:
+              ([AT_BOOTS: 0,  // Stiefel schuetzen gar nicht
+                P_BODY:  50,  // Koerper zu 50%
+                AT_BELT: 600  // Guertel zu 600%
+              ])
+              -> alle 'fehlenden' Eintraege wirken normal
+   - SP_SHOW_DAMAGE -------------- 0/1 oder Array von Arrays
+              0, fuer keine Treffermeldung, 1 sonst
+              In einem Array koennen Ersatz-Treffermeldungen definiert
+              werden. Format ist:
+              ({
+               ({ int lphit1, string mess_me,
+                              string mess_en,
+                              string mess_room }),
+               ({ lphit2, mess_me, mess_en, mess_room }),
+               ...
+               ({ lphitn, mess_me, mess_en, mess_room }),
+              })
+              wobei lphit1<lphit2<...<lphitn sein muss, d.h. das Array-
+              Array aufsteigend sortiert.
+
+              Ist ein Treffer x LP hart, werden die Meldungen des lphit-
+              Arrays ausgegeben, dessen Wert am naehesten unter dem Schaden
+              liegt.
+
+              In den Meldungen mess_me (an den Getroffenen), mess_en (an
+              den Feind), mess_room (an die restlichen Umstehenden) koennen
+              Ersatzstrings wie folgt verwendet werden:
+              @WER1/@WESSEN1/@WEM1/@WEN1 - name(casus) des Getroffenen (TO)
+              @WER2/@WESSEN2/@WEM2/@WEN2 - name(casus) des Feindes (enemy)
+   - EINFO_DEFEND ------------ Mapping
+              Dieses Mapping liefert erweiterte Informationen zu dem
+              bisherigen Ablauf des aktiven Attacks.
+              Die verfuegbaren Informationen sind in der Manpage zu
+              DefendInfo festgehalten.
+
+   3. Reihenfolgen in Defend
+   - das Living wird angegriffen, wenn
+     - P_NO_ATTACK != 0
+     - 'enemy' existiert und kein netztoter Spieler ist
+   - P_DEFENDERS werden durchgegangen (und eventuell benachrichtigt)
+   - P_TMP_ATTACK_HOOK wird abgefragt
+   - die Ruestungen werden vom Schaden gegebenenfalls abgezogen
+   - magischer Ausweichskill beruecksichtigt
+   - sensitive Objekte werden ggf. benachrichtigt
+   - InternalModifyDefend wird gerufen
+   - Koerperabwehr abgezogen
+   - der Schaden an do_damage()/reduce_hit_points() uebergeben
+   - Flucht ueberpruefen mit CheckWimpyAndFlee()
+
+
+BEMERKUNGEN
+===========
+
+   Ruestungen wirken konventionell nur, wenn mindestens ein Schadensanteil
+   mechanisch ist und es kein Spell oder ein Spell mit SP_PHYSICAL_ATTACK
+   auf 1 ist.
+
+   Defend() beruecksichtigt magische Verteidigungen, die der Spieler bei
+   sich hat, sollte also aus Fairness gegenueber den Objekten anderer
+   Magier immer dem direkten reduce_hit_points() oder do_damage()
+   vorgezogen werden. Mittels der Flags in 'spell' kann man sehr viel
+   aendern.
+
+
+RUECKGABEWERT
+=============
+
+   Hoehe des tatsaechlichen Schadens. Dies kann mehr sein als die
+   Lebenspunkte des Lebewesens.
+
+BEISPIELE (SIEHE AUCH Defend_bsp):
+   // ein simpler Angriff: enem->Defend(100, ({DT_BLUDGEON}), 0,
+   this_object());
+
+   // ein magischer Angriff (ohne Treffermeldung): enem->Defend(100,
+   ({DT_BLUDGEON, DT_FIRE}), 1, this_object());
+
+   // ein magischer Angriff mit Treffermeldung: enem->Defend(100,
+   ({DT_BLUDGEON, DT_FIRE}), ([SP_SHOW_DAMAGE:1]),
+
+      this_object());
+
+
+SIEHE AUCH
+==========
+
+   Angriff:   Attack(L), P_NO_ATTACK, InsertEnemy(L)
+   Schaden:   P_ENABLE_IN_ATTACK_OUT, P_LAST_MOVE,
+              do_damage(L), reduce_hit_points(L)
+   Schutz:    P_DEFENDERS, InformDefend(L), DefendOther(L)
+              P_ARMOURS, P_AC, P_DEFEND_FUNC, QueryDefend(L)
+              P_BODY, A_DEX
+   Daten:     P_LAST_COMBAT_TIME
+              P_LAST_DAMTYPES, P_LAST_DAMTIME, P_LAST_DAMAGE
+              P_DAMAGE_MSG
+   Resistenz: P_RESISTANCE_STRENGTHS, CheckResistance(L)
+   Sonstiges: CheckSensitiveAttack(L)
+              InternalModifyDefend(L)
+              UseSkill(L),
+              DefendInfo
+
+15.09.2010, Zesstra