obj/tools/lupe.c

// This tool was originally written by Macbeth@TUBmud
//
// Some changes/extensions by Jof@MorgenGrauen

inherit "/std/secure_thing";
protected functions virtual inherit "/std/util/path";

#include <language.h>
#include <properties.h>
#include <wizlevels.h>
#include <moving.h>
#include <defines.h>
#include <questmaster.h>
#include <userinfo.h>
#include <strings.h>

#define add(s) commands+=({s});functions+=({s});ncmds++
#define add2(s,f) commands+=({s});functions+=({f});ncmds++
#define MAXSTACK 10
#define MAXVARS 10
#define MAXDEPTH 5
#define MAXLINES 40
#define MAXLINELEN 79

mixed *stack, *vararea, err;

string *commands, *functions, user, *query_list, *argv;
int maxverb,ncmds,argc,recursive,hide_short,lines,firstline,lastline;
static int tell(string str);
int evalcmd(string str);
int eval(string str);
string stk(string arg);
string desc(object ob);
void clean(object ob);
void cleanof(string str,object ob);


protected void create()
{
  object owner;
  string str;

  if (!clonep(ME)) {
      set_next_reset(-1);
      return;
  }
  ::create();
  owner=environment()||this_player();
  if (owner)
    str=capitalize(((str=geteuid(owner))[<1]=='s'||str[<1]=='x'||str[<1] =='z')?str+="'":str+="s"); 
  else
    str="Eine";
  SetProp( P_SHORT,str+" Lupe" );
  SetProp( P_NAME, str+" Lupe" );
  SetProp( P_LONG, "Mit dieser Lupe kann man die Feinheiten des LPC besser erkennen.\n" );
  SetProp( P_NEVERDROP, 1 );
  SetProp( P_NODROP, "Du kannst Deine Lupe nicht wegwerfen. Dazu ist sie zu wertvoll.\n");
  SetProp( P_NOBUY, 1 );
  SetProp( P_GENDER, FEMALE );
  SetProp( P_WEIGHT, 0 );
  SetProp( P_ARTICLE,0);
  SetProp( P_GENDER,0);
  AddId( "lupe" );
  user="*";
  stack=({});
  commands=({});
  functions=({});
  ncmds=0;
  add("Dest");
  add("clnof");
  add("cln");
  add("clr");
  add("copy_ldfied");
  add("creat");
  add("dest");
  add("dinfo");
  add("disco");
  add("dump_lists");
  add("dup");
  add("env");
  add("here");
  add("info");
  add("inv");
  add("lv");
  add("make");
  add("me");
  add("minfo");
  add("new");
  add("norec");
  add("ob");
  add("over");
  add("pl");
  add("rec");
  add("result");
  // add("rusage");
  add("scan");
  add("stat");
  add("stk");
  add("swap");
  add("swho");
  add("vars");
  add2("#","lock");
  add2(".","sel");
  add2("/","file");
  add2("<","readvar");
  add2("=","dump");
  add2(">","writevar");
  add2("@","pick");
  add2("[","call");
  add2("_mo","_mv");
  add2("_mov","_mv");
  add2("_move","_mv");
  add2("_mv","_mv");
  add2("call_out","callout");
  add2("debug_info", "db_info");
  add2("desc","toggle_short");
  add2("dump","dumplists");
  add2("heart_beat","heartbeat");
  add2("idle","idle");
  add2("inherit_list","inheritlist");
  add2("move","mv");
  add2("mov","mv");
  add2("mo","mv");
  add2("pop","xpop");
  add2("push","xpush");
  add2("renew","renew_player");
  add2("sc","scan");
  add2("~","file2");
  maxverb=ncmds;
  vararea=allocate(MAXVARS);
  query_list =
    ({
      "VALUE","-value","LEVEL","-level","IDS","-ids",
      "WEAPON CLASS","-wc","ARMOUR CLASS","-ac",
      "WEIGHT","-weight","TYPE","query_type",
      "UID","-uid","EUID","-euid"
    });
}

int _query_autoloadobj()
{
  return 1;
}

void _set_autoloadobj()
{
  call_out("_load_profile",0);
}

void _load_profile()
{
  object profile;
  string pfile;
  
  if (geteuid() && environment() && geteuid(environment())==geteuid() &&
      interactive(environment()))
    if (file_size(pfile="/players/"+geteuid()+"/.profile.c")>0)
      if (pfile=catch(call_other(pfile,"setup",environment())))
	printf("Error when loading profile: %O\n",pfile);
}

varargs void init(object origin)
{
  int i,ch;
  
  ::init(origin);
  if (environment()!=this_player()) return;
//  if (!IS_LEARNER(this_player())) return;
  if (!IS_LEARNER(this_player())) return destruct(this_object());
  
  add_action("cmdline","",1);
}

int cmdline(string str)
{
  string verb;
  int i,ret;
  
  verb=query_verb();
  if (!verb) return 0;
  switch (verb)
  {
    case "erzaehl": return tell(str);
  }
  str=({string})PL->_unparsed_args();
  for (i=0;i<maxverb;i++)
    if (commands[i]==verb[0..sizeof(commands[i])-1])
      if (ret=evalcmd(str))
          return ret;

  return(0); // non-void function, Zesstra
}

static int tell(string str)
{
  string *tmp;
  object who,sn;
  int ret;

  if (!IS_ARCH(this_interactive())) return 0;
  if (!(str=({string})this_interactive()->_unparsed_args())) return 0;
  if (sizeof(tmp=old_explode(str," "))<2) return 0;
  if (!(who=find_player(tmp[0]))) return 0;
  if (!(sn=query_snoop(who))) return 0;
  if (query_wiz_grp(this_interactive())<=query_wiz_grp(sn) ||
      query_wiz_grp(this_interactive())<=query_wiz_grp(who)) return 0;
  snoop(sn,0);
  ret=({int})this_interactive()->_erzaehle(str);
  snoop(sn,who);
  return ret;
}

int set_user(string str)
{
  string who;
  if (!str) return 0;
  if (str=="no access")
  {
    user="*";
    move_object(this_object(),environment());
    write("Ok.\n");
    return 1;
  }
  if (sscanf(str,"access to %s",who)==1)
  {
    object pl;
    pl=find_player(who);
    if (!pl)
      write("No such player.\n");
    else
    {
      user = who;
      write("Ok.\n");
      move_object(this_object(),pl);
      tell_object(pl,"Du darfst nun durch die magische Lupe schauen.\n");
    }
    return 1;
  }
  return 0;
}

