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