Added public files
Roughly added all public files. Probably missed some, though.
diff --git a/obj/tools/lupe.c b/obj/tools/lupe.c
new file mode 100644
index 0000000..5d6f109
--- /dev/null
+++ b/obj/tools/lupe.c
@@ -0,0 +1,1888 @@
+// This tool was originally written by Macbeth@TUBmud
+//
+// Some changes/extensions by Jof@MorgenGrauen
+
+inherit "/std/thing";
+
+#include <language.h>
+#include <properties.h>
+#include <wizlevels.h>
+#include <moving.h>
+#include <defines.h>
+#include <questmaster.h>
+#include <userinfo.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);
+
+
+void create()
+{
+ object owner;
+ string str;
+
+ if (!clonep(ME)) 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("_goto");
+ 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);
+}
+
+void init()
+{
+ int i,ch;
+
+ ::init();
+ 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=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=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=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)
+{
+ string temp;
+ if(!str) return "";
+ while (sscanf(str," %s",temp)==1) str=temp;
+ return str;
+}
+
+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;
+ 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)
+{
+ return "secure/master"->_get_path( path, geteuid( this_player() ) );
+}
+
+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);
+ 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((string)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 && ob->short())
+ return object_name(ob)+" "+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 && (s=ob->short()))
+ write(" SHORT: "+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=ob->short())
+ write(" SHORT: "+ob->name());
+ write("\n");
+ if (getuid(ob))
+ write("CREATOR: "+getuid(ob)+"\n");
+ if (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: "+s->query_real_name()+"\n");
+ s="";
+ if (living(ob))
+ s +="living ";
+ if (ob->query_npc())
+ s+="npc ";
+ if (ob->query_gender_string())
+ s+=ob->query_gender_string();
+ if (s!="")
+ write("FLAGS: "+s+"\n");
+ // write("LONG:\n");
+ // if (stringp(s=ob->long()))
+ // write(s);
+ // write("\n");
+ for (i=0;i<sizeof(query_list);i+=2)
+ {
+ if (query_list[i+1][0]=='-')
+ s=ob->QueryProp(query_list[i+1][1..]);
+ else
+ s=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",ob->name());
+ }
+ catch(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 && p->id(str) && destroyable(p))
+ {
+ if (recursive) clean(p);
+ Remove(p,0);
+ p=first_inventory(ob);
+ }
+ while (p)
+ {
+ p2=next_inventory(p);
+ if (p2 && 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;
+ 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]))
+ {
+ 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)
+ 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])
+ 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(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=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="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 (ob->QueryProp(P_GHOST))
+ level+=", tot";
+ if (ob->QueryProp(P_INVIS))
+ level+=", unsichtbar";
+ if (ob->QueryProp(P_FROG))
+ level+=", gruen und glitschig";
+ if (ob->QueryProp(P_TESTPLAYER))
+ level+=", Testspieler";
+ }
+ tmp=ob->QueryProp(P_PRESAY);
+ if (tmp && tmp!="")
+ tmp=tmp+" ";
+ else
+ tmp="";
+ tmp2=ob->QueryProp(P_RACE);
+ if(!tmp2)
+ tmp2="Dingsda";
+ arr=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*ob->QueryProp(P_AGE)),
+ (tmp=ob->QueryProp(P_MARRIED))?
+ ("Verheiratet mit "+capitalize(tmp)+"."):"");
+ else
+ printf(" Aggressiv : %4s Gespraechig : %d%%\n",
+ ob->QueryProp(P_AGGRESSIVE)? "Ja" : "Nein",
+ ob->QueryProp(P_CHAT_CHANCE)) ;
+ printf(" Lebenspunkte : [%4d/%4d] Magiepunkte : [%4d/%4d] " +
+ "Erfahrung : %d\n",
+ ob->QueryProp(P_HP), ob->QueryProp(P_MAX_HP),
+ ob->QueryProp(P_SP), ob->QueryProp(P_MAX_SP),
+ ob->QueryProp(P_XP));
+ printf(" Nahrung : [%3d/%d] Fluessigkeit : [%3d/%d] " +
+ "Alkohol : [%3d/%d]\n",
+ ob->QueryProp(P_FOOD), ob->QueryProp(P_MAX_FOOD),
+ ob->QueryProp(P_DRINK), ob->QueryProp(P_MAX_DRINK),
+ ob->QueryProp(P_ALCOHOL), ob->QueryProp(P_MAX_ALCOHOL)) ;
+ switch(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, ob->QueryProp(P_ALIGN), ob->QueryProp(P_LEVEL)) ;
+ stats = 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", ob->QueryMoney(),
+ stat_str) ;
+
+ weapon = "Keine" ; armour = "" ;
+ for(tmp=all_inventory(ob); sizeof(tmp); tmp=tmp[1..])
+ {
+ if(tmp[ 0 ]->QueryProp(P_WIELDED)) // gezueckte Waffe
+ weapon = (tmp[ 0 ]->name(WER)) + " (" +
+ old_explode(object_name(tmp[ 0 ]),"#")[0] + ")[" +
+ tmp[ 0 ]->QueryProp(P_WC) + "]" ;
+
+ if(tmp[ 0 ]->QueryProp(P_WORN)) // getragene Ruestung
+ armour += (tmp[ 0 ]->name(WER)) + "[" +
+ 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",
+ ob->QueryProp(P_TOTAL_WC), weapon,
+ ob->QueryProp(P_TOTAL_AC), armour) ;
+
+ list = ob->QueryEnemies();
+ if (pointerp(list))
+ {
+ list=list[0];
+ tmp2 = "" ;
+ for(i=sizeof(list)-1 ; i>=0;i--)
+ if (objectp(list[i]))
+ tmp2 += (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(ob->QueryProp(P_QUESTS))),
+ 75,
+ " Aufgaben : ",
+ BS_INDENT_ONCE));
+ if(((tmp2 = 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)), 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"), ob->QueryProp(P_LEVEL));
+ tmp=ob->short();
+ if (!stringp(tmp)||!sizeof(tmp))
+ tmp=sprintf("(%s %s %s %s)",ob->QueryProp(P_PRESAY)+"",
+ ob->QueryProp(P_NAME)+"",ob->QueryProp(P_TITLE)+"",
+ (interactive(ob)?"":"(netztot"));
+ else
+ tmp=tmp[0..<3];
+ printf("%s, Rasse: %s\n",tmp, ""+ob->QueryProp(P_RACE));
+ printf("Stats: ");
+ tmp=ob->QueryProp(P_ATTRIBUTES);
+ tmp3=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: ",
+ ob->QueryProp(P_TOTAL_AC),ob->QueryProp(P_TOTAL_WC),
+ ob->QueryProp(P_WIMPY));
+ if (!(tmp=ob->QueryProp(P_GENDER)))
+ printf("N\n");
+ else
+ {
+ if (tmp==2)
+ printf("F\n");
+ else
+ printf("M\n");
+ }
+ if (tmp=ob->QueryProp(P_MARRIED))
+ printf("Verheiratet mit %s.\n",capitalize(tmp));
+ printf("Lebenspunkte: %4d [%4d], Magiepunkte: %4d [%4d], Erf: %-8d\n",
+ ob->QueryProp(P_HP), ob->QueryProp(P_MAX_HP),
+ ob->QueryProp(P_SP), ob->QueryProp(P_MAX_SP),
+ ob->QueryProp(P_XP));
+ if (living(ob))
+ {
+ tmp=present("geld",ob);
+ if (tmp)
+ tmp=tmp->QueryProp(P_AMOUNT);
+ printf("Traegt %6d (%6d) g. Eigengewicht %6d g. %6d Muenzen.\n",
+ ob->query_weight_contents(),ob->QueryProp(P_MAX_WEIGHT),
+ ob->QueryProp(P_WEIGHT),tmp);
+ if (tmp=ob->SelectEnemy())
+ printf("Kaempft gegen %s [%O]\n",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", ob->QueryProp(P_MAILADDR)+"");
+ tmp="/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="/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=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 ",ob->QueryProp(P_KILLS));
+ printf(", QuestPoints: %d (%d/%d), Alter: %s\n",ob->QueryProp(P_QP),ob->QueryProp(P_NEEDED_QP),QM->QueryMaxQP(),timef(2*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",ob->QueryProp("command_average"));
+ printf(", noch %d ZT zu finden.\nGesnooped von: %s\n",
+ ((tmp=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",
+ 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="/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=ob->QueryProperties();
+ new->SetProperties(ob->QueryProperties());
+ push(new);
+ new->move(this_player(),M_NOCHECK);
+ return arg;
+}
+