std/player/viewcmd.c

// MorgenGrauen MUDlib
//
// player/viewcmd.c -- player view command handling
//
// $Id: viewcmd.c 9548 2016-04-17 19:28:22Z Zesstra $

#pragma strong_types
#pragma save_types
#pragma range_check
#pragma no_clone
#pragma pedantic

//#include <player.h>
#include <properties.h>
#include <rooms.h>
#include <wizlevels.h>
#include <defines.h>
#include <moving.h>
#include <new_skills.h>
#include <ansi.h>
#include <notify_fail.h>
#include <sys_debug.h>

#define NEED_PROTOTYPES
#include <container.h>
#include <thing/properties.h>
#include <living/put_and_get.h>
#include <living/description.h>
#include <living/put_and_get.h>
#include <player/command.h>

varargs mixed More(string str, int fflag, string returnto);

void create()
{
  Set(P_BRIEF, SAVE, F_MODE);
  Set(P_BLIND, SAVE, F_MODE);
}

int _toggle_brief()
{
  int brief;

  if (query_verb()=="kurz")
    brief=1;
  else if (query_verb()=="ultrakurz")
    brief=2;
  else brief=0;
  SetProp(P_BRIEF, brief);
  write("Du bist nun im \""+
        (brief?(brief==1?"Kurz":"Ultrakurz"):"Lang")+"\"modus.\n");
  return 1;
}

private int sortinv(mixed a, mixed b) { return a[0] > b[0]; }

private string collectinv(mixed obj)
{
  if(obj[0]=="") return 0;
  return (obj[2] ? " " : "")
       + obj[0]
       + (obj[1] > 1 ? " ("+obj[1]+")" : "");
}

#define I_AUTOLOAD      1
#define I_KEEP          4
#define I_FORMATTED     16
#define I_ARMOUR        64
#define I_SORT          256
#define I_WEAPON        1024
#define I_FORCE_SORT    4096
#define I_NO_TABLE      16384

private string getflags(string arg, int flags)
{
  int no, i;
  if(sizeof(arg) < 2) return 0;
  no = (arg[0] == '-');

  for(i = 1; i < sizeof(arg); i++)
  {
    switch(arg[i])
    {
    case 'a': flags |= I_AUTOLOAD << no; break;
    case 'b': flags |= I_KEEP << no; break;
    case 'f': flags |= I_FORMATTED << no; break;
    case 'r': flags |= I_ARMOUR << no; break;
    case 's': flags |= I_SORT << no; break;
    case 'w': flags |= I_WEAPON << no; break;
    case 'v': flags |= (I_ARMOUR | I_WEAPON) << !no; break;
    case '1': flags |= I_NO_TABLE; break;
        // Die Option macht nur Aerger und kommentiert ist sie eh nicht.
        // Wer das dringend braucht, soll Wargons Schiebepuzzle benutzen.
        //
        // Tiamak, 15.10.2000
        //    case 'S': flags |= I_FORCE_SORT << no; break;
    default : return arg[i..i]; // wird ausgegeben an Spieler als unbekannt.
    }
  }
  return 0;
}

static int _check_keep(object ob)
{
  return (ob->QueryProp(P_KEEP_ON_SELL))==geteuid(ME);
}

