diff --git a/doc/lfun/AddCmd_bsp b/doc/lfun/AddCmd_bsp
index ec8ff17..4f382c8 100644
--- a/doc/lfun/AddCmd_bsp
+++ b/doc/lfun/AddCmd_bsp
@@ -1,10 +1,6 @@
 
-AddCmd_bsp()
-************
-
-
 ADDCMD() - BEISPIELE
-====================
+********************
 
 
 FUNKTION
@@ -25,48 +21,61 @@
 BEISPIELE
 =========
 
-   // SIMPEL: ganz simpel, beinahe wie add_action
+
+Einfache Beispiele
+------------------
+
+1. SIMPEL: ganz simpel, beinahe wie add_action()
+
    AddCmd("befiehl","action_befehlen");
-   ...
+   // ...
    int action_befehlen(string str) {
-    if(!str || !strlen(str))
-     // Fehlermeldung, falls gar keine Funktion 1 dafuer zurueckgibt
-     notify_fail("Was willst du befehlen?!\n");
-    else {
-     write("Du befiehlst \""+str+"\", und alle folgen!\n");
-     say(TP->Name(WER)+" befiehlt \""+str+"\", und du folgst!\n");
-     return 1;         // ERFOLG - Abbruch der Kommandoauswertung
-    }
-    return 0;          // MISSERFOLG - Fehlermeldung oben gesetzt
+     if(!str || !strlen(str))
+       // Fehlermeldung, falls gar keine Funktion 1 dafuer zurueckgibt
+       notify_fail("Was willst du befehlen?!\n");
+     else {
+       write("Du befiehlst \""+str+"\", und alle folgen!\n");
+       say(TP->Name(WER)+" befiehlt \""+str+"\", und du folgst!\n");
+       return 1;  // ERFOLG - Abbruch der Kommandoauswertung
+     }
+     return 0;    // MISSERFOLG - Fehlermeldung oben gesetzt
    }
 
