diff --git a/std/player/viewcmd.c b/std/player/viewcmd.c
new file mode 100644
index 0000000..5d7e618
--- /dev/null
+++ b/std/player/viewcmd.c
@@ -0,0 +1,754 @@
+// 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
+
+#define NEED_PROTOTYPES
+#include "/sys/thing/properties.h"
+#include "/sys/living/put_and_get.h"
+#include "/sys/living/description.h"
+
+#include <container.h>
+#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 <sys_debug.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 nosave int exa_cnt;
+private nosave int exa_time;
+private nosave string *exa;
+
+varargs int _examine(string str, int mode)
+{
+  object base, *objs, env;
+  string what, detail, parent, out, error;
+  int i, size, done;
+
+  if(CannotSee()) return 1;
+
+  _notify_fail("Was willst Du denn untersuchen?\n");
+  if (!str) return 0;
+
+  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 = ({});
+    }
+  }
+  // do we look at an object in our environment ?
+  if (sscanf(str,"%s in raum", what) || sscanf(str,"%s im raum", what))
+      base = environment();
+  // is the object inside of me (inventory)
+  else if (sscanf(str,"%s in mir", what) || sscanf(str,"%s in dir", what))
+      base = this_object();
+  else {
+      what = str;
+      // get the last object we looked at
+      base = QueryProp(P_REFERENCE_OBJECT);
+      
+      // if a reference object exists, test for its existance in the room
+      // or in our inventory
+      if (objectp(base))
+      {
+       if (base == environment() || base==this_object())
+        {
+          // Umgebung oder Spieler selber sind als Bezugsobjekt immer in
+          // Ordnung, nichts machen.
+        }
+        // Das Referenzobjekt darf nicht unsichtbar sein.
+        else if (!base->short())
+          base = 0;
+        else if(member(deep_inventory(environment()), base) != -1)
+        {
+          foreach(env : all_environment(base)) {
+            // 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())
+                base = 0;
+              break;
+            }
+          }
+        }
+        else
+          base = 0; // nicht im Raum oder Inventory
+      }
+  }
+
+  // scan input if we want a specific object to look at
+  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)
+  {
+    // if an ref object exists get its inventory. (Oben wurde sichergestellt,
+    // dass das Referenzobjekt einsehbar ist)
+    if(base)
+      objs = base->locate_objects(parent, 1) || ({});
+    else {
+      // else get our inv and env
+      objs = environment()->locate_objects(parent, 1)
+           + locate_objects(parent, 1);
+    }
+    objs = filter_objects(objs, "short"); // nur sichtbare...
+    if(sizeof(objs) > 1)
+      return (notify_fail("Es gibt mehr als eine(n) "+capitalize(parent)+".\n"), 0);
+    else
+    {
+      if (sizeof(objs))
+        base = objs[0];
+      else
+        return (notify_fail("Hier ist kein(e) "+capitalize(parent)+".\n"), 0);
+    }
+    objs = 0;
+  }
+  else detail = what;
+
+  int base_was_env = 1;
+  do {
+    // if a base exists get its inventory, else get our inv and env
+    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
+      {
+        // Referenzobjekt da, aber nicht reinguckbar. base aber nicht nullen,
+        // denn es ist ja noch gueltig fuer Detailsuchen an base...
+        objs = ({});
+      }
+    }
+    else
+    {
+      objs = environment()->locate_objects(detail, 1)
+           + locate_objects(detail, 1);
+      base = environment();
+    }
+    objs = filter_objects(objs, "short"); // nur sichtbare...
+
+    if(!sizeof(objs))
+    {
+      // wenn keine Objekte gefunden wurden, wird nach Details gesucht...
+      if((out = base->GetDetail(detail, QueryProp(P_REAL_RACE),SENSE_VIEW)) ||
+         (out = base->GetDoorDesc(detail)))
+      {
+        SetProp(P_REFERENCE_OBJECT, base);
+        return (write(out), 1);
+      }
+      else
+      {
+        // wenn auch keine Details gefunden, dann schauen, ob Ende ist
+        // (base==env) oder wir evtl. noch im env suchen koennen.
+        if (base == environment())
+        {
+          if (base_was_env) {
+            // in diesem Fall war das Env das Bezugsobjekt - daher wegwerfen.
+            SetProp(P_REFERENCE_OBJECT, 0);
+            _notify_fail("Sowas siehst Du da nicht!\n");
+          }
+          else {
+            _notify_fail("Sowas siehst Du auch da nicht!\n");
+            // in diesem Fall war nicht das Env das Bezugsobjekt - es soll
+            // behalten und nicht geloescht werden.
+          }
+          return 0;
+        }
+        else {
+          base_was_env=0;
+          write(break_string("Du findest an "+base->name(WEM)
+                +" kein \"" + capitalize(detail) + "\"."
+                 " Dein Blick wendet sich der Umgebung zu.",78));
+          base = 0;
+        }
+      }
+    }
+    else  // Objekte gefunden!
+      done = 1;
+  } while(!done);
+
+  // Es muss min. ein (sichtbares) Objekt geben, sonst waere man hier nicht
+  // hingekommen.
+  object ob = objs[0];
+  SetProp(P_REFERENCE_OBJECT, ob);
+  tell_object(ME, ob->long(mode));
+  return 1;
+}
+
+varargs int _sense_exa(string str)
+{
+  object base, *objs, env;
+  string what, detail, parent, out, error;
+  int sense;
+
+  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))
+      return notify_fail("Du bist taub!\n"), 0;
+
+    _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 0;
+    if (this_object()->CannotSee()) {
+      notify_fail("Du kannst nichts sehen!\n");
+      return 0;
+    }
+    sense = SENSE_READ;
+  }
+
+  if (!str) {
+    if(!detail =
+        environment()->GetDetail(SENSE_DEFAULT,QueryProp(P_REAL_RACE),sense))
+      return 0;
+    write(detail);
+    return 1;
+  }
+  else if(sscanf(str,"an %s",what)==1)
+    str=what;
+
+  // do we look at an object in our environment ?
+  if (sscanf(str,"%s in raum", what) || sscanf(str,"%s im raum", what))
+      base = environment();
+  // is the object inside of me (inventory)
+  else if (sscanf(str,"%s in mir", what) || sscanf(str,"%s in dir", what))
+      base = this_object();
+  else {
+      what = str;
+      // get the last object we looked at
+      base = QueryProp(P_REFERENCE_OBJECT);
+      
+      // if a reference object exists, test for its existance in the room
+      // or in our inventory
+      if (objectp(base))
+      {
+        if (base == environment() || base==this_object())
+        {
+          // Umgebung oder Spieler selber sind als Bezugsobjekt immer in
+          // Ordnung, nichts machen.
+        }
+        // Das Referenzobjekt darf nicht unsichtbar sein.
+        else if (!base->short())
+          base = 0;
+        else if(member(deep_inventory(environment()), base) != -1)
+        {
+          foreach(env : all_environment(base)) {
+            // 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())
+                base = 0;
+              break;
+            }
+          }
+        }
+        else
+          base = 0; // nicht im Raum oder Inventory
+      }
+  }
+
+  // scan input if we want a specific object to look at
+  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)
+  {
+    // if an ref object exists get its inventory. (Oben wurde sichergestellt,
+    // dass das Referenzobjekt einsehbar ist)
+
+    if(base)
+      objs = base->locate_objects(parent, 1) || ({});
+    else
+    {
+      // else get our inv and env
+      objs = environment()->locate_objects(parent, 1)
+           + locate_objects(parent, 1);
+    }
+    objs = filter_objects(objs, "short"); // nur sichtbare...
+    if(sizeof(objs) > 1)
+      return (notify_fail("Es gibt mehr als eine(n) "+capitalize(parent)+".\n"), 0);
+    else
+    {
+      if(sizeof(objs))
+          base = objs[0];
+      else
+          return (notify_fail("Hier ist kein(e) "+capitalize(parent)+".\n"), 0);
+    }
+    objs = 0;
+  }
+  else detail = what;
+
+  // wie auch immer haben wir jetzt ein Bezugsobjekt.
+  int maxtries=3;
+  do {
+    int base_was_env=1;
+    // als ersten werden in Frage kommende Objekte gesucht. Wenn base
+    // existiert (idR nur im ersten Durchlauf), wird dort gesucht, sonst in
+    // Env und Inv.
+    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
+      {
+        // Referenzobjekt da, aber nicht reinguckbar. base aber nicht nullen,
+        // denn es ist ja noch gueltig fuer Detailsuchen an base...
+        objs = ({});
+      }
+    }
+    else
+    {
+      objs = environment()->locate_objects(detail, 1)
+           + locate_objects(detail, 1);
+      base = environment();
+    }
+    objs = filter_objects(objs, "short"); // nur sichtbare...
+
+    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)
+      {
+        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);
+        if (stringp(out))
+        {
+          SetProp(P_REFERENCE_OBJECT, ob);
+          tell_object(ME, out);
+          return 1;
+        }
+      }
+    }
+
+    // Keine Objekte gefunden, die in Frage kommen. Nach Details suchen.
+    if(out = base->GetDetail(detail, QueryProp(P_REAL_RACE),sense))
+    {
+      SetProp(P_REFERENCE_OBJECT, base);
+      return (write(out), 1);
+    }
+    else
+    {
+      // Auch keine Details gefunden... Wenn wir uns noch das Env angucken
+      // koennen (weil base != env), dann machen wir das, ansonsten ist
+      // jetzt hier leider Ende...
+      if(base == environment())
+      {
+        if (base_was_env)
+          SetProp(P_REFERENCE_OBJECT, 0);
+        return 0;
+      }
+      else
+      {
+        // nochmal im naechsten Schleifendurchlauf ohne base probieren.
+        base = 0;
+        base_was_env = 0; 
+      }
+    }
+  } while(--maxtries);
+
+  // nach dieser Schleife sollte man nie ankommen...
+  raise_error(sprintf("_sense_exa(): zuviele Versuche, etwas zu finden."));
+
+  return 0;
+}
+
+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_obs(str,PUT_GET_NONE);
+  if (!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);
+}
+
+int _look(string str)
+{
+  string s;
+  int flag;
+
+  if(CannotSee()) return 1;
+
+  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;
+  }
+  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;
+  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);
+  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","_sense_exa",0,0}),
+      ({"lausch","_sense_exa",0,0}),
+      ({"hoer","_sense_exa",0,0}),
+      ({"hoere","_sense_exa",0,0}),
+      ({"lies","_sense_exa",0,0}),
+      ({"lese","_sense_exa",0,0}),
+      ({"les","_sense_exa",0,0}),
+      ({"schnupper","_sense_exa",0,0}),
+      ({"schnuppere","_sense_exa",0,0}),
+      ({"riech","_sense_exa",0,0}),
+      ({"rieche","_sense_exa",0,0}),
+      ({"taste","_sense_exa",0,0}),
+      ({"beruehre","_sense_exa",0,0}),
+      ({"beruehr","_sense_exa",0,0}),
+      ({"kurz","_toggle_brief",0,0}),
+      ({"lang","_toggle_brief",0,0}),
+      ({"ultrakurz","_toggle_brief",0,0}) 
+    });
+}