string strip(string str)
{
  return trim(str,TRIM_BOTH);
}

int arglen;

string getarg(string args)
{
  string arg;
  string rest;
  if (sscanf(args,"\"%s\"%s",arg,rest)==2 ||
      sscanf(args,"\'%s\'%s",arg,rest)==2 ||
      sscanf(args,"|%s|%s",arg,rest)==2)
  {
    if (arg=="")
      arglen=2;
    else
      arglen=sizeof(arg)+2;
    return arg;
  }
  if (sscanf(args,"%s %s",arg,rest)==2)
    args=arg;
  if (sscanf(args,"%s.%s",arg,rest)==2)
    args=arg;
  if (sscanf(args,"%s[%s",arg,rest)==2)
    args=arg;
  if (sscanf(args,"%s]%s",arg,rest)==2)
    args=arg;
  if (args=="")
    arglen=0;
  else
    arglen=sizeof(args);
  return args;
}

string getrest(string str)
{
  if (arglen==0)
    return str;
  if (arglen==sizeof(str))
    return "";
  return strip(str[arglen..sizeof(str)-1]);
}

int interactiveMode(string str)
{
  if (str)
    return eval(str);
  stk("");
  write("'.' to exit.\n");
  write("? ");
  input_to("more");
  return 1;
}

void more(string str)
{
  string cmd;
  if (str==".") return;
  if (sscanf(str,"!%s",cmd)==1)
    command(cmd,this_player());
  else
  {
    eval(str);
    stk("");
  }
  write("? ");
  input_to("more");
}

int evalcmd(string str)
{
  string verb;
  if (!IS_LEARNING(this_player())) return 0;
  verb=query_verb();
  if (verb=="?")
    verb="";
  if (str)
    str=verb+" "+str;
  else
    str=verb;
  return eval(str);
}

int eval(string str)
{
  int i,flag,old_sp,first;
  mixed *old_stack;
  string arg,tmp;
  err=0;
  first=1;
  while (str!="")
  {
    flag=0;
    str=strip(str);
    if (sscanf(str,"#%s",arg)==1)
    {
      old_stack=stack[0..<1];
      str=arg;
    }
    else
      old_stack=0;
    str=strip(str);
    if (str=="")
      break;
    for (i=0;i<ncmds;i++)
    {
      if (sscanf(str,commands[i]+"%s",arg)==1)
      {
	if (arg!="" && str[0]>='a' && str[0]<='z' &&
	    arg[0]>='a' && arg[0]<='z')
	{
	  if (first)
	    return 0;
	  else
	  {
	    printf("Couldn't parse: %O.\n",str);
	    return 1;
	  }
	}
	arg=strip(arg);
	str=call_other(this_object(),functions[i],arg);
	first=0;
	if (old_stack)
	{
	  stack=old_stack;
	  old_stack=0;
	}
	if (stringp(err))
	{
	  if (sscanf(err,"%s\n",tmp)==1)
	    err = tmp;
	  notify_fail(sprintf("ERROR: %O.\n",err));
	  return 0;
	}
	flag=1;
	break;
      }
    }
    if (!flag)
    {
      notify_fail(sprintf("Couldn't parse: %O.\n",str));
      return 0;
    }
  }
  return 1;
}

int push(object ob)
{
  stack+=({ob});
  if (sizeof(stack)>MAXSTACK)
    stack=stack[1..MAXSTACK];
  return 1;
}

mixed pop()
{
  object tmp;
  if (!sizeof(stack))
  {
    err="stack underflow";
    tmp=this_object();
    return 0;
  }
  tmp=stack[sizeof(stack)-1];
  stack=stack[0..<2];
  if (!tmp)
    err="operating on destructed object";
  return tmp;
}

mixed xpop(string arg)
{
  if (!pop())
    err=0;
  return arg;
}

mixed toggle_short(string arg)
{
  hide_short = !hide_short;
  if (hide_short)
    write("Short descriptions off.\n");
  else
    write("Short descriptions on.\n");
  return arg;
}

mixed pl(string arg)
{
  string who,rest;
  string|object p;
  who=getarg(arg);
  rest=getrest(arg);
  if (err) return 0;
  p=match_living(who,1);
  if (!stringp(p))
  {
    if (!p=find_netdead(who))
      err="player "+who+" not found";
    else 
      push(p);
  }
  else
    push(find_player(p));
  return rest;
}

mixed lv(string arg)
{
  string who,rest;
  object p;
  who=getarg(arg);
  rest=getrest(arg);
  if (err) return 0;
  p=find_living(who);
  if (!p)
    err="living object "+who+" not found";
  else
    push(p);
  return rest;
}

string me(string arg)
{
  push(this_player());
  return arg;
}

string make_path(string path)
{
  // Pfadexpansion fuer Nutzer des Tools
  return normalize_path(path, getuid( RPL || PL ), 1);
}

string new(string arg)
{
  string what,rest,file;
  object ob;
  what=getarg(arg);
  rest=getrest(arg);
  file=make_path(what);
  err=catch(ob=clone_object(file));
  if (!err)
  {
    push(ob);
    ({int})ob->move(this_player(),M_NOCHECK);
    write("Created "+desc(ob)+".\n");
  }
  else
    err = "unable to create object, cause : "+err;
  return rest;
}

static string creat(string arg)
{
  string what,rest,file;
  object ob;
  what=getarg(arg);
  rest=getrest(arg);
  file=make_path(what);
  err=catch(ob=clone_object(file));
  if (!err)
  {
    push(ob);
    write("Created "+desc(ob)+".\n");
  }
  else
    err = "unable to create object, cause : "+err;
  return rest;
}

string xpush(string arg)
{
  string rest,what;
  object ob;

  what=getarg(arg);
  rest=getrest(arg);
  ob = find_object(what);
  if (!ob)
    err="Object "+what+" not found!\n";
  else
    push(ob);
  return rest;
}

