diff --git a/doc/sphinx/lfun/Defend.rst b/doc/sphinx/lfun/Defend.rst
index f0d80cf..70dc9d2 100644
--- a/doc/sphinx/lfun/Defend.rst
+++ b/doc/sphinx/lfun/Defend.rst
@@ -4,8 +4,8 @@
 FUNKTION
 --------
 
-  public int Defend(int dam, string|string* dam_types, int|mapping si_spell, 
-    object enemy)
+  public int Defend(int dam, string|string* dam_types, 
+      int|mapping si_spell, object enemy)
 
 DEFINIERT IN
 ------------
@@ -42,11 +42,11 @@
     (dam-Summe(Ruestungsstaerken)-random(P_BODY+A_DEX))*CheckResistance/10
     aber nicht unter 0.
 
-Der Parameter 'spell'
-+++++++++++++++++++++
+Der Parameter 'si_spell'
+++++++++++++++++++++++++
 
-    Ist 'spell' 0, dann gilt der Angriff als normale physische Attacke
-    Uebergibt man als 'spell'-Parameter ein Mapping, so gibt es dafuer
+    Ist 'si_spell' 0, dann gilt der Angriff als normale physische Attacke
+    Uebergibt man als 'si_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.
 
@@ -70,7 +70,8 @@
         Name des Spells
     - SP_GLOBAL_ATTACK (int)
         1 bei Flaechenspells (die mehrere Ziele treffen koennen)
-    - SP_REDUCE_ARMOUR (mapping) ------------ Mapping: keys AT_X/P_BODY, values int>=0
+    - SP_REDUCE_ARMOUR (mapping) ------------ 
+        Mapping: keys AT_X/P_BODY, values int>=0
         Die Schutzwirkung durch P_AC/Magie einer Ruestung wird typabhaengig
         reduziert. Als Keys sind P_BODY und die AT_* erlaubt, die Werte
         muessen ints > 0 sein.
@@ -157,37 +158,31 @@
   enem->Defend(100, ({DT_BLUDGEON}), ([SP_PHYSICAL_ATTACK:1]), this_object());
 
   // ein magischer Angriff (ohne Treffermeldung):
-  enem->Defend(100, ({DT_BLUDGEON, DT_FIRE}), ([SP_PHYSICAL_ATTACK:0]), this_object());
+  enem->Defend(100, ({DT_BLUDGEON, DT_FIRE}), ([SP_PHYSICAL_ATTACK:0]), 
+               this_object());
 
   // ein magischer Angriff mit Treffermeldung:
   enem->Defend(100, ({DT_BLUDGEON, DT_FIRE}), ([SP_SHOW_DAMAGE:1]),
-    this_object());
+               this_object());
 
 SIEHE AUCH
 ----------
 
-  Angriff: :doc:`Attack`, :doc:`../props/P_NO_ATTACK`, :doc:`InsertEnemy`
+  Angriff:
+    :doc:`Attack`, :doc:`../props/P_NO_ATTACK`, :doc:`InsertEnemy`
 
-  Schaden:   :doc:`../props/P_ENABLE_IN_ATTACK_OUT`, 
-  :doc:`../props/P_LAST_MOVE`, :doc:`do_damage`,
-  :doc:`reduce_hit_points`
+  Schaden:
+    :doc:`../props/P_ENABLE_IN_ATTACK_OUT`, :doc:`../props/P_LAST_MOVE`, :doc:`do_damage`, :doc:`reduce_hit_points`
 
-  Schutz:    :doc:`../props/P_DEFENDERS`, :doc:`InformDefend`,
-  :doc:`DefendOther`, :doc:`../props/P_ARMOURS`,
-  :doc:`../props/P_AC`, :doc:`../props/P_DEFEND_FUNC`,
-  :doc:`QueryDefend`, :doc:`../props/P_BODY`
+  Schutz:
+    :doc:`../props/P_DEFENDERS`, :doc:`InformDefend`, :doc:`DefendOther`, :doc:`../props/P_ARMOURS`, :doc:`../props/P_AC`, :doc:`../props/P_DEFEND_FUNC`, :doc:`QueryDefend`, :doc:`../props/P_BODY`
 
-  Daten:     :doc:`../props/P_LAST_COMBAT_TIME`,
-  :doc:`../props/P_LAST_DAMTYPES`,
-  :doc:`../props/P_LAST_DAMTIME`, :doc:`../props/P_LAST_DAMAGE`,
-  :doc:`../props/P_DAMAGE_MSG`
+  Daten:
+    :doc:`../props/P_LAST_COMBAT_TIME`, :doc:`../props/P_LAST_DAMTYPES`, :doc:`../props/P_LAST_DAMTIME`, :doc:`../props/P_LAST_DAMAGE`, :doc:`../props/P_DAMAGE_MSG`
+  Resistenz:
+    :doc:`../props/P_RESISTANCE_STRENGTHS`, :doc:`CheckResistance`
 
