doc/sphinx/lfun/AddCmd_bsp.rst

ADDCMD() - BEISPIELE
********************

FUNKTION
========
::

    varargs void AddCmd(mixed cmd, mixed func, mixed flag);

BEMERKUNGEN
===========
::

    Die hier aufgefuehrten Komplexbeispiele sind zum Verstaendnis gedacht,
    daher fuehren sie oft Alternativen auf. Die letzte Variante ist dann
    jeweils diejenige, welche am leichtesten das Problem loesen koennte.
    Falls die einem zu komplex ist, hilft vielleicht die vorletzte.

BEISPIELE
=========

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");
     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
   }

2. SIMPEL .. weitere Beispiele

.. code-block:: pike

   AddCmd(({"kletter","klettere"}),"action_klettern" );
   AddCmd(({"renn","renne"}),#'action_rennen);

3. REGELN: eine komplexere Regel

.. code-block:: pike

   AddCmd("loesch|loesche|ersticke&feuer|brand|flammen&decke|wolldecke",
          "action_loeschen",
          "Was willst du loeschen?|Womit willst du loeschen?");

4. REGELN: mit Platzhaltern im Fehlerstring

.. 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)
         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

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 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));
      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;
  }

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.

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
  oder man versucht eine bessere Regel zu schaffen, was hier durch
  die Moeglichkeit von zwei oder drei Parameter unmoeglich ist

.. 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?");
    // ...
    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;
    }

Problem 2: mehrere Regeln aufgrund von optionalen Parametern
------------------------------------------------------------

  Manchmal will man optionale Parameter erlauben, die aber eine
  Wirkung zeigen sollen. Hierbei ist die Reihenfolge der AddCmd()-
  Anweisungen und ggf. deren Aufbau entscheidend.

.. code-block:: pike

  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?");

  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:

.. code-block:: pike

  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?");

  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