diff --git a/doc/sphinx/man/lfun/DefendInfo b/doc/sphinx/man/lfun/DefendInfo
new file mode 100644
index 0000000..21d41ac
--- /dev/null
+++ b/doc/sphinx/man/lfun/DefendInfo
@@ -0,0 +1,216 @@
+
+DefendInfo()
+************
+
+
+FUNKTION
+========
+
+
+DEFINIERT IN
+============
+
+   /sys/combat.h
+
+
+ARGUMENTE
+=========
+
+
+BESCHREIBUNG
+============
+
+    Die DefendInformationen werden im Runde eines Attack/Defend Vorgangs
+    in Attack initial angelegt und dem Defend ueber den Parameter spell
+    uebergeben. Ist dieser Parameter ein Mapping, so sind die
+    DefendInformationen ueber den Key EINFO_DEFEND zu erhalten.
+    Die Informationen liegen in Form eines Mappings vor.
+    Vor Zugriff sollte immer auf die Existenz dieses Keys in dem Mapping
+    geprueft werden, da nicht alle Informationen immer existieren.
+    Die Keys sind in combat.h definiert und sind folgende:
+
+
+
+   ORIGINAL_AINFO - Mapping
+       Hier ist eine Kopie des originalen ainfo-mappings des Attacks
+       vorhanden mit folgenden Eintraegen:
+       Immer vorhandene Eintraege:
+         SI_ENEMY              der angegriffene Gegner
+
+
+
+       Angriff mit gezueckter Waffe:
+         P_WEAPON              das Waffenobjekt selbst
+         P_WEAPON_TYPE         P_WEAPON_TYPE der Waffe
+         P_WC                  P_WC der Waffe
+         P_NR_HANDS            P_NR_HANDS der Waffe
+         SI_SKILLDAMAGE_TYPE   P_DAM_TYPE der Waffe
+         SI_SKILLDAMAGE        waffe->QueryDamage(enemy)
+            bei vorhandenem Zweihandskill SK_TWOHANDED wird nur der durch
+            den Skill modifizierte Schadenswert uebernommen
+         SI_SKILLDAMAGE_MSG    "mit "+waffe->name(WEM,0)
+         SI_SKILLDAMAGE_MSG2   "mit "+waffe->name(WEM,1)
+         SI_SPELL              0
+
+       Angriff mit blossen Haenden:
+         P_WEAPON_TYPE         WT_HANDS
+         P_WC                  P_HANDS[1]
+         SI_SKILLDAMAGE        Schadenswert, aus P_HANDS[1] und A_STR
+                               berechnet
+         SI_SKILLDAMAGE_TYPE   P_HANDS[2]
+         SI_SKILLDAMAGE_MSG
+         SI_SKILLDAMAGE_MSG2   beides P_HANDS[0]
+         SI_SPELL              0
+
+
+
+       Angriff mit einem Spell (SK_MAGIC_ATTACK):
+         SI_SKILLDAMAGE        Schadenswert des Spells
+         SI_SKILLDAMAGE_TYPE   Schadenstypen des Spells
+         SI_SKILLDAMAGE_MSG    Schadensmeldung des Spells, wenn vorhanden,
+                               sonst "mit magischen Faehigkeiten"
+         SI_SKILLDAMAGE_MSG2   entsprechende Meldung des Spells, wenn
+                               gesetzt, ansonsten identisch mit
+                               SI_SKILLDAMAGE_MSG
+         P_WEAPON_TYPE         P_WEAPON_TYPE des Spells, wenn vorhanden,
+                               sonst WT_MAGIC
+         SI_SPELL              SI_SPELL des Spells
+
+
+
+       Hinweise:
+       - Alle Eintraege in diesem Mapping koennen bereits durch
+         InternalModifyAttack() veraendert worden sein.
+       - Die Daten werden mittels deep_copy(ainfo) eingetragen.
+       - Daten in den Eintraegen SI_SKILLDAMAGE* und SI_SPELL koennen bei
+         physikalischen Angriffen durch die Skills FIGHT(P_WEAPON_TYPE) oder
+         SK_FIGHT oder durch einen P_TMP_ATTACK_MOD bzw. Hook vom Typ
+         H_HOOK_ATTACK_MOD modifiziert worden sein.
+
+
+
+   ORIGINAL_DAM - int
+       Der Originalschaden aus dem Attack
+
+   ORIGINAL_DAM_TYPE - string/string*
+       Der Originaldamagetyp aus dem Attack
+
+   CURRENT_DAM - int
+       Der momentane Schaden, nach schon erfolgten Modifikationen
+
+
+
+   CURRENT_DAM_TYPE - string/string*
+       Der momentane Damagetyp, nach schon erfolgten Modifikationen
+
+
+
+   ENEMY_INSERTED - int
+       0 oder 1 je nachdem ob der Angreifer schon in der enemy-list
+       vorhanden war oder nicht
+
+
+
+   RFR_REDUCE - int
+       0 oder reduzierter Schaden durch RFR Modifikation
+
+
+
+   PRESENT_DEFENDERS - Array
+       Liste der durch InformDefend informierten Defender als Objekt.
+       Ein Defender wird immer NACH InformDefend
+       dazugefuegt
+
+
+
+   DEFENDING_DEFENDER - Array ({})
+       Hat ein durch InformDefend ein Defender verteidigt, so wird
+       fuer diesen Defender ein Eintrag in diesem Array vorgenommen,
+       welcher folgende Struktur besitzt.
+               ({
+                       DEF_DEFENDER - Object
+                         Der Verteidiger, welcher VOR
+                         DefendOther eingefuegt wird
+                       DEF_DAM - int
+                         Der veraenderte Schaden, welcher NACH
+                         DefendOther eingefuegt wird
+                       DEF_DAMTYPE string/string*
+                         Die veraenderte Schadensart, welche
+                         NACH DefendOther eingefuegt wird
+                       DEF_SPELL - Mapping
+                         Das Mapping des veraenderten Spells, welches
+                         als Kopie NACH DefendOther eingefuegt wird
+               })
+
+
+
+   DEFEND_HOOK - Int/Array
+       DI_NOHOOK, wenn kein Hook da war, DI_HOOKINTERRUPT, wenn der
+       Hook das Defend unterbricht, DI_HOOK, wenn ein Hook vorhanden
+       ist, dieser das Defend aber unveraendert laesst.
+       Veraendert ein Hook das Defend, so ist hier ein Array zu finden
+       mit den veraenderten Parametern in der Struktur:
+               ({
+                       HOOK_DAM - int
+                          Der veraenderte Schaden
+                       HOOK_DAMTYPE - string/string*
+                          Die veraenderte Schadensart
+                       HOOK_SPELL - Mapping
+                          Das Mapping des veraenderten Spells als Kopie
+               })
+
+
+
+   DEFEND_ARMOURS - Mapping (2 Werte pro Key)
+       Liste der beruecksichtigten Ruestungen. Fuer jede Ruestung
+       wird ein Eintrag vorgenommen, mit dem Objekt der jeweiligen
+       Ruestung als Key. Hierbei werden die Ruestungen erst eingetragen,
+       wenn ihr jeweiliges QueryDefend() aufgerufen wird, d.h. es sind nicht
+       von Anfang an alle getragenen Ruestung drin. Jeder Eintrag im Mapping
+       besitzt die folgenden 2 Werte:
+               DEF_ARMOUR_DAM - int
+                   Der Schaden NACH QueryDefend (vorher 0)
+               DEF_ARMOUR_PROT - int
+                   Verteidigungswert der Ruestung VOR DefendFunc
+       Bsp: Ich will wissen, wie gut 'ruestung' schuetzte:
+            spell[EINFO_DEFEND][DEFEND_ARMOURS][ruestung,DEF_ARMOUR_PROT]
+
+   DEFEND_GUILD - Array
+       Eine Liste mit der Modifikation der Gilde mit der Struktur
+               ({
+                       GUILD_DAM - int
+                         Der veraenderte Schaden
+                       GUILD_DAMTYPE - string/string*
+                         Die veraenderte Schadensart
+               })
+
+
+
+   DEFEND_RESI - int
+       Schaden nach CheckResistance
+
+
+
+   DEFEND_BODY - int
+       Schaden nach Beruecksichtigung des Bodies (nur
+       physikalisch)
+
+
+
+   DEFEND_LOSTLP - int
+       Tatsaechlich abgezogene LP
+
+
+
+   DEFEND_CUR_ARMOUR_PROT - int
+       Schutz der Ruestung vor Call der
+       DefendFunc. Ist nur in der DefendFunc definiert. Kann auch aus
+       DEFEND_ARMOURS entnommen werden
+
+
+SIEHE AUCH
+==========
+
+   Attack, Defend
+
+18.Jul 2006 Muadib