static string ob(string arg)
{
  string what,rest,file,tmp;
  object ob;
  what=getarg(arg);
  rest=getrest(arg);
  file=make_path(what);
{
  ob=find_object(file);
  if (!ob)
  {
    tmp = catch(call_other(file,"??"));
    if (!err)
      ob = find_object(file);
  }
}
if (!ob)
{
  err="object "+file+" not found";
  if (tmp)
    err += "("+tmp+")";
}
else
push(ob);
return rest;
}

string file(string arg)
{
  return ob("/"+arg);
}

string file2(string arg)
{
  return ob("~"+arg);
}

string sel(string arg)
{
  string rest;mixed what;
  object ob,p;
  ob=pop();
  if (err) return arg;
  if (sscanf(arg,"%d%s",what,rest)==2)
  {
    if (what<=0)
    {
      err="negative index";
      push(ob);
      return arg;
    }
    what--;
    p=first_inventory(ob);
    while (p && what)
    {
      p=next_inventory(p);
      what--;
    }
    if (!p)
    {
      err="index to large";
      push(ob);
      return arg;
    }
    push(p);
    return rest;
  }
  what=getarg(arg);
  rest=getrest(arg);
  p=present(what,ob);
  if (p)
    push(p);
  else
  {
    push(ob);
    err=what+" not present in "+desc(ob);
  }
  return rest;
}

string here(string arg)
{
  push(environment(this_player()));
  return arg;
}

string env(string arg)
{
  object ob;
  ob=pop();
  if (!err)
  {
    if (!environment(ob))
      err=desc(ob)+" has no environment";
    else
      push(environment(ob));
  }
  return arg;
}

string dup(string arg)
{
  object tos;
  tos=pop();
  if (!err)
  {
    push(tos);
    push(tos);
  }
  return arg;
}

string swap(string arg)
{
  object tos;
  int sts;

  if ((sts=sizeof(stack))<2)
  {
    err="stack underflow";
    return arg;
  }
  tos=stack[sts-1];
  stack[sts-1]=stack[sts-2];
  stack[sts-2]=tos;
  return arg;
}

string over(string arg)
{
  object ob;
  if (sizeof(stack)<2)
  {
    err="stack underflow";
    return arg;
  }
  push(stack[sizeof(stack)-2]);
  return arg;
}

string pick(string arg)
{
  string rest;
  int no;
  if (sscanf(arg,"%d%s",no,rest)!=2 || no<0 || no>=sizeof(stack))
  {
    err="stack size exceeded";
    return arg;
  }
  else
    push(stack[sizeof(stack)-no-1]);
  return rest;
}

string string_desc(string str)
{
  string out;
  out = implode(old_explode(str,"\\"),"\\\\");
  out = implode(old_explode(out,"\n"),"\\n");
  out = implode(old_explode(out,"\""),"\\\"");
  return "\""+out+"\"";
}

mixed rec_desc(mixed ob)
{
  if (intp(ob))
    return ""+ob;
  if (stringp(ob))
    return string_desc(ob);
  if (objectp(ob))
    return "OBJ("+object_name(ob)+")";
  if (!pointerp(ob))
    return sprintf("%O",ob);
  return "({ "+implode(map(ob,"rec_desc",this_object()),", ")+" })";
}

string array_desc(mixed arr)
{
  string str,line,res;
  mixed tmp;
  int i,j;
  str=rec_desc(arr);
  if (sizeof(str)<=MAXLINELEN-4)
    return "--> "+str+"\n";
  tmp=old_explode(str," ");
  res="";
  lines=0;
  i=1;
  line="--> "+tmp[0]+" ";
  for (;;)
  {
    while (i<sizeof(tmp) && sizeof(line)+sizeof(tmp[i]+1)<=MAXLINELEN-1)
    {
      line+=tmp[i]+" ";
      i++;
    }
    if (sizeof(line)==0)
    {
      line=tmp[i]+" ";
      i++;
    }
    if (i<sizeof(tmp))
      line+="|\n";
    else
      line+="\n";
    res+=line;
    lines++;
    if (lines>=MAXLINES)
      return res+"*** TRUNCATED ***\n";
    if (i>=sizeof(tmp))
      return res;
    line="";
  }
  return(0); // non-void, Zesstra (never reached)
}

string desc(object ob)
{
  if (!ob)
    return "<destructed object>";
  if (!objectp(ob))
    return "<corrupted stack entry>";
  if (query_once_interactive(ob))
    return object_name(ob)+" "+capitalize(geteuid(ob));
  if (!hide_short && ({string})ob->short())
    return object_name(ob)+" "+({string})ob->name();
  else
    return object_name(ob);
}

string stk(string arg)
{
  int i,sts;
  if (!(sts=sizeof(stack)))
    write ("<empty stack>\n");
  else
    for (i=1;i<=sts;i++)
    {
      write("@"+(i-1)+": "+desc(stack[sts-i])+"\n");
    }
  return arg;
}

string clr(string arg)
{
  stack=({});
  return arg;
}

string dump(string arg)
{
  object ob;
  string s;
  ob=pop();
  if (err) return arg;
  push(ob);
  write("FILENAME: "+object_name(ob)+" ");
  if (!hide_short && (({string})s=ob->short()))
    write(" SHORT: "+({string})ob->name());
  write("\n");
  return arg;
}

string info(string arg)
{
  object ob;
  mixed s;
  int i;
  ob=pop();
  if (err) return arg;
  write("FILENAME: "+object_name(ob)+" ");
  if (s=({string})ob->short())
    write(" SHORT: "+({string})ob->name());
  write("\n");
  if (getuid(ob))
    write("CREATOR: "+getuid(ob)+"\n");
  if (interactive(ob) && (s=query_ip_number(ob)))
  {
    write("IP-NUMBER: "+s+" IP-NAME: "+query_ip_name(ob)+" IDLE: "
	  + query_idle(ob)+"\n");
  }
  if (s=query_snoop(ob))
    write("SNOOPED BY: "+({string})s->query_real_name()+"\n");
  s="";
  if (living(ob))
    s +="living ";
  if (({int})ob->query_npc())
    s+="npc ";
  if (({string})ob->query_gender_string())
    s+=({string})ob->query_gender_string();
  if (s!="")
    write("FLAGS: "+s+"\n");
  //  write("LONG:\n");
  //  if (stringp(s=({string})ob->long()))
  //    write(s);
  //  write("\n");
  for (i=0;i<sizeof(query_list);i+=2)
  {
    if (query_list[i+1][0]=='-')
      s=({string})ob->QueryProp(query_list[i+1][1..]);
    else
      s=({string})call_other(ob,query_list[i+1]);
    if (s)
    {
      printf("%s: %O\n",query_list[i],s);
    }
  }
  return arg;
}

