diff --git a/doc/lfun/AddSpell b/doc/lfun/AddSpell
index b08a296..a8623e0 100644
--- a/doc/lfun/AddSpell
+++ b/doc/lfun/AddSpell
@@ -7,7 +7,7 @@
 ========
 
    varargs int AddSpell(int rate, int damage,
-      string|<int|spell>* TextForEnemy, string|<int|string>*
+      string|<int|string>* TextForEnemy, string|<int|string>*
       TextForOthers, string|string* dam_type, string|closure func,
       int|mapping spellarg)
 
@@ -27,25 +27,26 @@
    damage        - Der Schadenswert fuer Defend(),
       muss > 0 sein
 
-   TextForEnemy  - Text, den der Feind erhalten soll
+   TextForEnemy  - Text, den der Feind erhalten soll.
       String <text> oder Array der Form ({<text>,<messagetype>})
       (Siehe ReceiveMsg())
 
-   TextForOthers - Text, den andere im Raum erhalten sollen
-      String <text> oder Array der Form ({<text>,<messagetype>})
-      (Siehe ReceiveMsg())
+   TextForOthers - Text, den andere im Raum erhalten sollen.
+      String <text> ode Array der Form ({<text>,<messagetype>}) (Siehe
+      ReceiveMsg())
 
    dam_type      - Schadenstyp(en) fuer Defend(),
       (Default: ({DT_MAGIC}) fuer Magische und ({DT_BLUDGEON}) fuer
       physikalische Angriffe)
 
    func          - Funktionsname oder Closure, die nach Anwendung
-      aufgerufen werden soll (Optional, bekommt als Argumente object
+      aufgerufen werden soll. (Optional, bekommt als Argumente object
       enemy, int real_damage, string* dam_type)
 
    sinfo         - Skillinfomapping, muss SI_SPELL mit den SP_* fuer
-      den Aufruf von Defend() enthalten Default ist ([SI_SPELL:
-      ([SP_PHYSICAL_ATTACK: 0]), SI_MAGIC_TYPE: ({ MT_ANGRIFF }) ])
+      den Aufruf von Defend() enthalten. Hierfuer muss <newskills.h>
+      includiert werden. Default ist ([SI_SPELL: ([SP_PHYSICAL_ATTACK:
+      0]), SI_MAGIC_TYPE: ({ MT_ANGRIFF }) ])
 
 
 BESCHREIBUNG