-  Resistenz: :doc:`../props/P_RESISTANCE_STRENGTHS`,
-  :doc:`CheckResistance`
-
-  Sonstiges: :doc:`CheckSensitiveAttack`,
-  :doc:`InternalModifyDefend`, :doc:`normalize_defend_args`
-  :doc:`UseSkill`,
-  :doc:`DefendInfo`
+  Sonstiges:
+    :doc:`CheckSensitiveAttack`, :doc:`InternalModifyDefend`, :doc:`normalize_defend_args`, :doc:`UseSkill`, :doc:`DefendInfo`
 
 Letzte Aenderung: 20.01.2019, Zesstra
diff --git a/doc/sphinx/lfun/DefendOther.rst b/doc/sphinx/lfun/DefendOther.rst
index e18c9c7..363ff24 100644
--- a/doc/sphinx/lfun/DefendOther.rst
+++ b/doc/sphinx/lfun/DefendOther.rst
@@ -5,37 +5,41 @@
 --------
 ::
 
-  public <int|string*|mapping>* DefendOther(int dam, string|string* dam_type,
-                                            int|mapping spell, object enemy)
+    public <int|string*|mapping>* DefendOther(int dam, string* dam_type,
+                                        int|mapping si_spell, object enemy)
 
 DEFINIERT IN
 ------------
 ::
 
-	/std/living/combat.c
+    /std/living/combat.c
 
 ARGUMENTE
 ---------
 ::
 