-   // SIMPEL .. weitere Beispiele
+2. SIMPEL .. weitere Beispiele
+
    AddCmd(({"kletter","klettere"}),"action_klettern" );
    AddCmd(({"renn","renne"}),#'action_rennen);
 
-   // REGELN: eine komplexere Regel
+3. REGELN: eine komplexere Regel
+
    AddCmd("loesch|loesche|ersticke&feuer|brand|flammen&decke|wolldecke",
           "action_loeschen",
           "Was willst du loeschen?|Womit willst du loeschen?");
 
-   // REGELN: mit Platzhaltern im Fehlerstring
+4. REGELN: mit Platzhaltern im Fehlerstring
+
    AddCmd("spring|springe|huepf|huepfe&von|vom&baum|ast|eiche",
           #'action_huepfe,
           "Willst du von etwas @verben?|Von wo willst du @verben?");
 
-   // SCHLECHT: eine unscharfe Regel - sie sollten eine Ausnahme sein (!)
+5. SCHLECHT: eine unscharfe Regel - sie sollten eine Ausnahme sein
+   (!)
+
    AddCmd("kletter","fun_klettern",1);
 
-   // FALSCH: sehr schlecht, kein Imperativ verwendet
-   // ausserdem sollte man fuer solche Syntaxen AddReadDetail benutzen
+6. FALSCH: sehr schlecht, kein Imperativ verwendet
+
    AddCmd("lese","eval_lesen");
 
-   // SIMPLE REGEL
+   ausserdem sollte man fuer Lese-Syntaxen AddReadDetail benutzen
+
+7. SIMPLE REGEL
+
    static int action_jump(string str);        // Prototype (wegen closure)
-   ...
+   // ...
    AddCmd("spring|springe|huepf|huepfe&von&baum|ast",#'action_jump,
           "Willst Du von etwas @verben?|Wovon willst Du @verben?");
-   ...
+   // ...
    static int action_jump(string str) {
      write(break_string("Du springst vom Baum und kommst hart auf!",78));
      this_player()->move((XXXROOM+"boden"), M_GO, 0,
@@ -76,307 +85,314 @@
      return 1;
    }
 
-   // SIMPLE REGEL OHNE METHODE
-   // mit Regeln kann man auch Aktivitaeten im Raum erlauben, ohne eine
-   // Funktion aufrufen zu muessen: die letzte Regel ist fuer Spieler
-   // unmoeglich zu erfuellen, die dazugehoerige Fehlermeldung wird mit
-   // dem ^ (write-Flag) versehen und entsprechend an den Spieler
-   // (und den Raum (hinter dem ^)) ausgegeben
+8. SIMPLE REGEL OHNE METHODE
+
+   mit Regeln kann man auch Aktivitaeten im Raum erlauben, ohne eine
+   Funktion aufrufen zu muessen: die letzte Regel ist fuer Spieler
+   unmoeglich zu erfuellen, die dazugehoerige Fehlermeldung wird mit
+   dem ^ (write-Flag) versehen und entsprechend an den Spieler (und
+   den Raum (hinter dem ^)) ausgegeben
+
    AddCmd("spring|springe&herunter|runter&\n\bimpossible",0,
           "Wohin oder wovon willst Du springen?|"
           "Du springst vom Baum und kommst hart auf.^"
           "@WER1 springt vom Baum und kommt hart auf.");
 
-## Komplexbeispiel: Regeln mit Fehlermeldungen ##
-   ## Variante 1, OHNE REGELN ##
-      // bei Nichtverwendung von Regeln muss man Parameter selbst
-      auswerten AddCmd(({"bohr","bohre"}),#'action_bohren); ...
-      private int action_bohren(string str) {
 
-         string >>*<<tmp; notify_fail("Wo willst (etwas) Du
-         bohren?n"); if(!str) return 0;       // Tja, keine Argumente
-         ... tmp=explode(str," ");    // nach " " in Argument-Array
-         aufspalten if((i=member(tmp,"loch"))>=0) { // aha, ab jetzt
-         uebernehmen wir :)
+Komplexbeispiel: Regeln mit Fehlermeldungen
+-------------------------------------------
 
-            if((j=member(tmp[(i+1)..],"in"))<0 &&
-                     (j=member(tmp[(i+1)..],"durch"))<0)
 
-                  write("Willst Du das Loch in etwas bohren?n");
+Variante 1a, OHNE REGELN
+~~~~~~~~~~~~~~~~~~~~~~~~
 
-               else if((i=member(tmp[(j+1)..],"boden"))<0 &&
-                     (i=member(tmp[(j+1)..],"erde"))<0)
+   Wenn man keine Regeln verwendet, muss man die Eingabe selbst
+   auswerten.
 
-                  write("In/Durch was willst du das Loch bohren?n");
-
-               else {
-                  write("Du bohrst ein Loch in den Boden.n");
-                  say(this_player()->Name(WER)+" bohrt ein Loch in den
-                  Boden.n");
-
-               } return 1;      // "bohre loch" war so eindeutig, dass
-               nur diese
-
+   AddCmd(({"bohr","bohre"}),#'action_bohren);
+   // ...
+   private int action_bohren(string str) {
+     string *tmp;
+     notify_fail("Wo willst (etwas) Du bohren?\n");
+     if(!str) return 0;       // Tja, keine Argumente ...
+     tmp=explode(str," ");    // nach " " in Argument-Array aufspalten
+     if((i=member(tmp,"loch"))>=0) { // aha, ab jetzt uebernehmen wir :)
+       if((j=member(tmp[(i+1)..],"in"))<0 &&
+          (j=member(tmp[(i+1)..],"durch"))<0)
+         write("Willst Du das Loch in etwas bohren?\n");
+       else if((i=member(tmp[(j+1)..],"boden"))<0 &&
+               (i=member(tmp[(j+1)..],"erde"))<0)
+         write("In/Durch was willst du das Loch bohren?\n");
+       else {
+         write("Du bohrst ein Loch in den Boden.\n");
+         say(this_player()->Name(WER)+" bohrt ein Loch in den Boden.\n");
+       }
+       return 1;  // "bohre loch" war so eindeutig, dass nur diese
                   // Methode gemeint sein konnte, also brechen wir die
                   // weitere Auswertung auf jeden Fall ab (und geben
                   // eine write-Fehlermeldung)
+     } // end if(..."loch")
+     return 0;    // "bohre" allein muss nicht diese Methode meinen,
+                  // also nur obige notify_fail()-Meldung, falls
+                  // sich nach dieser Methode gar keine sonst
+                  // angesprochen fuehlt
+   } // end fun
 
-         } // end if(..."loch") return 0;        // "bohre" allein
-         muss nicht diese Methode meinen,
 
-            // also nur obige notify_fail()-Meldung, falls // sich
-            nach dieser Methode gar keine sonst // angesprochen fuehlt
+Variante 1b, OHNE REGELN, Alternative
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-      } // end fun
+   prinzipiell koennte die Methode action_bohren() auch so aussehen,
+   ist aber nicht ganz so flexibel:
 
-   ## Variante 1a, OHNE REGELN ##
-      // prinzipiell koennte die Methode action_bohren auch so //
-      aussehen, ist aber nicht ganz so flexibel: private int
-      action_bohren(string str) {
+   private int action_bohren(string str) {
+     string unused;
+     if(!str || (sprintf(str,"loch in erde%s", unused)!=1 &&
+                 sprintf(str,"loch durch erde%s", unused)!=1 &&
+                 sprintf(str,"loch in boden%s", unused)!=1 &&
+                 sprintf(str,"loch durch boden%s", unused)!=1))
+       notify_fail("Willst Du in irgendwas ein Loch bohren?\n");
+     else {
+       // ...
+       return 1;
+     }
+     return 0;
+   }
 
-         string tmp; if(!str || (sprintf(str,"loch in erde%s",tmp)!=1
-         &&
 
-               sprintf(str,"loch durch erde%s",tmp)!=1 &&
-               sprintf(str,"loch in boden%s",tmp)!=1 &&
-               sprintf(str,"loch durch boden%s",tmp)!=1))
+Variante 2, MIT REGEL
+~~~~~~~~~~~~~~~~~~~~~
 
-            notify_fail("Willst Du in irgendwas ein Loch bohren?n");
+   das gleiche in etwa mal als einfache Regel
 
-         else {
-            ... return 1;
+   AddCmd("bohr|bohre&loch&in|durch&erde|boden",#'action_bohren,
+          "Was willst du (wohin) bohren?|"
+          "Willst du das Loch in etwas bohren?|"
+          "Wohin willst du das Loch bohren?");
+   // ...
+   private int action_bohren(string str, mixed *param) {
+     write("Du bohrst ein Loch in den Boden.\n");
+     say(this_player()->Name(WER)+" bohrt ein Loch in den Boden.\n");
+     // ...
+     return 1;
+   }
 
-         } return 0;
 
-      }
+Variante 3, MIT REGEL UND FEHLERMELDUNG
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-   ## Variante 2, MIT REGEL ##
-      // das gleiche in etwa mal als einfache Regel
-      AddCmd("bohr|bohre&loch&in|durch&erde|boden",#'action_bohren,
+   und nun mit Fehlermeldungen mit Ersetzungen, so dass wir mehr auf
+   die Eingaben des Spielers eingehen
 
-         "Was willst du (wohin) bohren?|" "Willst du das Loch in etwas
-         bohren?|" "Wohin willst du das Loch bohren?");
+   AddCmd("bohr|bohre&loch&in|durch&erde|boden",#'action_bohren,
+          "Was willst du (wohin) @verben?|"
+          "Willst du das Loch in etwas @verben?|"
+          "@WER3 was willst du das Loch @verben?");
+   // ...
+   private int action_bohren(string str, mixed *param) // ...
 
-      ... private int action_bohren(string str, mixed >>*<<param) {
 
-         write("Du bohrst ein Loch in den Boden.n");
-         say(this_player()->Name(WER)+" bohrt ein Loch in den
-         Boden.n"); ... return 1;
+Variante 4, MIT REGEL, FEHLERMELDUNG UND RETURN 1
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-      }
+   In Variante 1 kam sinnvollerweise sehr frueh der Abbruch mit
+   "return 1;" und mit Ausgabe von write-Fehlermeldungen, das koennen
+   wir auch direkt und ohne eigene Methode.
 
-   ## Variante 3, MIT REGEL UND FEHLERMELDUNG ##
-      // und nun mit Fehlermeldungen mit Ersetzungen, so dass wir mehr
-      // auf die Eingaben des Spielers eingehen
-      AddCmd("bohr|bohre&loch&in|durch&erde|boden",#'action_bohren,
+   AddCmd("bohr|bohre&loch&in|durch&erde|boden",#'action_bohren,
+          "Was willst du (wohin) @verben?|"
+          "Willst du das Loch in etwas @verben?^|"
+          "@WER3 was willst du das Loch @verben?^");
+    // ...
+    private int action_bohren(string str, mixed *param) // ...
 
-         "Was willst du (wohin) @verben?|" "Willst du das Loch in
-         etwas @verben?|" "@WER3 was willst du das Loch @verben?");
 
-      ... private int action_bohren(string str, mixed >>*<<param) ...
+Variante 5, MIT REGEL, FEHLERMELDUNG, RETURN 1, OHNE FUN
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-   ## Variante 4, MIT REGEL, FEHLERMELDUNG UND RETURN 1 ##
-      // in Variante 1 kam sinnvollerweise sehr frueh der Abbruch mit
-      // "return 1;" und die Ausgabe von write-Fehlermeldungen, // das
-      koennen wir auch
-      AddCmd("bohr|bohre&loch&in|durch&erde|boden",#'action_bohren,
+   // und falls in action_bohren() nichts ausser Ausgaben passiert, koennen
+   // wir uns die auch ganz sparen indem wir eine nichterfuellbare Regel
+   // samt Fehlermeldung bauen
+   AddCmd("bohr|bohre&loch&in|durch&erde|boden&\nimpossible",0,
+          "Was willst du (wohin) @verben?|"
+          "Willst du das Loch in etwas @verben?^|"
+          "@WER3 was willst du das Loch @verben?^|"
+          "Du @verbst ein Loch @WER3 den Boden.^@WER1 @verbt "
+          "ein Loch @WER3 den Boden.");
 
-         "Was willst du (wohin) @verben?|" "Willst du das Loch in
-         etwas @verben?^|" "@WER3 was willst du das Loch @verben?^");
 
-      ... private int action_bohren(string str, mixed >>*<<param) ...
+Komplexbeispiel: Spezialregeln @PRESENT und @ID
+-----------------------------------------------
 
-   ## Variante 5, MIT REGEL, FEHLERMELDUNG, RETURN 1, OHNE FUN ##
-         // und falls in action_bohren() nichts ausser Ausgaben
-         passiert, koennen // wir uns die auch ganz sparen indem wir
-         eine nichterfuellbare Regel // samt Fehlermeldung bauen
-         AddCmd("bohr|bohre&loch&in|durch&erde|boden&nimpossible",0,
 
-            "Was willst du (wohin) @verben?|" "Willst du das Loch in
-            etwas @verben?^|" "@WER3 was willst du das Loch
-            @verben?^|" "Du @verbst ein Loch @WER3 den Boden.^@WER1
-            @verbt " "ein Loch @WER3 den Boden.");
+Variante 1, OHNE REGELN
+~~~~~~~~~~~~~~~~~~~~~~~
 
-      --- Ende Komplexbeispiel Regeln mit Fehlermeldungen ---
+   Oft agieren Kommandos auf Objekten im Raum, diese muessen dabei per
+   present() identifiziert werden: Beispiel ist ein Geldautomat
+   (Hinweis: dieses Beispiel dient der Illustration, die
+   Funktionalitaet an sich sollte man besser mit einem Container mit
+   PreventInsert() erzeugen.)
 
-## Komplexbeispiel: Spezialregeln @PRESENT und @ID ##
-   ## Variante 1, OHNE REGELN ##
-      // oft agieren Kommandos auf Objekten im Raum, diese muessen
-      dabei per // present() identifiziert werden: // Beispiel ist ein
-      Geldautomat (den man besser mit einem Container // mit
-      PreventInsert() basteln sollte)
-      AddCmd(({"stopf","stopfe"}),#'action_stopf); ... private int
-      action_stopf(string str) {
-
-         string tmp,tmp2; object o;
-
-         if(str && (sprintf("%s in automat%s",tmp,tmp2)==2 ||
-               sprintf("%s in geldautomat%s",tmp,tmp2)==2 ||
-               sprintf("%s in bankomat%s",tmp,tmp2)==2) {
-
-            o=present(tmp,this_player()); if(o) {
-
-               if(o->QueryProp(...)) {
-                  write(break_string(
-                     "Du stopfst "+o->name(WEN,1)+" in den
-                     Automaten.",78));
-
-                  say(...);
-
-               } else {
-                  write(break_string(
-                     "Du versuchst "+o->name(WEN,1)+" in den Automaten
-                     zu stopfen, " "aber "+o->QueryPronoun(WER)+"
-                     passt nicht hinein.",78));
-
-                  say(...);
-
-               }
-
-            } else {
-               write("Was willst du in den Automaten stopfen?n");
-               say(....);
-
-            } return 1;
-
-         } notify_fail("Was willst du wohin stecken?n"); return 0;
-
-      }
-
-   ## Variante 2, MIT REGEL ##
-         // einerseits koennen wir das Finden von Objekten in Inv und
-         Env // integrieren und uns andererseits das Aufzaehlen aller
-         IDs des // Automaten ersparen
-         AddCmd("steck|stecke&@PRESENT&in&@ID",#'action_stopf,
-
-            "Was willst du wohin stopfen?|" "Willst du @WEN2 in etwas
-            stopfen?|" "Wohinein willst du @WEN2 stopfen?");
-
-         ... // dabei werden wie immer die gefunden Matches als
-         Parameterarray // uebergeben ... und die @PRESENT und @ID als
-         Objekte! private int action_stopf(string str, mixed
-         >>*<<param) {
-
-            if(param[0]->QueryProp(...)) {
-               write(break_string(
-                  "Du stopfst "+param[0]->name(WEN,1)+" in den
-                  Automaten.",78));
-
-               say(...);
-
-            } else {
-               write(break_string(
-                  "Du versuchst "+param[0]->name(WEN,1)+" in den
-                  Automaten zu " "stopfen, aber
-                  "+param[0]->QueryPronoun(WER)+" passt nicht "
-                  "hinein.",78));
-
-               say(...);
-
-            } return 1;
-
+   AddCmd(({"stopf","stopfe"}),#'action_stopf);
+   // ...
+   private int action_stopf(string str) {
+     string was, unused;
+     if(str && (sprintf("%s in automat%s", was, unused)==2 ||
+                sprintf("%s in geldautomat%s", was, unused)==2 ||
+                sprintf("%s in bankomat%s", was, unused)==2) {
+       object o = present(was, this_player());
+       if(o) {
+         if(o->QueryProp(...)) {
+           write(break_string(
+             "Du stopfst "+o->name(WEN,1)+" in den Automaten.",78));
+           say(...);
+         } else {
+           write(break_string(
+             "Du versuchst "+o->name(WEN,1)+" in den Automaten zu stopfen, "
+             "aber "+o->QueryPronoun(WER)+" passt nicht hinein.",78));
+           say(...);
          }
+       } else {
+         write("Was willst du in den Automaten stopfen?\n");
+         say(....);
+       }
+       return 1;
+     }
+     notify_fail("Was willst du wohin stecken?\n");
+     return 0;
+   }
 
-      --- Ende Komplexbeispiel Spezialregeln @PRESENT und @ID  ---
 
-## Komplexbeispiel: gleiches Verb, mehrere Regeln ##
-   // Das Problem mehrerer Regeln fuer ein Kommandoverb besteht darin,
-   dass // letztlich nur eine der Fehlermeldungen zum Tragen kommt -
-   welche // genau ist etwas vage. // Dabei kann man sich auf eines
-   verlassen: juengere AddCmd werden // zuerst ausgewertet. Wenn sich
-   das aendert, tretet euren EM.
+Variante 2, MIT REGEL
+~~~~~~~~~~~~~~~~~~~~~
 
-   ## Problem 1: Mehrere Regeln weil mehrere Zwecke ##
-      ## Variante 1 - GLEICHLAUTENDE FEHLERMELDUNG // fuer alles wird
-      eine identische Fehlermeldung gesetzt, das ist // natuerlich
-      nicht sehr flexibel oder schoen AddCmd("kriech|krieche&hoch|hin
-      auf|hinaus|heraus|raus",#'result_kriech,
+   einerseits koennen wir auf diese Weise das Finden von Objekten in
+   Inv und Env in die AddCmd()-Regel integrieren und uns andererseits
+   das Aufzaehlen aller IDs des Automaten ersparen.
 
-         "Wohin willst Du kriechen?");
+   Wie immer werden die gefundenen Matches als Parameterarray an die
+   angegebene Methode uebergeben. Das Array enthaelt die mit @PRESENT
+   und @ID gefundenen Treffer praktischerweise als Objekte.
 
-      AddCmd("kriech|krieche&nach&oben",#'result_kriech,
-         "Wohin willst Du kriechen??|Wohin willst Du kriechen?");
+   AddCmd("steck|stecke&@PRESENT&in&@ID",#'action_stopf,
+          "Was willst du wohin stopfen?|"
+          "Willst du @WEN2 in etwas stopfen?|"
+          "Wohinein willst du @WEN2 stopfen?");
+   // ...
+   private int action_stopf(string str, mixed *param) {
+     if(param[0]->QueryProp(...)) {
+       write(break_string(
+         "Du stopfst "+param[0]->name(WEN,1)+" in den Automaten.",78));
+       say(...);
+     } else {
+       write(break_string(
+         "Du versuchst "+param[0]->name(WEN,1)+" in den Automaten zu "
+         "stopfen, aber "+param[0]->QueryPronoun(WER)+" passt nicht "
+         "hinein.",78));
+       say(...);
+     }
+     return 1;
+   }
 
-      AddCmd("kriech|krieche&aus&loch|grube|falle",#'result_kriech);
-         "Wohin willst Du kriechen?|Wohin willst Du kriechen?");
 
-      // oder man versucht eine bessere Regel zu schaffen, was hier
-      durch // die Moeglichkeit von zwei oder drei Parameter
-      unmoeglich ist
+Komplexbeispiel: gleiches Verb, mehrere Regeln
+----------------------------------------------
 
-      ## Variante 2 - EIGENE AUSWERTUNG // es bietet sich also eigene
-      Weiterauswertung an, was durch die // Uebergabe der getriggerten
-      Verben erleichtert wird:
-      AddCmd("kriech|krieche&hoch|hinauf|hinaus|heraus|raus|aus|nach",
+   Das Problem mehrerer Regeln fuer ein Kommandoverb besteht darin,
+   dass letztlich nur eine der Fehlermeldungen zum Tragen kommt -
+   welche genau, ist etwas vage. Dabei kann man sich auf eines
+   verlassen: juengere AddCmd werden zuerst ausgewertet. Wenn sich das
+   aendert, tretet euren EM.
 
-         #'result_kriech, "Wohin willst Du kriechen?");
 
-      ... static int result_kriech(string str, mixed >>*<<extra) {
+Problem 1: Mehrere Regeln weil mehrere Zwecke
+---------------------------------------------
 
-         if(member(extra,"aus")>=0 &&
-               !sizeof(({str}),"*.\<(hoehle|grube|falle)\>.*"))
 
-            notify_fail("Woraus willst Du kriechen?n");
+Variante 1 - GLEICHLAUTENDE FEHLERMELDUNG
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-         else if(member(extra,"nach")>=0 && strstr(str,"oben")<0)
-            notify_fail("In welche Richtung willst Du kriechen?n");
+   Fuer alles wird eine identische Fehlermeldung gesetzt, das ist
+   natuerlich nicht sehr flexibel oder schoen oder man versucht eine
+   bessere Regel zu schaffen, was hier durch die Moeglichkeit von zwei
+   oder drei Parameter unmoeglich ist
 
-         else if(this_player()->QueryAttribute(A_DEX)>10 ||
-               member(holding_root,this_player())) {
+   AddCmd("kriech|krieche&hoch|hinauf|hinaus|heraus|raus",#'result_kriech,
+          "Wohin willst Du kriechen?");
+   AddCmd("kriech|krieche&nach&oben",#'result_kriech,
+          "Wohin willst Du kriechen??|Wohin willst Du kriechen?");
+   AddCmd("kriech|krieche&aus&loch|grube|falle",#'result_kriech);
+          "Wohin willst Du kriechen?|Wohin willst Du kriechen?");
 
-            write("Du kriechst mit Muehe heraus.n");
-            this_player()->move((XXXROOM+"draussen"), M_GO, 0,
 
-               "kriecht mit Muehe aus der Grube", "kriecht aus einer
-               Grube");
+Variante 2 - EIGENE AUSWERTUNG
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-            return 1;
+   Statt der Verwendung mehrerer aehnlicher AddCmd() bietet sich die
+   eigene Weiterauswertung an, was durch die Uebergabe der
+   getriggerten Argumente erleichtert wird.
 
-         } else
-            write("Du bist zu ungeschickt, halt Dich irgendwo
-            fest.n"); return 1;
+   AddCmd("kriech|krieche&hoch|hinauf|hinaus|heraus|raus|aus|nach",
+          #'result_kriech,
+          "Wohin willst Du kriechen?");
+   // ...
+   private int result_kriech(string str, mixed *extra) {
+     if(member(extra,"aus")>=0 &&
+        !sizeof(({str}),"*.\\<(hoehle|grube|falle)\\>.*"))
+       notify_fail("Woraus willst Du kriechen?\n");
+     else if(member(extra,"nach")>=0 && strstr(str,"oben")<0)
+       notify_fail("In welche Richtung willst Du kriechen?\n");
+     else if(this_player()->QueryAttribute(A_DEX)>10 ||
+             member(holding_root,this_player())) {
+       write("Du kriechst mit Muehe heraus.\n");
+       this_player()->move((XXXROOM+"draussen"), M_GO, 0,
+                           "kriecht mit Muehe aus der Grube",
+                           "kriecht aus einer Grube");
+       return 1;
+     } else
+       write("Du bist zu ungeschickt, halt Dich irgendwo fest.\n");
+       return 1;
+     }
+     return 0;
+   }
 
-         } return 0;
 
-      } // (ob sich der Aufwand fuer diese Beispielsyntax lohnt ist
-      fraglich)
+Problem 2: mehrere Regeln aufgrund von optionalen Parametern
+------------------------------------------------------------
 
-   ## Problem 2: mehrere Regeln, weil optionale Parameter ##
-      // Manchmal will man optionale Parameter erlauben, die aber eine
-      // Wirkung zeigen sollen:
-      AddCmd("schlag|schlage&@ID&hart",#'action_schlag_hart,
+   Manchmal will man optionale Parameter erlauben, die aber eine
+   Wirkung zeigen sollen. Hierbei ist die Reihenfolge der AddCmd()-
+   Anweisungen und ggf. deren Aufbau entscheidend.
 
-         "Was oder wen willst du @verben?|" "Wie willst du @WEN2
-         schlagen?");
+   AddCmd("schlag|schlage&@ID&hart",#'action_schlag_hart,
+          "Was oder wen willst du @verben?|"
+          "Wie willst du @WEN2 schlagen?");
+   AddCmd("schlag|schlage&@ID",#'action_schlag,
+          "Was oder wen willst du @verben?");
 
-      AddCmd("schlag|schlage&@ID",#'action_schlag,
-         "Was oder wen willst du @verben?");
+   Da juengere AddCmd aelteren vorgehen, wird die komplexere Regel samt
+   ihrer Fehlermeldung nie ausgewertet, da ein "schlag ball hart" auch
+   die zweite Regel triggert.
 
-      // Da juengere AddCmd aelteren vorgehen, wird die komplexere
-      Regel samt // ihrer Fehlermeldung nie ausgewertet, da ein
-      "schlag ball hart" auch // die zweite Regel triggert.
+   Anders herum:
 
-      // anders herum: AddCmd("schlag|schlage&@ID",#'action_schlag,
+   AddCmd("schlag|schlage&@ID",#'action_schlag,
+          "Was oder wen willst du @verben?");
+   AddCmd("schlag|schlage&@ID&hart",#'action_schlag_hart,
+          "Was oder wen willst du @verben?|"
+          "Wie willst du @WEN2 schlagen?");
 
-         "Was oder wen willst du @verben?");
+   Jetzt wird die komplexere Regel zuerst ueberprueft und triggert
+   auch die richtige Funktion.
+   Leider kommt die Fehlermeldung nie zum Tragen, denn was durch Regel 2
+   durchfaellt, triggert entweder Regel 1 oder faellt auch durch Regel 1
+   durch und ueberschreibt dabei die Meldung.
 
-      AddCmd("schlag|schlage&@ID&hart",#'action_schlag_hart,
-         "Was oder wen willst du @verben?|" "Wie willst du @WEN2
-         schlagen?");
+   AddCmd("schlag|schlage&@ID",#'action_schlag,
+          "Was oder wen willst du wie @verben?");
+   AddCmd("schlag|schlage&@ID&hart",#'action_schlag_hart);
 
-      // Jetzt wird die komplexere Regel zuerst ueberprueft und
-      triggert // auch die richtige Funktion. // Leider kommt die
-      Fehlermeldung nie zum Tragen, denn was durch Regel 2 //
-      durchfaellt, triggert entweder Regel 1 oder faellt auch durch
-      Regel 1 // durch und ueberschreibt dabei die Meldung.
+   Das ist zwar auch nur fast perfekt, besser wird es aber nicht.
 
-      AddCmd("schlag|schlage&@ID",#'action_schlag,
-         "Was oder wen willst du wie @verben?");
-
-      AddCmd("schlag|schlage&@ID&hart",#'action_schlag_hart);
-
-      // Fast perfekt. Besser wird es nicht.
-
-      --- Ende Komplexbeispiel mehrere Regeln ---
-
-Letzte Aenderung: 22.12.2016, Bugfix
+Letzte Aenderung: 20.11.2019, Arathorn
diff --git a/doc/sphinx/lfun/AddCmd_bsp.rst b/doc/sphinx/lfun/AddCmd_bsp.rst
index d0665d3..f3b848e 100644
--- a/doc/sphinx/lfun/AddCmd_bsp.rst
+++ b/doc/sphinx/lfun/AddCmd_bsp.rst
@@ -1,18 +1,14 @@
-AddCmd_bsp()
-============
-
 ADDCMD() - BEISPIELE
---------------------
-::
+********************
 
 FUNKTION
---------
+========
 ::
 
     varargs void AddCmd(mixed cmd, mixed func, mixed flag);
 
 BEMERKUNGEN
------------
+===========
 ::
 
     Die hier aufgefuehrten Komplexbeispiele sind zum Verstaendnis gedacht,
@@ -21,267 +17,351 @@
     Falls die einem zu komplex ist, hilft vielleicht die vorletzte.
 
 BEISPIELE
----------
-::
+=========
 
-    // SIMPEL: ganz simpel, beinahe wie add_action
-    AddCmd("befiehl","action_befehlen");
-    ...
-    int action_befehlen(string str) {
+Einfache Beispiele
+------------------
+
+1. SIMPEL: ganz simpel, beinahe wie add_action()
+
+.. code-block:: pike
+
+   AddCmd("befiehl","action_befehlen");
+   // ...
+   int action_befehlen(string str) {
      if(!str || !strlen(str))
-      // Fehlermeldung, falls gar keine Funktion 1 dafuer zurueckgibt
-      notify_fail("Was willst du befehlen?!\n");
+       // Fehlermeldung, falls gar keine Funktion 1 dafuer zurueckgibt
+       notify_fail("Was willst du befehlen?!\n");
      else {
-      write("Du befiehlst \""+str+"\", und alle folgen!\n");
-      say(TP->Name(WER)+" befiehlt \""+str+"\", und du folgst!\n");
-      return 1;		// ERFOLG - Abbruch der Kommandoauswertung
+       write("Du befiehlst \""+str+"\", und alle folgen!\n");
+       say(TP->Name(WER)+" befiehlt \""+str+"\", und du folgst!\n");
+       return 1;  // ERFOLG - Abbruch der Kommandoauswertung
      }
-     return 0;		// MISSERFOLG - Fehlermeldung oben gesetzt
-    }
+     return 0;    // MISSERFOLG - Fehlermeldung oben gesetzt
+   }
 
-    // SIMPEL .. weitere Beispiele
-    AddCmd(({"kletter","klettere"}),"action_klettern" );
-    AddCmd(({"renn","renne"}),#'action_rennen);
+2. SIMPEL .. weitere Beispiele
 
-    // REGELN: eine komplexere Regel
-    AddCmd("loesch|loesche|ersticke&feuer|brand|flammen&decke|wolldecke",
-           "action_loeschen",
-           "Was willst du loeschen?|Womit willst du loeschen?");
+.. code-block:: pike
 
-    // REGELN: mit Platzhaltern im Fehlerstring
-    AddCmd("spring|springe|huepf|huepfe&von|vom&baum|ast|eiche",
-           #'action_huepfe,
-           "Willst du von etwas @verben?|Von wo willst du @verben?");
+   AddCmd(({"kletter","klettere"}),"action_klettern" );
+   AddCmd(({"renn","renne"}),#'action_rennen);
 
-    // SCHLECHT: eine unscharfe Regel - sie sollten eine Ausnahme sein (!)
-    AddCmd("kletter","fun_klettern",1);
+3. REGELN: eine komplexere Regel
 
-    // FALSCH: sehr schlecht, kein Imperativ verwendet
-    // ausserdem sollte man fuer solche Syntaxen AddReadDetail benutzen
-    AddCmd("lese","eval_lesen");
+.. code-block:: pike
 
-    // SIMPLE REGEL
-    static int action_jump(string str);        // Prototype (wegen closure)
-    ...
-    AddCmd("spring|springe|huepf|huepfe&von&baum|ast",#'action_jump,
-           "Willst Du von etwas @verben?|Wovon willst Du @verben?");
-    ...
-    static int action_jump(string str) {
-      write(break_string("Du springst vom Baum und kommst hart auf!",78));
-      this_player()->move((XXXROOM+"boden"), M_GO, 0,
-                          "springt unelegant vom Baum","faellt vom Baum");
-      this_player()->Defend(random(100),({DT_BLUDGEON}),([SP_RECURSIVE:1]),
-                            this_object());
-      return 1;
-    }
+   AddCmd("loesch|loesche|ersticke&feuer|brand|flammen&decke|wolldecke",
+          "action_loeschen",
+          "Was willst du loeschen?|Womit willst du loeschen?");
 
-    // SIMPLE REGEL OHNE METHODE
-    // mit Regeln kann man auch Aktivitaeten im Raum erlauben, ohne eine
-    // Funktion aufrufen zu muessen: die letzte Regel ist fuer Spieler
-    // unmoeglich zu erfuellen, die dazugehoerige Fehlermeldung wird mit
-    // dem ^ (write-Flag) versehen und entsprechend an den Spieler
-    // (und den Raum (hinter dem ^)) ausgegeben
-    AddCmd("spring|springe&herunter|runter&\n\bimpossible",0,
-           "Wohin oder wovon willst Du springen?|"
-           "Du springst vom Baum und kommst hart auf.^"
-           "@WER1 springt vom Baum und kommt hart auf.");
+4. REGELN: mit Platzhaltern im Fehlerstring
 
-## Komplexbeispiel: Regeln mit Fehlermeldungen ##
- ## Variante 1, OHNE REGELN ##
-    // bei Nichtverwendung von Regeln muss man Parameter selbst auswerten
-    AddCmd(({"bohr","bohre"}),#'action_bohren);
-    ...
-    private int action_bohren(string str) {
-      string *tmp;
-      notify_fail("Wo willst (etwas) Du bohren?\n");
-      if(!str) return 0;       // Tja, keine Argumente ...
-      tmp=explode(str," ");    // nach " " in Argument-Array aufspalten
-      if((i=member(tmp,"loch"))>=0) { // aha, ab jetzt uebernehmen wir :)
+.. code-block:: pike
+
+   AddCmd("spring|springe|huepf|huepfe&von|vom&baum|ast|eiche",
+          #'action_huepfe,
+          "Willst du von etwas @verben?|Von wo willst du @verben?");
+
+5. SCHLECHT: eine unscharfe Regel - sie sollten eine Ausnahme sein (!)
+
+.. code-block:: pike
+
+   AddCmd("kletter","fun_klettern",1);
+
+6. FALSCH: sehr schlecht, kein Imperativ verwendet 
+
+.. code-block:: pike
+
+   AddCmd("lese","eval_lesen");
+
+   ausserdem sollte man fuer Lese-Syntaxen AddReadDetail benutzen
+
+7. SIMPLE REGEL
+
+.. code-block:: pike
+
+   static int action_jump(string str);        // Prototype (wegen closure)
+   // ...
+   AddCmd("spring|springe|huepf|huepfe&von&baum|ast",#'action_jump,
+          "Willst Du von etwas @verben?|Wovon willst Du @verben?");
+   // ...
+   static int action_jump(string str) {
+     write(break_string("Du springst vom Baum und kommst hart auf!",78));
+     this_player()->move((XXXROOM+"boden"), M_GO, 0,
+                         "springt unelegant vom Baum","faellt vom Baum");
+     this_player()->Defend(random(100),({DT_BLUDGEON}),([SP_RECURSIVE:1]),
+                           this_object());
+     return 1;
+   }
+
+8. SIMPLE REGEL OHNE METHODE
+
+   mit Regeln kann man auch Aktivitaeten im Raum erlauben, ohne eine
+   Funktion aufrufen zu muessen: die letzte Regel ist fuer Spieler
+   unmoeglich zu erfuellen, die dazugehoerige Fehlermeldung wird mit
+   dem ^ (write-Flag) versehen und entsprechend an den Spieler
+   (und den Raum (hinter dem ^)) ausgegeben
+
+.. code-block:: pike
+
+   AddCmd("spring|springe&herunter|runter&\n\bimpossible",0,
+          "Wohin oder wovon willst Du springen?|"
+          "Du springst vom Baum und kommst hart auf.^"
+          "@WER1 springt vom Baum und kommt hart auf.");
+
+
+Komplexbeispiel: Regeln mit Fehlermeldungen
+-------------------------------------------
+
+Variante 1a, OHNE REGELN
+^^^^^^^^^^^^^^^^^^^^^^^^
+    
+  Wenn man keine Regeln verwendet, muss man die Eingabe selbst auswerten.
+
+.. code-block:: pike
+
+   AddCmd(({"bohr","bohre"}),#'action_bohren);
+   // ...
+   private int action_bohren(string str) {
+     string *tmp;
+     notify_fail("Wo willst (etwas) Du bohren?\n");
+     if(!str) return 0;       // Tja, keine Argumente ...
+     tmp=explode(str," ");    // nach " " in Argument-Array aufspalten
+     if((i=member(tmp,"loch"))>=0) { // aha, ab jetzt uebernehmen wir :)
        if((j=member(tmp[(i+1)..],"in"))<0 &&
           (j=member(tmp[(i+1)..],"durch"))<0)
          write("Willst Du das Loch in etwas bohren?\n");
-        else if((i=member(tmp[(j+1)..],"boden"))<0 &&
-                (i=member(tmp[(j+1)..],"erde"))<0)
+       else if((i=member(tmp[(j+1)..],"boden"))<0 &&
+               (i=member(tmp[(j+1)..],"erde"))<0)
          write("In/Durch was willst du das Loch bohren?\n");
-        else {
+       else {
          write("Du bohrst ein Loch in den Boden.\n");
          say(this_player()->Name(WER)+" bohrt ein Loch in den Boden.\n");
-        }
-        return 1;      // "bohre loch" war so eindeutig, dass nur diese
-                       // Methode gemeint sein konnte, also brechen wir die
-                       // weitere Auswertung auf jeden Fall ab (und geben
-                       // eine write-Fehlermeldung)
-      } // end if(..."loch")
-      return 0;        // "bohre" allein muss nicht diese Methode meinen,
-                       // also nur obige notify_fail()-Meldung, falls
-                       // sich nach dieser Methode gar keine sonst
-                       // angesprochen fuehlt
-    } // end fun
-
- ## Variante 1a, OHNE REGELN ##
-    // prinzipiell koennte die Methode action_bohren auch so
-    // aussehen, ist aber nicht ganz so flexibel:
-    private int action_bohren(string str) {
-     string tmp;
-     if(!str || (sprintf(str,"loch in erde%s",tmp)!=1 &&
-                 sprintf(str,"loch durch erde%s",tmp)!=1 &&
-                 sprintf(str,"loch in boden%s",tmp)!=1 &&
-                 sprintf(str,"loch durch boden%s",tmp)!=1))
-      notify_fail("Willst Du in irgendwas ein Loch bohren?\n");
-     else {
-      ...
-      return 1;
-     }
-     return 0;
-    }
-
- ## Variante 2, MIT REGEL ##
-    // das gleiche in etwa mal als einfache Regel
-    AddCmd("bohr|bohre&loch&in|durch&erde|boden",#'action_bohren,
-           "Was willst du (wohin) bohren?|"
-           "Willst du das Loch in etwas bohren?|"
-           "Wohin willst du das Loch bohren?");
-    ...
-    private int action_bohren(string str, mixed *param) {
-     write("Du bohrst ein Loch in den Boden.\n");
-     say(this_player()->Name(WER)+" bohrt ein Loch in den Boden.\n");
-     ...
-     return 1;
-    }
-
- ## Variante 3, MIT REGEL UND FEHLERMELDUNG ##
-    // und nun mit Fehlermeldungen mit Ersetzungen, so dass wir mehr
-    // auf die Eingaben des Spielers eingehen
-    AddCmd("bohr|bohre&loch&in|durch&erde|boden",#'action_bohren,
-           "Was willst du (wohin) @verben?|"
-           "Willst du das Loch in etwas @verben?|"
-           "@WER3 was willst du das Loch @verben?");
-    ...
-    private int action_bohren(string str, mixed *param) ...
-
- ## Variante 4, MIT REGEL, FEHLERMELDUNG UND RETURN 1 ##
-    // in Variante 1 kam sinnvollerweise sehr frueh der Abbruch mit
-    // "return 1;" und die Ausgabe von write-Fehlermeldungen,
-    // das koennen wir auch
-    AddCmd("bohr|bohre&loch&in|durch&erde|boden",#'action_bohren,
-           "Was willst du (wohin) @verben?|"
-           "Willst du das Loch in etwas @verben?^|"
-           "@WER3 was willst du das Loch @verben?^");
-    ...
-    private int action_bohren(string str, mixed *param) ...
-
- ## Variante 5, MIT REGEL, FEHLERMELDUNG, RETURN 1, OHNE FUN ##
-    // und falls in action_bohren() nichts ausser Ausgaben passiert, koennen
-    // wir uns die auch ganz sparen indem wir eine nichterfuellbare Regel
-    // samt Fehlermeldung bauen
-    AddCmd("bohr|bohre&loch&in|durch&erde|boden&\nimpossible",0,
-           "Was willst du (wohin) @verben?|"
-           "Willst du das Loch in etwas @verben?^|"
-           "@WER3 was willst du das Loch @verben?^|"
-           "Du @verbst ein Loch @WER3 den Boden.^@WER1 @verbt "
-           "ein Loch @WER3 den Boden.");
-
-   --- Ende Komplexbeispiel Regeln mit Fehlermeldungen ---
-
-## Komplexbeispiel: Spezialregeln @PRESENT und @ID ##
- ## Variante 1, OHNE REGELN ##
-    // oft agieren Kommandos auf Objekten im Raum, diese muessen dabei per
-    // present() identifiziert werden:
-    // Beispiel ist ein Geldautomat (den man besser mit einem Container
-    // mit PreventInsert() basteln sollte)
-    AddCmd(({"stopf","stopfe"}),#'action_stopf);
-    ...
-    private int action_stopf(string str) {
-     string tmp,tmp2;
-     object o;
-
-     if(str && (sprintf("%s in automat%s",tmp,tmp2)==2 ||
-                sprintf("%s in geldautomat%s",tmp,tmp2)==2 ||
-                sprintf("%s in bankomat%s",tmp,tmp2)==2) {
-      o=present(tmp,this_player());
-      if(o) {
-       if(o->QueryProp(...)) {
-        write(break_string(
-         "Du stopfst "+o->name(WEN,1)+" in den Automaten.",78));
-        say(...);
-       } else {
-        write(break_string(
-         "Du versuchst "+o->name(WEN,1)+" in den Automaten zu stopfen, "
-         "aber "+o->QueryPronoun(WER)+" passt nicht hinein.",78));
-        say(...);
        }
-      } else {
-       write("Was willst du in den Automaten stopfen?\n");
-       say(....);
-      }
+       return 1;  // "bohre loch" war so eindeutig, dass nur diese
+                  // Methode gemeint sein konnte, also brechen wir die
+                  // weitere Auswertung auf jeden Fall ab (und geben
+                  // eine write-Fehlermeldung)
+     } // end if(..."loch")
+     return 0;    // "bohre" allein muss nicht diese Methode meinen,
+                  // also nur obige notify_fail()-Meldung, falls
+                  // sich nach dieser Methode gar keine sonst
+                  // angesprochen fuehlt
+   } // end fun
+
+Variante 1b, OHNE REGELN, Alternative
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+  prinzipiell koennte die Methode action_bohren() auch so
+  aussehen, ist aber nicht ganz so flexibel:
+
+.. code-block:: pike
+
+  private int action_bohren(string str) {
+    string unused;
+    if(!str || (sprintf(str,"loch in erde%s", unused)!=1 &&
+                sprintf(str,"loch durch erde%s", unused)!=1 &&
+                sprintf(str,"loch in boden%s", unused)!=1 &&
+                sprintf(str,"loch durch boden%s", unused)!=1))
+      notify_fail("Willst Du in irgendwas ein Loch bohren?\n");
+    else {
+      // ...
       return 1;
+    }
+    return 0;
+  }
+
+Variante 2, MIT REGEL
+^^^^^^^^^^^^^^^^^^^^^
+  
+  das gleiche in etwa mal als einfache Regel
+
+.. code-block:: pike
+
+  AddCmd("bohr|bohre&loch&in|durch&erde|boden",#'action_bohren,
+         "Was willst du (wohin) bohren?|"
+         "Willst du das Loch in etwas bohren?|"
+         "Wohin willst du das Loch bohren?");
+  // ...
+  private int action_bohren(string str, mixed *param) {
+    write("Du bohrst ein Loch in den Boden.\n");
+    say(this_player()->Name(WER)+" bohrt ein Loch in den Boden.\n");
+    // ...
+    return 1;
+  }
+
+Variante 3, MIT REGEL UND FEHLERMELDUNG
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   
+  und nun mit Fehlermeldungen mit Ersetzungen, so dass wir mehr
+  auf die Eingaben des Spielers eingehen
+
+.. code-block:: pike
+
+   AddCmd("bohr|bohre&loch&in|durch&erde|boden",#'action_bohren,
+          "Was willst du (wohin) @verben?|"
+          "Willst du das Loch in etwas @verben?|"
+          "@WER3 was willst du das Loch @verben?");
+   // ...
+   private int action_bohren(string str, mixed *param) // ...
+
+Variante 4, MIT REGEL, FEHLERMELDUNG UND RETURN 1
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+  In Variante 1 kam sinnvollerweise sehr frueh der Abbruch mit
+  "return 1;" und mit Ausgabe von write-Fehlermeldungen, das koennen
+  wir auch direkt und ohne eigene Methode.
+
+.. code-block:: pike
+
+  AddCmd("bohr|bohre&loch&in|durch&erde|boden",#'action_bohren,
+         "Was willst du (wohin) @verben?|"
+         "Willst du das Loch in etwas @verben?^|"
+         "@WER3 was willst du das Loch @verben?^");
+   // ...
+   private int action_bohren(string str, mixed *param) // ...
+
+Variante 5, MIT REGEL, FEHLERMELDUNG, RETURN 1, OHNE FUN
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. code-block:: pike
+
+  // und falls in action_bohren() nichts ausser Ausgaben passiert, koennen
+  // wir uns die auch ganz sparen indem wir eine nichterfuellbare Regel
+  // samt Fehlermeldung bauen
+  AddCmd("bohr|bohre&loch&in|durch&erde|boden&\nimpossible",0,
+         "Was willst du (wohin) @verben?|"
+         "Willst du das Loch in etwas @verben?^|"
+         "@WER3 was willst du das Loch @verben?^|"
+         "Du @verbst ein Loch @WER3 den Boden.^@WER1 @verbt "
+         "ein Loch @WER3 den Boden.");
+
+Komplexbeispiel: Spezialregeln @PRESENT und @ID
+-----------------------------------------------
+
+Variante 1, OHNE REGELN
+^^^^^^^^^^^^^^^^^^^^^^^
+
+  Oft agieren Kommandos auf Objekten im Raum, diese muessen dabei per
+  present() identifiziert werden:
+  Beispiel ist ein Geldautomat 
+  (Hinweis: dieses Beispiel dient der Illustration, die Funktionalitaet an
+  sich sollte man besser mit einem Container mit PreventInsert() erzeugen.)
+
+.. code-block:: pike
+
+   AddCmd(({"stopf","stopfe"}),#'action_stopf);
+   // ...
+   private int action_stopf(string str) {
+     string was, unused;
+     if(str && (sprintf("%s in automat%s", was, unused)==2 ||
+                sprintf("%s in geldautomat%s", was, unused)==2 ||
+                sprintf("%s in bankomat%s", was, unused)==2) {
+       object o = present(was, this_player());
+       if(o) {
+         if(o->QueryProp(...)) {
+           write(break_string(
+             "Du stopfst "+o->name(WEN,1)+" in den Automaten.",78));
+           say(...);
+         } else {
+           write(break_string(
+             "Du versuchst "+o->name(WEN,1)+" in den Automaten zu stopfen, "
+             "aber "+o->QueryPronoun(WER)+" passt nicht hinein.",78));
+           say(...);
+         }
+       } else {
+         write("Was willst du in den Automaten stopfen?\n");
+         say(....);
+       }
+       return 1;
      }
      notify_fail("Was willst du wohin stecken?\n");
      return 0;
-    }
+   }
 
- ## Variante 2, MIT REGEL ##
-    // einerseits koennen wir das Finden von Objekten in Inv und Env
-    // integrieren und uns andererseits das Aufzaehlen aller IDs des
-    // Automaten ersparen
-    AddCmd("steck|stecke&@PRESENT&in&@ID",#'action_stopf,
-           "Was willst du wohin stopfen?|"
-           "Willst du @WEN2 in etwas stopfen?|"
-           "Wohinein willst du @WEN2 stopfen?");
-    ...
-    // dabei werden wie immer die gefunden Matches als Parameterarray
-    // uebergeben ... und die @PRESENT und @ID als Objekte!
-    private int action_stopf(string str, mixed *param) {
-     if(param[0]->QueryProp(...)) {
+Variante 2, MIT REGEL
+^^^^^^^^^^^^^^^^^^^^^
+
+  einerseits koennen wir auf diese Weise das Finden von Objekten in Inv 
+  und Env in die AddCmd()-Regel integrieren und uns andererseits das 
+  Aufzaehlen aller IDs des Automaten ersparen.
+
+  Wie immer werden die gefundenen Matches als Parameterarray an die
+  angegebene Methode uebergeben. Das Array enthaelt die mit @PRESENT und 
+  @ID gefundenen Treffer praktischerweise als Objekte.
+
+.. code-block:: pike
+
+  AddCmd("steck|stecke&@PRESENT&in&@ID",#'action_stopf,
+         "Was willst du wohin stopfen?|"
+         "Willst du @WEN2 in etwas stopfen?|"
+         "Wohinein willst du @WEN2 stopfen?");
+  // ...
+  private int action_stopf(string str, mixed *param) {
+    if(param[0]->QueryProp(...)) {
       write(break_string(
-       "Du stopfst "+param[0]->name(WEN,1)+" in den Automaten.",78));
+        "Du stopfst "+param[0]->name(WEN,1)+" in den Automaten.",78));
       say(...);
-     } else {
+    } else {
       write(break_string(
-       "Du versuchst "+param[0]->name(WEN,1)+" in den Automaten zu "
-       "stopfen, aber "+param[0]->QueryPronoun(WER)+" passt nicht "
-       "hinein.",78));
+        "Du versuchst "+param[0]->name(WEN,1)+" in den Automaten zu "
+        "stopfen, aber "+param[0]->QueryPronoun(WER)+" passt nicht "
+        "hinein.",78));
       say(...);
-     }
-     return 1;
     }
+    return 1;
+  }
 
-   --- Ende Komplexbeispiel Spezialregeln @PRESENT und @ID  ---
+Komplexbeispiel: gleiches Verb, mehrere Regeln
+----------------------------------------------
 
-## Komplexbeispiel: gleiches Verb, mehrere Regeln ##
- // Das Problem mehrerer Regeln fuer ein Kommandoverb besteht darin, dass
- // letztlich nur eine der Fehlermeldungen zum Tragen kommt - welche
- // genau ist etwas vage.
- // Dabei kann man sich auf eines verlassen: juengere AddCmd werden
- // zuerst ausgewertet. Wenn sich das aendert, tretet euren EM.
+  Das Problem mehrerer Regeln fuer ein Kommandoverb besteht darin, dass
+  letztlich nur eine der Fehlermeldungen zum Tragen kommt - welche
+  genau, ist etwas vage.
+  Dabei kann man sich auf eines verlassen: juengere AddCmd werden
+  zuerst ausgewertet. Wenn sich das aendert, tretet euren EM.
 
- ## Problem 1: Mehrere Regeln weil mehrere Zwecke ##
-    ## Variante 1 - GLEICHLAUTENDE FEHLERMELDUNG
-    // fuer alles wird eine identische Fehlermeldung gesetzt, das ist
-    // natuerlich nicht sehr flexibel oder schoen
-    AddCmd("kriech|krieche&hoch|hinauf|hinaus|heraus|raus",#'result_kriech,
-           "Wohin willst Du kriechen?");
-    AddCmd("kriech|krieche&nach&oben",#'result_kriech,
-           "Wohin willst Du kriechen??|Wohin willst Du kriechen?");
-    AddCmd("kriech|krieche&aus&loch|grube|falle",#'result_kriech);
-           "Wohin willst Du kriechen?|Wohin willst Du kriechen?");
+Problem 1: Mehrere Regeln weil mehrere Zwecke
+---------------------------------------------
 
-    // oder man versucht eine bessere Regel zu schaffen, was hier durch
-    // die Moeglichkeit von zwei oder drei Parameter unmoeglich ist
+Variante 1 - GLEICHLAUTENDE FEHLERMELDUNG
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  
+  Fuer alles wird eine identische Fehlermeldung gesetzt, das ist
+  natuerlich nicht sehr flexibel oder schoen
+  oder man versucht eine bessere Regel zu schaffen, was hier durch
+  die Moeglichkeit von zwei oder drei Parameter unmoeglich ist
 
-    ## Variante 2 - EIGENE AUSWERTUNG
-    // es bietet sich also eigene Weiterauswertung an, was durch die
-    // Uebergabe der getriggerten Verben erleichtert wird:
+.. code-block:: pike
+
+  AddCmd("kriech|krieche&hoch|hinauf|hinaus|heraus|raus",#'result_kriech,
+         "Wohin willst Du kriechen?");
+  AddCmd("kriech|krieche&nach&oben",#'result_kriech,
+         "Wohin willst Du kriechen??|Wohin willst Du kriechen?");
+  AddCmd("kriech|krieche&aus&loch|grube|falle",#'result_kriech);
+         "Wohin willst Du kriechen?|Wohin willst Du kriechen?");
+
+
+Variante 2 - EIGENE AUSWERTUNG
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    
+  Statt der Verwendung mehrerer aehnlicher AddCmd() bietet sich die eigene 
+  Weiterauswertung an, was durch die Uebergabe der getriggerten Argumente
+  erleichtert wird.
+
+.. code-block:: pike
+
     AddCmd("kriech|krieche&hoch|hinauf|hinaus|heraus|raus|aus|nach",
            #'result_kriech,
            "Wohin willst Du kriechen?");
-    ...
-    static int result_kriech(string str, mixed *extra) {
+    // ...
+    private int result_kriech(string str, mixed *extra) {
       if(member(extra,"aus")>=0 &&
          !sizeof(({str}),"*.\\<(hoehle|grube|falle)\\>.*"))
-       notify_fail("Woraus willst Du kriechen?\n");
+        notify_fail("Woraus willst Du kriechen?\n");
       else if(member(extra,"nach")>=0 && strstr(str,"oben")<0)
-       notify_fail("In welche Richtung willst Du kriechen?\n");
+        notify_fail("In welche Richtung willst Du kriechen?\n");
       else if(this_player()->QueryAttribute(A_DEX)>10 ||
               member(holding_root,this_player())) {
         write("Du kriechst mit Muehe heraus.\n");
@@ -295,42 +375,49 @@
       }
       return 0;
     }
-    // (ob sich der Aufwand fuer diese Beispielsyntax lohnt ist fraglich)
 
- ## Problem 2: mehrere Regeln, weil optionale Parameter ##
-    // Manchmal will man optionale Parameter erlauben, die aber eine
-    // Wirkung zeigen sollen:
-    AddCmd("schlag|schlage&@ID&hart",#'action_schlag_hart,
-           "Was oder wen willst du @verben?|"
-           "Wie willst du @WEN2 schlagen?");
-    AddCmd("schlag|schlage&@ID",#'action_schlag,
-           "Was oder wen willst du @verben?");
+Problem 2: mehrere Regeln aufgrund von optionalen Parametern
+------------------------------------------------------------
 
-    // Da juengere AddCmd aelteren vorgehen, wird die komplexere Regel samt
-    // ihrer Fehlermeldung nie ausgewertet, da ein "schlag ball hart" auch
-    // die zweite Regel triggert.
+  Manchmal will man optionale Parameter erlauben, die aber eine
+  Wirkung zeigen sollen. Hierbei ist die Reihenfolge der AddCmd()-
+  Anweisungen und ggf. deren Aufbau entscheidend.
 
-    // anders herum:
-    AddCmd("schlag|schlage&@ID",#'action_schlag,
-           "Was oder wen willst du @verben?");
-    AddCmd("schlag|schlage&@ID&hart",#'action_schlag_hart,
-           "Was oder wen willst du @verben?|"
-           "Wie willst du @WEN2 schlagen?");
+.. code-block:: pike
 
-    // Jetzt wird die komplexere Regel zuerst ueberprueft und triggert
-    // auch die richtige Funktion.
-    // Leider kommt die Fehlermeldung nie zum Tragen, denn was durch Regel 2
-    // durchfaellt, triggert entweder Regel 1 oder faellt auch durch Regel 1
-    // durch und ueberschreibt dabei die Meldung.
+  AddCmd("schlag|schlage&@ID&hart",#'action_schlag_hart,
+         "Was oder wen willst du @verben?|"
+         "Wie willst du @WEN2 schlagen?");
+  AddCmd("schlag|schlage&@ID",#'action_schlag,
+         "Was oder wen willst du @verben?");
 
-    AddCmd("schlag|schlage&@ID",#'action_schlag,
-           "Was oder wen willst du wie @verben?");
-    AddCmd("schlag|schlage&@ID&hart",#'action_schlag_hart);
+  Da juengere AddCmd aelteren vorgehen, wird die komplexere Regel samt
+  ihrer Fehlermeldung nie ausgewertet, da ein "schlag ball hart" auch
+  die zweite Regel triggert.
 
-    // Fast perfekt. Besser wird es nicht.
+  Anders herum:
 
+.. code-block:: pike
 
-    --- Ende Komplexbeispiel mehrere Regeln ---
+  AddCmd("schlag|schlage&@ID",#'action_schlag,
+         "Was oder wen willst du @verben?");
+  AddCmd("schlag|schlage&@ID&hart",#'action_schlag_hart,
+         "Was oder wen willst du @verben?|"
+         "Wie willst du @WEN2 schlagen?");
 
-Letzte Aenderung: 22.12.2016, Bugfix
+  Jetzt wird die komplexere Regel zuerst ueberprueft und triggert
+  auch die richtige Funktion.
+  Leider kommt die Fehlermeldung nie zum Tragen, denn was durch Regel 2
+  durchfaellt, triggert entweder Regel 1 oder faellt auch durch Regel 1
+  durch und ueberschreibt dabei die Meldung.
+
+.. code-block:: pike
+
+  AddCmd("schlag|schlage&@ID",#'action_schlag,
+         "Was oder wen willst du wie @verben?");
+  AddCmd("schlag|schlage&@ID&hart",#'action_schlag_hart);
+
+  Das ist zwar auch nur fast perfekt, besser wird es aber nicht.
+
+Letzte Aenderung: 20.11.2019, Arathorn