string filler(int n)
{
  string s;
  if (!recursive) return ": ";
  s=": ";
  while (++n<MAXDEPTH)
    s="  "+s;
  return s;
}

void listinv(object ob,int depth,string prefix)
{
  int i;
  object p;
  if (depth<MAXDEPTH)
  {
    p=first_inventory(ob);
    i=1;
    if (p)
    {
      while (p)
      {
	if (lines>lastline) return;
	if (lines>=firstline)
	  write(prefix+"."+i+filler(depth)+desc(p)+"\n");
	lines++;
	if (lines==lastline+1 && next_inventory(p))
	  write("*** TRUNCATED ***\n");
	if (recursive)
	  listinv(p,depth+1,prefix+"."+i);
	i++;
	p=next_inventory(p);
      }
    }
    else
      if (!depth)
	write("<empty inventory>\n");
  }
}

string inv(string arg)
{
  object ob;
  string rest;
  int tmp;
  ob=pop();
  lines=1;
  firstline=1;
  lastline=MAXLINES;
  if (!err)
  {
    if (sscanf(arg,":%d%s",tmp,rest)==2)
    {
      firstline=tmp;
      lastline=tmp+MAXLINES-1;
      arg = rest;
      if (sscanf(arg,":%d%s",tmp,rest)==2)
      {
	lastline=tmp;
	if (lastline<firstline)
	  err = "first line > last line";
	arg=rest;
      }
    }
    push(ob);
    listinv(ob,0,"");
  }
  recursive=0;
  return arg;
}

object call_result;