-	dam
-	  Der Schaden, der voraussichtlich beim zu verteidigenden Lebewesen
-	  verursacht werden soll.
-	dam_type
-	  Der Schadenstyp (oder die Schadenstypen), der beim zu
-	  verteidigenden Lebewesen verursacht werden sollen.
-	spell
-	  Wenn das zu verteidigende Lebewesen mit Spells angegriffen wurde,
-	  so koennte man hier mehr Infos entnehmen.
-	enemy
-	  Der Feind, der ein zu verteidigendes Lebewesen angegriffen hat.
+    int dam
+      Der Schaden, der voraussichtlich beim zu verteidigenden Lebewesen
+      verursacht werden soll.
+
+    string* dam_type
+      Der Schadenstyp (oder die Schadenstypen), der beim zu
+      verteidigenden Lebewesen verursacht werden sollen.
+
+    mapping si_spell
+      Mapping mit zusaetzlichen Informationen zum Angriff
+      Alte Objekte uebergeben manchmal einen Integer (0 fuer
+      physikalischen Angriff, 1 fuer Zauber.
+
+    object enemy
+      Der Feind, der ein zu verteidigendes Lebewesen angegriffen hat.
 
 RUeCKGABEWERT
 -------------
 ::
 
-	Array mit den Eintraegen der gegebenenfalls veraenderten
-	uebergebenen Parameter: 
+    Array mit den Eintraegen der gegebenenfalls veraenderten
+    uebergebenen Parameter: 
             (1) dam      [Typ int], 
             (2) dam_type [Typ string*], 
             (3) spell    [Typ mapping].
@@ -44,66 +48,78 @@
 ------------
 ::
 
-	Es ist moeglich, dass Objekte Angriffe auf Lebewesen abwehren oder
-	umwandeln, sofern diese Objekte bei dem angegriffenen Lebewesen
-	mittels AddDefender() angemeldet wurden und sich der selben Umgebung
-	befinden.
-	Zumeist wird es sich bei den Objekten natuerlich ebenfalls um
-	andere Lebewesen handeln, die das Lebewesen, bei dem sie angemeldet
-	sind, verteidigen sollen.
-	Bei einem Angriff auf das Lebewesen koennen alle Objekte per Aufruf
-	von DefendOther() in einen Angriff eingreifen, wobei die
-	Schadensstaerke, der Schadenstyp (die Schadenstypen),
-	Zusatzinformationen fuer Angriffsspells und der Angreifer als
-	Parameter uebergeben werden.
-	Desweiteren ist zu beachten, dass bei als physikalisch markierten
-	Angriffen in einem Team nur Verteidiger aus der ersten Reihe
-	beruecksichtigt werden und dass bei einem Angriff zufaellig aus
-	allen moeglichen Verteidigern ausgewaehlt wird.
-	Standardmaessig ist diese Funktion in Lebewesen bereits definiert,
-	wobei der Skill SK_DEFEND_OTHER, sofern vorhanden, aufgerufen wird.
+    Es ist moeglich, dass Objekte Angriffe auf Lebewesen abwehren oder
+    umwandeln, sofern diese Objekte bei dem angegriffenen Lebewesen
+    mittels AddDefender() angemeldet wurden und sich der selben Umgebung
+    befinden.
+    Zumeist wird es sich bei den Objekten natuerlich ebenfalls um
+    andere Lebewesen handeln, die das Lebewesen, bei dem sie angemeldet
+    sind, verteidigen sollen.
+    
+    Bei einem Angriff auf das Lebewesen koennen alle Objekte per Aufruf
+    von DefendOther() in einen Angriff eingreifen, wobei die
+    Schadensstaerke, der Schadenstyp (die Schadenstypen),
+    Zusatzinformationen fuer Angriffsspells und der Angreifer als
+    Parameter uebergeben werden.
+
+    Des weiteren ist zu beachten, dass bei als physikalisch markierten
+    Angriffen in einem Team nur Verteidiger aus der ersten Reihe
+    beruecksichtigt werden und dass bei einem Angriff zufaellig aus
+    allen moeglichen Verteidigern ausgewaehlt wird.
+    
+    Standardmaessig ist diese Funktion in Lebewesen bereits definiert,
+    wobei der Skill SK_DEFEND_OTHER, sofern vorhanden, aufgerufen wird.
 
 BEISPIEL
 --------
 ::
 
-	Sehr beliebt sind in Gilden NPCs, die den Beschwoerer begleiten und
-	verteidigen, z.B. beschworene Daemonen:
-	  inherit "std/npc";
-	  include <properties.h>
-	  object owner;
-	  void create()
-	  { ::create();
-	    SetProp(P_NAME,"Daemon");
-	    ...
-	  }
-	// nach Clonen des Daemons folgende Funktion mit Beschwoerer als
-	// Parameter aufrufen
-	  Identify(object caster)
-	  { if(!objectp(caster))
-	      call_out(#'remove,0);
-	    owner=caster;
-	    owner->AddDefender(this_object());
-	  }
-	// der Daemon wehrt jeden Angriff mit Feuer voll ab, man muss zuerst
-	// den Verteidiger umbringen, um den Beschwoerer toeten zu koennen
-	  mixed DefendOther(int dam,mixed dam_type,mixed spell,object enemy)
-	  { if(sizeof(dam_type)&&member_array(DT_FIRE,dam_type)!=-1)
-	      dam=0;
-	    return({dam,dam_type,spell});
-	  }
-	Soll der Daemon sich auch in ein Team einordnen, in welchem sich der
-	Beschwoerer eventuell befindet, so ist zusaetzlich AssocMember() in
-	diesem Beschwoerer aufzurufen, wobei der Daemon als Parameter
-	uebergeben wird.
+    Sehr beliebt sind in Gilden NPCs, die den Beschwoerer begleiten und
+    verteidigen, z.B. beschworene Daemonen:
+    
+    inherit "/std/npc";
+    
+    include <properties.h>
+    
+    object owner;
+    
+    void create() {
+      ::create();
+      SetProp(P_NAME,"Daemon");
+      ...
+    }
+    
+    // nach Clonen des Daemons folgende Funktion mit Beschwoerer als
+    // Parameter aufrufen
+    void Identify(object caster) {
+      if (!objectp(caster))
+        call_out(#'remove,0);
+      owner = caster;
+      owner->AddDefender(this_object());
+    }
+    
+    // der Daemon wehrt jeden Angriff mit Feuer voll ab, man muss zuerst
+    // den Verteidiger umbringen, um den Beschwoerer toeten zu koennen
+    public <int|string*|mapping>* DefendOther(int dam, 
+        string|string* dt, int|mapping spell, object enemy) {
+      if (sizeof(dt) && member(dt, DT_FIRE) != -1)
+        dam = 0;
+      return ({dam, dam_type, spell});
+    }
+    
+    Soll der Daemon sich auch in ein Team einordnen, in welchem sich der
+    Beschwoerer eventuell befindet, so ist zusaetzlich AssocMember() in
+    diesem Beschwoerer aufzurufen, wobei der Daemon als Parameter
+    uebergeben wird.
 
 SIEHE AUCH
 ----------
-::
 
-	AddDefender(), RemoveDefender(), InformDefend(), Kill(), IsEnemy(),
-	P_DEFENDERS, /std/living/combat.c, /sys/new_skills.h
+  Funktionen:
+    :doc:`../lfun/AddDefender`, :doc:`../lfun/RemoveDefender`, :doc:`../lfun/InformDefend`, :doc:`../lfun/Kill`, :doc:`../lfun/IsEnemy`, :doc:`../lfun/Defend`
+  Properties
+    :doc:`../props/P_DEFENDERS`
+  Objekte:
+    /std/living/combat.c, /sys/new_skills.h
 
-
-Last modified: Fri Feb 25 14:45:00 2000 by Paracelsus
-
+Last modified: 2019-Aug-26, Arathorn