diff --git a/doc/sphinx/lfun/DefendInfo.rst b/doc/sphinx/lfun/DefendInfo.rst
new file mode 100644
index 0000000..5067cac
--- /dev/null
+++ b/doc/sphinx/lfun/DefendInfo.rst
@@ -0,0 +1,218 @@
+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
+