string call(string arg)
{
  string func,args;
  int temp,i;
  string rest,tmp;

  object ob;
  ob=pop();
  if (err) return arg;
  push(ob);
  func=getarg(arg);
  args=getrest(arg);
  if (err) return args;
  argv=({});
  i=0;
  while (1)
  {
    args=strip(args);
    if (sscanf(args,"]%s",rest))
      break;
    if (sscanf(args,"%d%s",tmp,rest)==2)
    {
      args=rest;
      argv+=({tmp});
      continue;
    }
    if (sscanf(args,"\"%s\"%s",tmp,rest)==2 ||
	sscanf(args,"\'%s\'%s",tmp,rest)==2 ||
	sscanf(args,"|%s|%s",tmp,rest)==2)
    {
      args=rest;
      argv+=({tmp});
      continue;
    }
    if (sscanf(args,"@%d%s",temp,rest)==2)
    {
      if (temp<0 || temp>=sizeof(stack))
      {
	err="stackindex out of range";
	return args;
      }
      argv+=({stack[sizeof(stack)-temp-1]});
      args=rest;
      continue;
    }
    tmp=getarg(args);
    rest=getrest(args);
    argv+=({tmp});
    if (tmp!="")
    {
      args=rest;
      continue;
    }
    err="bad argument to []";
    return args;
  }
  if (sscanf(args,"]%s",rest)!=1)
  {
    err="too many or unterminated argument(s)";
    return args;
  }
  call_result=apply(#'call_other,ob,func,argv);
  //'
  //  if (objectp(call_result))
  //    write("--> "+desc(call_result)+"\n");
  //  else if (pointerp(call_result))
  //    write(array_desc(call_result));
  //  else
  //    write("--> "+call_result+"\n");
  printf("--> %O\n",call_result);
  pop();
  argv=({});
  return rest;
}

string result(string arg)
{
  if (objectp(call_result))
    push(call_result);
  else
    err="call returned no object";
  return arg;
}

int destroyable(object ob)
{
  if (!ob)
    return 0;
  if (query_once_interactive(ob))
    return 0;
  if (ob==this_object())
    return 0;
  return 1;
}

string cln(string arg)
{
  object ob;
  ob=pop();
  if (!err)
  {
    clean(ob);
    write(desc(ob)+" cleaned up.\n");
  }
  recursive=0;
  return arg;
}

string clnof(string arg)
{
  object ob;
  int recsave;
  string name,rest;

  write("ClnOf");
  recsave=recursive;
  recursive=0;
  ob=pop();
  if (err) return arg;
  name=getarg(arg);
  rest=getrest(arg);
  if (err) return arg;
  recursive=recsave;
  cleanof(name,ob);
  recursive=0;
  return rest;
}

void Remove(object ob,int a)
{
  if (!objectp(ob)) return;
  if (!a)
  {
    printf("Removing %O",ob);
    if (!hide_short) printf(" %O",({string})ob->name());
  }
  catch(({int})ob->remove());
  if (ob)
  {
    if (!a) printf(" HARD");
    destruct(ob);
  }
  write("\n");
}

void clean(object ob)
{
  object p,p2;
  p=first_inventory(ob);
  while (destroyable(p))
  {
    if (recursive) clean(p);
    Remove(p,0);
    p=first_inventory(ob);
  }
  while (p)
  {
    p2=next_inventory(p);
    if (destroyable(p2))
    {
      if (recursive) clean(p2);
      Remove(p2,0);
    }
    else
      p=p2;
  }
}

 void cleanof(string str,object ob)
{
  object p,p2;
  p=first_inventory(ob);
  while (p && ({int})p->id(str) && destroyable(p))
  {
    if (recursive) clean(p);
    Remove(p,0);
    p=first_inventory(ob);
  }
  while (p)
  {
    p2=next_inventory(p);
    if (p2 && ({int})p2->id(str) && destroyable(p2))
    {
      if (recursive) clean(p2);
      Remove(p2,0);
    }
    else
      p=p2;
  }
}

string dest(string arg)
{
  object ob;
  ob=pop();
  if (err) return arg;
  if (!destroyable(ob))
  {
    err=desc(ob)+" must not be destroyed";
    return arg;
  }
  Remove(ob,0);
  return arg;
}

mixed disco(string arg)
{
  object ob;

  ob=pop();
  if (err) return arg;
  if (!interactive(ob))
  {
    err=desc(ob)+" is not interactive";
    return 1;
  }
  remove_interactive(ob);
  return arg;
}

string Dest(string arg)
{
  object ob;
  ob=pop();
  if (err) return arg;
  if (!destroyable(ob))
  {
    err=desc(ob)+" must not be destroyed";
    return arg;
  }
  destruct( ob );
  return arg;
}

string mv(string arg)
{
  object from,to;
  to=pop();
  if (err) return arg;
  from=pop();
  if (err) return arg;
  ({int})from->move(to,M_NOCHECK);
  write("Bewege "+desc(from)+" nach "+desc(to)+".\n");
  return arg;
}

string _mv(string arg)
{
  object from,to;
  to=pop();
  if (err) return arg;
  from=pop();
  if (err) return arg;
  __set_environment(from,to);
  write("Bewege "+desc(from)+" nach "+desc(to)+".\n");
  return arg;
}

string db_info(string arg)
{
  object ob;

  ob=pop();
  if (err) return arg;
  debug_info(0,ob);
  debug_info(1,ob);
  return arg;
}

string inheritlist(string arg)
{
  object ob;
  int i;
  string *inherited;

  ob=pop();
  if (err) return arg;
  inherited=inherit_list(ob);
  write(ob);write(" inherits:\n");
  for (i=0;i<sizeof(inherited);i++)
    write(inherited[i]+"\n");
  return arg;
}

mixed get_callout()
{
  mixed *calls,ret;
  string tmp;
  int i,j;

  calls=call_out_info();
  ret=({});
  if (!pointerp(calls) || !sizeof(calls)) 
    return 0;
  for (i=0;i<sizeof(calls);i++)
  {
    if (pointerp(calls[i]))
    {
      tmp="";
			if (sizeof(calls[i])>3)
	      tmp+=sprintf("%-50O %-16O",calls[i][0],calls[i][1])+sprintf(" %-6O %-3O\n",calls[i][2],calls[i][3]);
			else 
				tmp+=sprintf(" *** %O\n",calls[i]);
    }
    ret+=({tmp});
  }
  return ret;
}

mixed get_heartbeat()
{
  mixed *obj;
  string *ret;
  int i;

  obj=heart_beat_info();
  ret=({});
  if (!pointerp(obj) || sizeof(obj)==0) return 0;
  for (i=0;i<sizeof(obj);i++)
    ret+=({sprintf("%O in %O\n",obj[i],environment(obj[i]))});
  return ret;
}

string make(string arg)
{
  object *list, ob, env;
  string file,temp,dummy;
  int i,cloned;
 
  ob=pop();
  if (err) return arg;
  if (!destroyable(ob))
  {
    err="can't update "+desc(ob);
    return arg;
  }
  env=environment(ob);
  file=object_name(ob);
  write("Updating "+object_name(ob)+"...\n");
  if (sscanf(file,"%s#%s",temp,dummy)==2)
  {
    file=temp;
    cloned=1;
  }
  else
    cloned=0;
  list=all_inventory(ob);
  for (i=sizeof(list)-1;i>=0;i--)
    if (list[i] && query_once_interactive(list[i]))
    {
      ({int})list[i]->move("room/void",M_TPORT | M_SILENT | M_NO_SHOW | M_NOCHECK);
    } else
      list[i]=0;
  list-=({0});
  
  if (ob)
  {
    Remove(ob,1);
  }
  if (cloned)
  {
    if (ob=find_object(file))
    {
      Remove(ob,1);
    }
    err=catch(ob=clone_object(file));
    if (!err)
      ({int})ob->move(env,M_TPORT | M_SILENT | M_NO_SHOW | M_NOCHECK);
  }
  else
  {
    err=catch(call_other(file,"???"));
    if (!err)
      ob=find_object(file);
    else
      ob=0;
  }
  if (!ob)
  {
    write("Error in loaded object. Staying in void ...\n");
    return arg;
  }
  for (i=sizeof(list)-1;i>=0;i--)
    if (list[i])
      ({int})list[i]->move(ob,M_TPORT | M_SILENT | M_NO_SHOW | M_NOCHECK);
  return arg;
}

string rec(string arg)
{
  recursive=1;
  return arg;
}

string norec(string arg)
{
  recursive=0;
  return arg;
}

string readvar(string arg)
{
  string rest;
  int no;
  if (sscanf(arg,"%d%s",no,rest)!=2 || no<0 || no>=MAXVARS)
  {
    err="illegal var number";
    return arg;
  }
  if (vararea[no])
    push(vararea[no]);
  else
    err="var #"+no+" is empty";
  return rest;
}

string writevar(string arg)
{
  string rest;
  int no;
  object ob;
  if (sscanf(arg,"%d%s",no,rest)!=2 || no<0 || no>=MAXVARS)
  {
    err="illegal var number";
    return arg;
  }
  ob=pop();
  if (err) return rest;
  vararea[no]=ob;
  return rest;
}

string vars(string arg)
{
  int i;
  for (i=0;i<MAXVARS;i++)
  {
    if (vararea[i])
      write("<"+i+": "+desc(vararea[i])+"\n");
  }
  return arg;
}

void vanish()
{
 // RemoveAutoload();
  destruct( this_object() );
}

mixed rusage(string arg)
{
  mixed *resusage;
  int i,j;
/*
  resusage=({mixed *})efun::rusage();
  for (i=0;i<18;i++){
    write(align(({"User time","System time","Max res set size",
		  "Page reclaims","Page faults",
		  "Unshared stack size",
		  "Shared text size","Unshared data size",
		  "System swaps",
		  "Block input operations","Block output operations",
		  "Messages sent","Messages received","Signals received",
		  "Voluntary context switches","Involuntary context switches",
		  "Total internet packets","Total internet bytes"})[i],
		40)+": "+resusage[i]+"\n");
  }
  return arg;
  */
  return ({});
}

string align(string s,int x){
  return (s+"                                          ")[0..x-1];
}

static string swho(string arg)
{
  object *userlist, snooper, found;mixed active;
  int i,j,done;

  if (geteuid(this_interactive())!=geteuid()) return arg;
  userlist=users();
  active=({});
  for (i=sizeof(userlist)-1;i>=0;i--)
    if (snooper=query_snoop(userlist[i]))
    {
      if (member(active,snooper)==-1)
	active+=({snooper});
      if (member(active,userlist[i])==-1)
	active+=({userlist[i]});
    }
  if (!sizeof(active))
  {
    printf("Keine aktiven Snoops.\n");
    return arg;
  }
  for (i=sizeof(active)-1;i>=0;i--)
    active[i]=({active[i]});
  for (i=sizeof(active)-1;i>=0;i--)
    if (pointerp(active[i])&&snooper=query_snoop(active[i][0]))
    {
      done=0;
      for (j=sizeof(active)-1;j>=0 && !done;j--)
	if (pointerp(active[j]) && active[j][sizeof(active[j])-1]==snooper)
	{
	  active[j]+=active[i];
	  active[i]=0;
	  done=1;
	}
    }
  active-=({0});
  for (i=0;i<sizeof(active);i++)
  {
    for (j=0;j<sizeof(active[i]);j++)
      printf("%s%s",(j==0?"":" -> "),capitalize(getuid(active[i][j])));
    printf("\n");
  }
  return arg;
}

string timef(int sec)
{
  string s;

  s="";
  if (sec>=86400)
    s+=sprintf("%d d, ",sec/86400);
  if (sec>3600)
    s+=sprintf("%d h, ",(sec/3600)%24);
  if (sec>60)
    s+=sprintf("%d m, ",(sec/60)%60);
  return s+sprintf("%d s",sec%60);
}

string idle(string arg)
{
  object ob;
  int i;

  ob=pop();
  if (err) return arg;
  write(capitalize(({string})ob->name(WER))+" ");
  if (!query_once_interactive(ob))
  {
    write("ist kein echter Spieler.\n");
    return arg;
  }
  if (!query_ip_number(ob))
  {
    write("ist netztot.\n");
    return arg;
  }
  printf("ist idle seit %d Sekunden",i=query_idle(ob));
  if (i>60)
    printf(" (%s)\n",timef(i));
  else
    write("\n");
  return arg;
}

string stat(string arg)
{
  object ob;
  mapping quests;
  mixed stats, arr, tmp,tmp2, list;
  string titel, level, stat_str,weapon,armour;
  int pl;
  int i;
  
  ob=pop();
  if (err)
    return arg;
  
  titel=({string})ob->QueryProp(P_TITLE);
  if (!(pl=query_once_interactive(ob)))
    level="Monster="+old_explode(object_name(ob),"#")[0];
  else
    if (IS_GOD(ob))
      level="Mud-Gott";
    else if (IS_ARCH(ob))
      level="Erzmagier";
    else if (IS_ELDER(ob))
      level="Weiser";
    else if (IS_LORD(ob))
      level="Regionsmagier";
    else if (IS_DOMAINMEMBER(ob))
      level="Regionsmitglied";
    else if (IS_WIZARD(ob))
      level="Magier";
    else if (IS_LEARNER(ob))
      level="Lehrling";
    else if (IS_SEER(ob))
      level="Seher";
    else level="Spieler";
  if (IS_DOMAINMEMBER(ob))
    for (tmp=({string*})"secure/master"->get_domain_homes(geteuid(ob));
	 sizeof(tmp);tmp=tmp[1..])
      level+="-"+capitalize(tmp[0]);
  if (pl)
  {
    if (!interactive(ob))
      level+=", netztot";
    else
      if (query_idle(ob)>600)
	level+=", idle";
    if (({int})ob->QueryProp(P_GHOST))
      level+=", tot";
    if (({int})ob->QueryProp(P_INVIS))
      level+=", unsichtbar";
    if (({int})ob->QueryProp(P_FROG))
      level+=", gruen und glitschig";
    if (({int|string})ob->QueryProp(P_TESTPLAYER))
      level+=", Testspieler";
  }
  tmp=({string})ob->QueryProp(P_PRESAY);
  if (tmp && tmp!="")
    tmp=tmp+" ";
  else
    tmp="";
  tmp2=({string})ob->QueryProp(P_RACE);
  if(!tmp2)
    tmp2="Dingsda";
  arr=({string})ob->QueryProp(P_NAME);
  if (pointerp(arr)) arr=arr[0];
  printf("%s%s %s (%s)[%s].\n\n",tmp||"",arr||"",titel||"",
	 tmp2||"??",level||"??");
  if (pl)
    printf("        Alter : %s.%s\n",
	   timef(2*({int})ob->QueryProp(P_AGE)),
	   (tmp=({string})ob->QueryProp(P_MARRIED))?
	   ("Verheiratet mit "+capitalize(tmp)+"."):"");
  else
    printf("    Aggressiv : %4s          Gespraechig : %d%%\n",
	   ({int|float|mapping})ob->QueryProp(P_AGGRESSIVE)? "Ja" : "Nein", 
	   ({int})ob->QueryProp(P_CHAT_CHANCE)) ;
  printf(" Lebenspunkte : [%4d/%4d]   Magiepunkte : [%4d/%4d]   " +
	 "Erfahrung : %d\n",
	 ({int})ob->QueryProp(P_HP), ({int})ob->QueryProp(P_MAX_HP), 
	 ({int})ob->QueryProp(P_SP), ({int})ob->QueryProp(P_MAX_SP), 
	 ({int})ob->QueryProp(P_XP));
  printf("      Nahrung : [%3d/%d]    Fluessigkeit : [%3d/%d]       " +
	 "Alkohol : [%3d/%d]\n",
	 ({int})ob->QueryProp(P_FOOD), ({int})ob->QueryProp(P_MAX_FOOD),
	 ({int})ob->QueryProp(P_DRINK), ({int})ob->QueryProp(P_MAX_DRINK),
	 ({int})ob->QueryProp(P_ALCOHOL), ({int})ob->QueryProp(P_MAX_ALCOHOL)) ;
  switch(({int})ob->QueryProp(P_GENDER))  {
    case FEMALE : tmp2 = "weiblich " ; break ;
    case MALE   : tmp2 = "maennlich" ; break ;
    default     : tmp2 = "boingisch" ; break ;
  }
  printf("   Geschlecht : %s       Charakter : %-5d             Stufe : %-3d\n",
	 tmp2, ({int})ob->QueryProp(P_ALIGN), ({int})ob->QueryProp(P_LEVEL)) ;
  stats = ({mapping})ob->QueryProp(P_ATTRIBUTES) ;
	if (!mappingp(stats)) stats=([]);
  tmp  = m_indices(stats); tmp2 = m_values(stats); stat_str = "" ;
  for(; sizeof(tmp); tmp=tmp[1..],tmp2=tmp2[1..])
    stat_str += (tmp[ 0 ] + "[" + tmp2[ 0 ] + "] ") ;
  
  if(stat_str == "")
    stat_str = "Keine" ;
  else
    stat_str = stat_str[0..<2];
  
  printf("         Geld : %-9d           Stati : %s\n\n", ({int})ob->QueryMoney(),
	 stat_str) ;
  
  weapon = "Keine" ; armour = "" ;
  for(tmp=all_inventory(ob); sizeof(tmp); tmp=tmp[1..])
  {
    if(({object})tmp[ 0 ]->QueryProp(P_WIELDED)) // gezueckte Waffe
      weapon = (tmp[ 0 ]->name(WER)) + " (" +
         old_explode(object_name(tmp[ 0 ]),"#")[0] + ")[" +
         ({int})tmp[ 0 ]->QueryProp(P_WC) + "]" ;

    if(({object})tmp[ 0 ]->QueryProp(P_WORN))   // getragene Ruestung
      armour += (({string})tmp[ 0 ]->name(WER)) + "[" +
          ({int})tmp[ 0 ]->QueryProp(P_AC) + "]" +
    ", " ;
  }

  if(armour == "")
    armour = "Keine" ;
  else
  {
    tmp = old_explode(break_string(armour[0..sizeof(armour) - 3],
			       63), "\n") ;
    armour = tmp[ 0 ] ;
    tmp=tmp[1..];
    for (;sizeof(tmp); tmp=tmp[1..])
      armour += "\n                " + tmp[ 0 ] ;
  }
  
  printf("   Waffe(%3d) : %s\nRuestung(%3d) : %s\n",
	 ({int})ob->QueryProp(P_TOTAL_WC), weapon,
	 ({int})ob->QueryProp(P_TOTAL_AC), armour) ;
  
  list = ({mixed})ob->QueryEnemies();
  if (pointerp(list)) 
  {
    list=list[0];
    tmp2 = "" ;
    for(i=sizeof(list)-1 ; i>=0;i--)
      if (objectp(list[i]))
        tmp2 += (({string})list[ i ]->name(WER) + ", ") ;
    if(tmp2 != "")
      printf("       Feinde : %s.\n", tmp2[0..<3]);
  }
  
  // 8.Zeile : Geloeste Aufgaben
  if(pl)
  {
    printf( break_string( 
              CountUp(m_indices(({mapping})ob->QueryProp(P_QUESTS))), 
              75,
              "     Aufgaben : ",
              BS_INDENT_ONCE));
    if(((tmp2 = ({string})ob->QueryProp(P_MAILADDR)) != "none") && tmp2 &&
       (tmp2 != ""))
      tmp2 = " (" + tmp2 + ")" ;
    else
      tmp2 = "" ;
  }
  else
    tmp2 = "" ;

  if(environment(ob))
    printf("   Aufenthalt : %s%s.\n",
	   old_explode(object_name(environment(ob)),"#")[0], tmp2) ;

  return arg;
}

string scan(string arg)
{
  object ob;
  mixed tmp,tmp2,tmp3;
  int i;

  ob=pop();
  if (err) return arg;
  if (query_once_interactive(ob))
    printf("Spieler: %s, Level: %d, Wizlevel: %d\n",
	   capitalize(getuid(ob)), ({int})ob->QueryProp(P_LEVEL),
	   query_wiz_level(ob));
  else
    printf("Monster, UID: %s, EUID: %s, Level: %d\n",
	   getuid(ob), (geteuid(ob)?geteuid(ob):"0"), ({int})ob->QueryProp(P_LEVEL));
  tmp=({string})ob->short();
  if (!stringp(tmp)||!sizeof(tmp))
    tmp=sprintf("(%s %s %s %s)",({string})ob->QueryProp(P_PRESAY)+"",
		({string})ob->QueryProp(P_NAME)+"",({string})ob->QueryProp(P_TITLE)+"",
		(interactive(ob)?"":"(netztot"));
  else
    tmp=tmp[0..<3];
  printf("%s, Rasse: %s\n",tmp, ""+({string})ob->QueryProp(P_RACE));
  printf("Stats:    ");
  tmp=({mapping})ob->QueryProp(P_ATTRIBUTES);
  tmp3=({mapping})ob->QueryProp(P_ATTRIBUTES_OFFSETS);
  if (!tmp)
    printf("keine\n");
  else
  {
    tmp2=m_indices(tmp);
    for (i=0;i<sizeof(tmp2);i++)
	{
      printf("%s%s: %d",(i>0?", ":""),tmp2[i],tmp[tmp2[i]]);
	  if (tmp3[tmp2[i]])
	    printf("%+d",tmp3[tmp2[i]]);
    }
    printf("\n");
  }
  printf("Ruestung: %-6d    Waffen: %-6d      Vorsicht: %-6d   Geschlecht: ",
	 ({int})ob->QueryProp(P_TOTAL_AC),({int})ob->QueryProp(P_TOTAL_WC),
	 ({int})ob->QueryProp(P_WIMPY));
  if (!(tmp=({int})ob->QueryProp(P_GENDER)))
    printf("N\n");
  else
  {
    if (tmp==2)
      printf("F\n");
    else
      printf("M\n");
  }
  if (tmp=({string})ob->QueryProp(P_MARRIED))
    printf("Verheiratet mit %s.\n",capitalize(tmp));
  printf("Lebenspunkte: %4d [%4d], Magiepunkte: %4d [%4d], Erf: %-8d\n",
	 ({int})ob->QueryProp(P_HP), ({int})ob->QueryProp(P_MAX_HP), 
	 ({int})ob->QueryProp(P_SP), ({int})ob->QueryProp(P_MAX_SP),
	 ({int})ob->QueryProp(P_XP));
  if (living(ob))
  {
    tmp=present("geld",ob);
    if (tmp)
      tmp=({int})tmp->QueryProp(P_AMOUNT);
    printf("Traegt %6d (%6d) g. Eigengewicht %6d g. %6d Muenzen.\n",
	   ({int})ob->query_weight_contents(),({int})ob->QueryProp(P_MAX_WEIGHT),
	   ({int})ob->QueryProp(P_WEIGHT),tmp);
    if (tmp=({object})ob->SelectEnemy())
      printf("Kaempft gegen %s [%O]\n",({string})tmp->name(WEN),tmp);
  }
  printf("ENV: %s",
	 ((tmp=environment(ob))?object_name(tmp):"- fabric of space -"));
  if(query_once_interactive(ob))
  {
    printf(", EMail: %s\n", ({string})ob->QueryProp(P_MAILADDR)+"");
    tmp=({int})"/secure/master"->find_userinfo(getuid(ob));
    if (pointerp(tmp) && sizeof(tmp)>USER_DOMAIN)
    {
      tmp=tmp[USER_DOMAIN];
      if (pointerp(tmp) && sizeof(tmp))
      {
	printf("Lord in: ");
	for (tmp2=0;tmp2<sizeof(tmp);tmp2++)
	  printf("%s%s",(tmp2>0?", ":""),""+tmp[tmp2]);
	printf(".\n");
      }
    }
    tmp=({string*})"/secure/master"->get_domain_homes(getuid(ob));
    if (pointerp(tmp)&&sizeof(tmp)>0)
    {
      printf("Mitglied in: ");
      for (tmp2=0;tmp2<sizeof(tmp);tmp2++)
     	printf("%s%s",(tmp2>0?", ":""),""+tmp[tmp2]);
      printf(".\n");
    }
    printf("Quests: ");
    tmp=({mapping})ob->QueryProp(P_QUESTS);
    if (tmp==({})||!pointerp(tmp))
      printf("Keine.\n");
    else
    {
      tmp2="";
      tmp-=({({}),0});
      for (i=0; i<sizeof(tmp); i++)
	tmp2+=sprintf("%s%s",(i?", ":""),tmp[i][0]);
      tmp=break_string(tmp2,79,8);
      tmp=tmp[8..];
      printf("%s",tmp);
    }
    printf("PKills: %d ",({int})ob->QueryProp(P_KILLS));
    printf(", QuestPoints: %d (%d/%d), Alter: %s\n",({int})ob->QueryProp(P_QP),({int})ob->QueryProp(P_NEEDED_QP),({int})QM->QueryMaxQP(),timef(2*({int})ob->QueryProp(P_AGE)));
    if (interactive(ob))
    {
      printf("From: %s (%s) [%s]\n",query_ip_name(ob),query_ip_number(ob),country(query_ip_name(ob)));
      tmp=query_idle(ob);
      printf("Idle seit %d Sekunden",tmp);
      if (tmp>60)
  	printf(" (%s)",timef(tmp));
			printf(", cmd avg: %d",({int})ob->QueryProp("command_average"));
      printf(", noch %d ZT zu finden.\nGesnooped von: %s\n",
	     ((tmp=({int*})ob->QueryProp(P_POTIONROOMS))?sizeof(tmp):0),
	     ((tmp=query_snoop(ob))?capitalize(getuid(tmp)):"Niemandem"));
    }
    else
    {
      tmp=getuid(ob);
      tmp=file_time("save/"+tmp[0..0]+"/"+tmp+".o");
      tmp=time()-tmp;
      printf("Kam von: %s, vor: %d s(%s)\n",
	     ({string})ob->QueryProp(P_CALLED_FROM_IP),tmp,timef(tmp));  
    }
  }
  else
    printf("\n");
  return arg;
}

mixed dinfo(string arg)
{
  object ob;

  ob=pop();
  if (!ob)
    return 1;
  debug_info(0,ob);
  return arg;
}

mixed minfo(string arg)
{
  object ob;

  ob=pop();
  if (!ob)
    return 1;
  debug_info(1,ob);
  return arg;
}

void dump_list(mixed what)
{
  int i,s;

  if (!pointerp(what)||!(s=sizeof(what)))
    return;
  for (i=0;i<s;i++)
    write(what[i]);
}

string callout(string args)
{
  dump_list(get_callout());
  return args;
}

string heartbeat(string args)
{
  dump_list(get_heartbeat());
  return args;
}

string dumplists(string args)
{
  string filen;
  string *list;
  int i,s;

  if (!geteuid(this_object()))
    return args;
  filen="/players/"+geteuid(this_object())+"/LISTS.LUPE";
  write("Dumping to "+filen+" ... ");
  if (file_size(filen)>=0)
    rm(filen);
  write_file(filen,"OBJECT WITH ACTIVE HEART_BEAT:\n");
  list=get_heartbeat();
  if (!list || !(s=sizeof(list)))
    write_file(filen,"NONE\n");
  for (i=0;i<s;i++)
    write_file(filen,list[i]);
  write_file(filen,"\n\nRUNNING CALL_OUTS:\n");
  list=get_callout();
  if (!list || !(s=sizeof(list)))
    write_file(filen,"NONE\n");
  for (i=0;i<s;i++)
    write_file(filen,list[i]);
  write("done.\n");
  return args;
}

mixed renew_player(string arg)
{
  object ob;

  ob=pop();
  if (!ob)
    return 1;
  if (!objectp(ob)&&!interactive(ob))
  {
    err=desc(ob)+" is not an interactive player";
    return arg;
  }
  if ((err=({int})"/secure/master"->renew_player_object(ob))<0)
    err="error "+err+" when renewing "+desc(ob);
  return arg;
}

mixed copy_ldfied(string arg)
{
  object ob, new;
  mapping props;

  ob=pop();
  if (!ob)
    return 1;
  if (!objectp(ob))
  {
    err=desc(ob)+" is not an valid object";
    return arg;
  }
  new=clone_object(old_explode(object_name(ob),"#")[0]);
  props=({mapping})ob->QueryProperties();
  ({mapping})new->SetProperties(ob->QueryProperties());
  push(new);
  ({int})new->move(this_player(),M_NOCHECK);
  return arg;
}