int _inventory(string str)
{
  mixed *args, output;
  int ansi, i, flags, minv;
  mixed inventory, weapons, armours, misc;
  string format;

  if(CannotSee()) return 1;

  if((str = _unparsed_args()) && str!="")
  {
    string error;
    error = "Benutzung: i[nventar] [-/+1abfrsvw]\n";
    args = regexp(regexplode(str, "[-+][1abfrswv][1abfrswv]*"),
                  "[-+][1abfrswv][1abfrswv]*");
    if(!sizeof(args)) return (_notify_fail(error), 0);
    if(sizeof(args = map(args, #'getflags/*'*/, &flags) - ({ 0 })))
    {
      printf("%s: Unbekanntes Argument.\n"+error, implode(args, ", "));
      return 1;
    }
  }
  // Fuer Spieler gehen nur sichtbare Objekte in den Algorithmus
  if (IS_LEARNING(ME))  
    inventory = all_inventory(ME);
  else
    inventory = filter_objects(all_inventory(ME), "short");
  
  ansi = member(({"vt100", "ansi"}), QueryProp(P_TTY)) != -1;
  minv = 1 | (flags & (I_FORMATTED | (I_FORMATTED << 1)) ? 2 : 0);
  format = (flags & I_NO_TABLE) ? "=" : "#";

//  if(flags & (I_FORCE_SORT | I_FORCE_SORT << 1))
//  {
//    closure sf;
//    sf = flags & I_FORCE_SORT ? #'> : #'<;
//    s = sort_array(s, lambda(({'a, 'b}),
//                             ({#'funcall, sf,
//                                   ({#'||,({#'call_other,'a,"short"}),""}),
//                                   ({#'||,({#'call_other,'b,"short"}),""})})));
//    map_objects(s, "move", this_object());
//    s = all_inventory(ME);
//  }

  if (flags & I_AUTOLOAD)
    inventory = filter_objects(inventory,"QueryProp",P_AUTOLOADOBJ);
  else if (flags & (I_AUTOLOAD << 1))
    inventory -= filter_objects(inventory,"QueryProp",P_AUTOLOADOBJ);

  if(flags & I_KEEP)
    inventory = filter(inventory,#'_check_keep);
  else if(flags & (I_KEEP << 1))
    inventory -= filter(inventory,#'_check_keep);

  armours = filter_objects(inventory, "QueryProp", P_ARMOUR_TYPE);
  // Kleidung dazu addieren, vorher die erkannten Ruestungen abziehen, die
  // muessen nicht nochmal durchiteriert werden.
  armours += filter_objects(inventory-armours, "IsClothing");
  // Ruestungen werden hier nicht abgezogen, weil es Kram gibt, welche sowohl
  // Ruestung als auch Waffe ist.
  weapons = filter_objects(inventory, "QueryProp", P_WEAPON_TYPE);
  misc = inventory - weapons - armours; // rest ;-)

  if(flags & I_WEAPON)
  {
    inventory = weapons; misc = ({});
    if(!(flags & (I_ARMOUR))) armours = ({});
  }
  if(flags & I_ARMOUR)
  {
     inventory = armours; misc = ({});
     if(!(flags & I_WEAPON)) weapons = ({});
  }
  if(flags & (I_WEAPON << 1)) { weapons = ({}); inventory = armours + misc; }
  if(flags & (I_ARMOUR << 1)) { armours = ({}); inventory = weapons + misc; }

  output = "";
  if(flags & (I_FORMATTED | (I_FORMATTED << 1)))
  {
    inventory = make_invlist(this_player(), inventory, minv);
    if(flags & (I_SORT | (I_SORT << 1)))
    inventory = sort_array(inventory, #'sortinv/*'*/);
    output += sprintf("%"+format+"-78s\n",
                      implode(map(inventory,#'collectinv/*'*/),"\n"));
  }
  else
  {
    if(weapons && sizeof(weapons))
    {
      weapons = make_invlist(this_player(), weapons, minv);
      if(flags & (I_SORT | (I_SORT << 1)))
        weapons = sort_array(weapons, #'sortinv/*'*/);
      output += (ansi?ANSI_BOLD:"") + "Waffen:" + (ansi?ANSI_NORMAL:"")+"\n"
              + sprintf("%"+format+"-78s\n",
                        implode(map(weapons, #'collectinv/*'*/), "\n"));
    }
    if(armours && sizeof(armours))
    {
      armours = make_invlist(this_player(), armours, minv);
      if(flags & (I_SORT | (I_SORT << 1)))
        armours = sort_array(armours, #'sortinv/*'*/);
      output += (ansi?ANSI_BOLD:"") 
              + "Kleidung & Ruestungen:" + (ansi?ANSI_NORMAL:"")+"\n"
              + sprintf("%"+format+"-78s\n",
                        implode(map(armours, #'collectinv/*'*/), "\n"));
    }
    if(misc && sizeof(misc))
    {
      misc = make_invlist(this_player(), misc, minv);
      if(flags & (I_SORT | (I_SORT << 1)))
        misc = sort_array(misc, #'sortinv/*'*/);
      output += (ansi?ANSI_BOLD:"") + "Verschiedenes:" + (ansi?ANSI_NORMAL:"")+"\n"
              + sprintf("%"+format+"-78s\n",
                        implode(map(misc, #'collectinv/*'*/), "\n"));
    }
  }

  // Spielerwunsch: 'inventar' sollte doch das Bezugsobjekt auf den Spieler
  // aendern.
  SetProp(P_REFERENCE_OBJECT, this_object());

  if (output=="") 
    output += (ansi?ANSI_BOLD:"")+"Die Liste ist leer."+(ansi?ANSI_NORMAL:"");
  More(output);
  return 1;
}

private int select_sense(string str)
{
  int sense = -1;
  if(member(({"riech","rieche","schnupper","schnuppere"}),query_verb())!=-1)
  {
    _notify_fail("Du kannst nichts Besonderes riechen.\n");
    sense = SENSE_SMELL;
  }
  else if(member(({"lausche","lausch","hoer","hoere"}),query_verb())!=-1)
  {
    if(QueryProp(P_DEAF))
    {
      notify_fail("Du bist taub!\n");
      return -1;
    }
    _notify_fail("Du kannst nichts Besonderes hoeren.\n");
    sense = SENSE_SOUND;
  }
  else if(member(({"taste","beruehre","beruehr"}),query_verb())!=-1)
  {
    sense = SENSE_TOUCH;
    // ein "ab" ganz am Ende von str wird abgeschnitten, es soll sowohl "taste
    // x ab" als auch "taste x" funktionieren.
    if (str) {
      _notify_fail("Sowas kannst Du hier nicht ertasten!\n");
      string *tmp = explode(str," ");
      if (sizeof(tmp) > 1 && tmp[<1] == "ab")
        str = implode(tmp[0..<2], " ");
    }
    else
      _notify_fail("Was willst Du denn abtasten?\n");
  }
  else if (member(({"lies","lese","les"}), query_verb()) > -1)
  {
    _notify_fail("Was willst Du lesen?\n");
    if ( !str ) // Kein SENSE_DEFAULT zulassen.
      return -1;
    if (CannotSee(1)) {
      notify_fail("Du kannst nichts sehen!\n", NF_NL_MAX);
      return -1;
    }
    sense = SENSE_READ;
  }
  // else ist normales Sehen/untersuchen
  else
  {
    if (CannotSee(1)) {
      notify_fail("Du kannst nichts sehen!\n", NF_NL_MAX);
      return -1;
    }
    _notify_fail("Was willst Du denn untersuchen?\n");
    if (!str) return -1;
    sense = SENSE_VIEW;
  }
  // "rieche an ..." etc.: das an rausschneiden, wird nicht gebraucht.
  if (sizeof(str))
  {
    if (sense!=SENSE_VIEW)
    {
      string what;
      if (sscanf(str,"an %s",what)==1) str=what;
    }
  }

  return sense;
}

private object get_ref_object(string str, string what)
{
  object ref_object;
  // do we look at an object in our environment ?
  if (sscanf(str,"%s in raum", what) || sscanf(str,"%s im raum", what))
      ref_object = environment();
  // is the object inside of me (inventory)
  else if (sscanf(str,"%s in mir", what) || sscanf(str,"%s in dir", what))
      ref_object = this_object();
  else
  {
      // ansonsten ist das argument komplett der suchstring und wir nehmen das
      // Referenzobjekt (so existent).
      what = str;
      // get the last object we looked at
      ref_object = QueryProp(P_REFERENCE_OBJECT);
      // if a reference object exists, test for its existance in the room
      // or in our inventory
      if (objectp(ref_object))
      {
       if (ref_object == environment() || ref_object==this_object())
        {
          // Umgebung oder Spieler selber sind als Bezugsobjekt immer in
          // Ordnung, nichts machen.
        }
        // Das Referenzobjekt darf nicht unsichtbar sein.
        else if (!ref_object->short())
          ref_object = 0;
        // Nur wenn unser environment() 
        else if(member(deep_inventory(environment()), ref_object) != -1)
        {
          foreach(object env : all_environment(ref_object)) {
            // Ist eine Umgebung Living oder intransparenter Container oder
            // unsichtbar?
            if (living(env) || !env->QueryProp(P_TRANSPARENT)
                || !env->short())
            {
              // in dem Fall ist ende, aber wenn das gefundene Env nicht
              // dieses Living selber oder sein Env ist, wird das
              // Referenzobjekt zusaetzlich genullt.
              if (env != this_object() && env != environment())
                ref_object = 0;
              break;
            }
          }
        }
        else
          ref_object = 0; // nicht im Raum oder Inventory
      }
  }
  return ref_object;
}

private object find_base(object ref_object, string what, string detail,
                         string parent)
{
  object base;
  // Suchen wir an/im/in/etc. einem bestimmten Objekt?
  if(sscanf(what, "%s an %s", detail, parent) == 2 ||
     sscanf(what, "%s am %s", detail, parent) == 2 ||
     sscanf(what, "%s in %s", detail, parent) == 2 ||
     sscanf(what, "%s im %s", detail, parent) == 2)
  {
    object *objs;
    // Wenn es ein Referenzobjekt gibt, wird das parent-Objekt in diesem
    // gesucht. (Oben wurde sichergestellt, dass das Referenzobjekt einsehbar
    // ist)
    if(ref_object)
      objs = ref_object->locate_objects(parent, 1) || ({});
    // sonst im Environment oder in uns.
    else {
      objs = environment()->locate_objects(parent, 1)
           + locate_objects(parent, 1);
    }
    objs = filter_objects(objs, "short"); // nur sichtbare...
    switch(sizeof(objs))
    {
      case 0:
        notify_fail("Hier ist kein(e) "+capitalize(parent)+".\n");
        return 0;
      case 1:
        // Basisobjekt gefunden.
        base = objs[0];
        break;
      default:
        notify_fail("Es gibt mehr als eine(n) "+capitalize(parent)+".\n");
        return 0;
    }
  }
  // im anderen fall ist das komplette what das gesuchte detail, was wir am
  // Referenzobjekt suchen (sofern vorhanden).
  else
  {
    base = ref_object;
    detail = what;
  }
  return base;
}

private nosave int exa_cnt;
private nosave int exa_time;
private nosave string *exa;
private void unt_script_dings(string str)
{
  // unt-script-sucher
  if (!sizeof(str)) return;
  if (member(({"boden","decke","wand","waende"}),old_explode(str," ")[0]) == -1) {
    exa_cnt -= (time() - exa_time)/2;
    exa_time = time();
    exa_cnt++;
    if (!exa)
      exa = ({ str });
    else
      exa += ({ str });
    if (exa_cnt > 10) {
      log_file("ARCH/LOOK", 
          sprintf("%s: %s in %s\n%@O\n",dtime(time()),getuid(this_object()), 
            environment() ? object_name(environment()) : "???",exa), 150000);
      exa_cnt = 0;
      exa = ({});
    }
    else if (exa_cnt < 0) {
      exa_cnt = 0;
      exa = ({});
    }
  }
}

varargs int _examine(string str, int mode)
{
  // Sinn auswaehlen, der benutzt wird. Wenn -1, abbrechen (kein Sinn bzw.
  // Sinn erlaubt ggf. kein leeren <str> fuer Defaulmeldung). Je nach Sinn
  // wird auch <str>modifiziert.
  int sense=select_sense(&str);
  if (sense<0) return 0;

  unt_script_dings(str);

  // Wenn kein str, dann SENSE_DEFAULT vom Environment ausgeben. Bei
  // SENSE_VIEW wurde das bereits bei den Aufrufern dieser Funktion gemacht.
  if (sense!=SENSE_VIEW)
  {
    if (!str)
    {
      string detail = environment()->GetDetail(SENSE_DEFAULT,
                                               QueryProp(P_REAL_RACE),sense);
      if(!detail)
        return 0;
      write(detail);
      return 1;
    }
  }

  // Das Ref-Objekt finden, das kann dann auch in <what> angeben sein. In dem
  // Fall wird <what> um die Angabe des Ref-Objekts gekuerzt.
  string what;
  object ref_object = get_ref_object(str, &what);

  // Sodann ein Basisobjekt finden. Das Basisobjekt ist das, was bei einem
  // "detail an parent" durch parent gekennzeichnet wird oder notfalls das
  // Ref-Objekt von oben.
  string detail, parent; // detail an parent
  object base; // das fuer parent gefundene objekt
  base = find_base(ref_object, what, &detail, &parent);

  // Jetzt wird versucht, ein Objekt mit der ID "detail" in base (parent) oder
  // ein Detail an base zu finden. Die Schleife laeuft ggf. zweimal. Wenn im
  // ersten Durchlauf nichts gefunden wird, wird ggf. noch die Umgebung in
  // einem zweiten Durchlauf anguckt.
  int first_base_was_env = (!base || base==environment() ? 1 : 0);
  do {
    object *objs;
    // Wenn base existiert und wir reingucken koennen, ermitteln wir alle zu
    // detail in Frage kommenanden Objekte in seinem Inventar
    if (base)
    {
      if  (base == this_object() || base == environment() ||
          (base->QueryProp(P_TRANSPARENT) && !living(base)))
      {
        // ich kann in base reingucken...
        objs = base->locate_objects(detail, 1) || ({});
      }
      else
      {
        // Basisobjekt da, aber nicht reinguckbar, also keine Objekte
        // gefunden. base aber nicht nullen, denn es ist ja noch gueltig fuer
        // Detailsuchen an base...
        objs = ({});
      }
    }
    // Wenn nicht, werden alle fuer detail in Frage kommenden Objekt in
    // unserer Umgebung und in uns selber ermittelt.
    else
    {
      base = environment();
      objs = environment()->locate_objects(detail, 1)
           + locate_objects(detail, 1);
    }
    // Und in jedem Fall werden alle Objekt raussortiert, die unsichtbar sind.
    // ;-)
    objs = filter_objects(objs, "short"); // nur sichtbare...

    // Wenn es sichtbare gibt, werden die ggf. angeguckt.
    if (sizeof(objs))
    {
      // Objekte gefunden, mal schauen, ob die taugen (d.h. fuer den jew. Sinn
      // Infos haben. Wenn nicht, muessen wir weitersuchen.
      // Aber erstmal die Objekte durchlaufen.
      foreach(object ob: objs)
      {
        string out;
        if (sense == SENSE_VIEW)
        {
          out = ob->long(mode);
        }
        else if (sense == SENSE_READ)
        {
          // Extrawurst: P_READ_MSG auch noch abfragen.
          out = ob->QueryProp(P_READ_MSG);
          if (!stringp(out))
            out = ob->GetDetail(SENSE_DEFAULT,QueryProp(P_REAL_RACE),SENSE_READ);
        }
        else 
          out=ob->GetDetail(SENSE_DEFAULT,QueryProp(P_REAL_RACE),sense);
        // Wenn was gefunden wurde, sind wir fertig.
        if (stringp(out))
        {
          SetProp(P_REFERENCE_OBJECT, ob);
          tell_object(ME, out);
          return 1;
        }
      }
    }
    // offenbar keine Objekte gefunden oder die hatten nix fuer unseren Sinn
    // dabei. Also nach ordinaeren Details an base/parent suchen.
    string out = base->GetDetail(detail, QueryProp(P_REAL_RACE), sense);
    if (!out && sense==SENSE_VIEW)
      out = base->GetDoorDesc(detail);
    if (out)
    {
      // Detail gefunden, base darf neues Referenzobjekt werden und nach
      // Ausgabe sind wir fertig.
      SetProp(P_REFERENCE_OBJECT, base);
      write(out);
      return 1;
    }
    else
    {
      // wenn auch keine Details gefunden, dann schauen, unser Env evtl.
      // noch nen passendes Detail oder Objekt hat. Das ist aber natuerlich
      // nur der Fall, wenn base nicht eh schon das Environment ist.
      if (base != environment())
      {
        // Wir schauen uns das Env noch an. Bei den anderen Sinnen kein neues
        // notify_fail, weil sonst staendig Meldungen kommen, dass x nicht da
        // ist, nur weil es keine Beschreibung fuer den Sinn hat.
        if (sense==SENSE_VIEW)
          write(break_string("Du findest an "+base->name(WEM)
                +" kein \"" + capitalize(detail) + "\"."
                 " Dein Blick wendet sich der Umgebung zu.",78));
        // in diesem Fall nullen wir base und lassen die Schleife noch
        // einmal durchlaufen.
        base = 0;
        continue;
      }
      // Leider ist nix mehr uebrig zum angucken und in jedem Fall Ende.
      else
      {
        // Wenn schon das erste angeguckte base das Environment war (dann
        // ist diese Schleife uebrigens nur einmal gelaufen), gibt es eine
        // leicht andere Meldung und das Bezugsobjekt muss weg.
        // neue notify_fail gibt es nur fuer SENSE_VIEW (s.o.)
        if (first_base_was_env) {
          SetProp(P_REFERENCE_OBJECT, 0);
          if (sense==SENSE_VIEW)
            _notify_fail("Sowas siehst Du da nicht!\n");
        }
        else if (sense==SENSE_VIEW) {
          _notify_fail("Sowas siehst Du auch da nicht!\n");
        }
        return 0;
      }
    }
  } while(1);
  // Nie erreicht.
  return 0;
}

// Funktion fuer "schau in ..."
varargs int look_into(string str,int mode)
{
  object *found_obs;

  if( CannotSee() ) return 1;
  _notify_fail("Wo willst Du denn reinschauen?\n");
  found_obs=find_objects(str, 0, 0);
  if (!sizeof(found_obs))
  {
    if (environment() &&
        (environment()->GetDetail(str,QueryProp(P_REAL_RACE))||
         environment()->GetDoorDesc(str)))
      _notify_fail("Da kannst Du so nicht reinsehen.\n");
    return 0;
  }
  
  return _examine(str, mode);
}

/* Gebe die Umgebung des aktiven Spielers zurueck, lasse dabei  */
/* rekursiv geschachtelte Raeume zu.                            */
/* Wenn allow_short 0 ist, so wird immer die long-descr benutzt */
varargs string env_descr(int allow_short,int flags, int force_short )
{
  object env;
  int brief;

  env = environment(ME);

  if(!env)
    return "Du schwebst im Nichts ... Du siehst nichts, rein gar nichts ...\n";

  if (!force_short && (!allow_short || !QueryProp(P_BRIEF)))
      return env->int_long(ME,ME,flags);

  if (!flags && ((brief=QueryProp(P_BRIEF))>=2))
      return "";

  return env->int_short(ME,ME);
}

// Kommandofunktion fuer schau.
// Verzweigt ggf. in _examine() fuers normale Untersuchen.
int _look(string str)
{
  string s;
  int flag;

  if(CannotSee()) return 1;

  // nur schau mit ggf. Flags entsorgt das Ref-Objekt und schaut die
  // Raumbeschreibung an.
  if(!str)
  {
    SetProp(P_REFERENCE_OBJECT, 0);
    write( env_descr() );
    return 1;
  }
  if(str=="-f" || str=="genau")
  {
    SetProp(P_REFERENCE_OBJECT, 0);
    write( env_descr(0,2) );
    return 1;
  }
  if(str=="-k" || str=="kurz")
  {
    SetProp(P_REFERENCE_OBJECT, 0);
    write( env_descr(1,2,1) );
    return 1;
  }
  // Ansonsten wird in _examine() weitergemacht, wobei Flags vorher
  // rausgeschnitten werden. _examine() benutzt die Flags, falls es eine
  // Langbeschreibung eines Objektes ausgeben wird.
  if(str[0..2]=="-f "){
    flag=2;
    str=str[3..];
  }
  else if(str[0..5]=="genau "){
    flag=2;
    str=str[6..];
  }
  else flag = 0;

  if (sscanf(str,"%s an",s)) str=s;
  // "in mir", "in dir" soll in _examine rein, aber "in ..." in look_into().
  if (sscanf(str,"%s in mir",s)||sscanf(str,"%s in dir",s)) return _examine(str,flag);
  if (sscanf(str,"in %s",s)) return look_into(s,flag);
  // Alles andere weiter an _examine().
  return _examine(str,flag);
}

int _equipment(string arg)
{
  if (CannotSee()) return 1;
  call_other("/std/player/invmaster/invmaster", "ShowInv", ME, arg);
  return 1;
}

static mixed _query_localcmds()
{
  return
    ({({"ausruestung", "_equipment",0,0}),
      ({"i","_inventory",0,0}),
      ({"inv","_inventory",0,0}),
      ({"inventur","_inventory",0,0}),
      ({"schau","_look",0,0}),
      ({"schaue","_look",0,0}),
      ({"unt","_examine",0,0}),
      ({"untersuch","_examine",0,0}),
      ({"betracht","_examine",0,0}),
      ({"untersuche","_examine",0,0}),
      ({"betrachte","_examine",0,0}),
      ({"betr","_examine",0,0}),
      ({"lausche","_examine",0,0}),
      ({"lausch","_examine",0,0}),
      ({"hoer","_examine",0,0}),
      ({"hoere","_examine",0,0}),
      ({"lies","_examine",0,0}),
      ({"lese","_examine",0,0}),
      ({"les","_examine",0,0}),
      ({"schnupper","_examine",0,0}),
      ({"schnuppere","_examine",0,0}),
      ({"riech","_examine",0,0}),
      ({"rieche","_examine",0,0}),
      ({"taste","_examine",0,0}),
      ({"beruehre","_examine",0,0}),
      ({"beruehr","_examine",0,0}),
      ({"kurz","_toggle_brief",0,0}),
      ({"lang","_toggle_brief",0,0}),
      ({"ultrakurz","_toggle_brief",0,0}) 
    });
}