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