| // ---------------------------------------------------------------------- |
| // Tellerstapel, ein Stackorientiertes magiertool. |
| // Rumata 15.09.93 |
| // ---------------------------------------------------------------------- |
| #include "teller.h" |
| inherit "std/secure_thing"; |
| inherit T_CMDS; |
| inherit T_EFUN; |
| inherit "std/more"; |
| |
| #include "/secure/wizlevels.h" |
| |
| nosave mapping tcommands; |
| nosave string owner_name; |
| |
| void logaccess( string s ); |
| static void do_msg( string s, object o ); |
| static string|int parseNext( string str, mixed auxstack, string funname ); |
| static mixed nextAlpha( string s ); |
| static varargs void restore_stack( string* argv, int args ); |
| static int do_call( string fun, int mit_return ); |
| static int do_call_efun( string fun, int mit_return ); |
| static int do_lpc( string str, int mit_return ); |
| static int do_cmd( string str ); |
| int error( string s ); |
| |
| static void tAddCmd( mixed cmd ) |
| { |
| int i; |
| |
| //if (find_player("rikus")) tell_object(find_player("rikus"),sprintf("%O\n",cmd)); |
| if( !pointerp(cmd) ) |
| m_add(tcommands, cmd, cmd); |
| else |
| for( i=0; i<sizeof(cmd); i++ ) |
| m_add(tcommands, cmd[i], cmd[0]); |
| } |
| |
| void create() |
| { |
| if( IS_BLUE(ME) ) return; |
| if( !find_player(getuid()) ) return; |
| owner_name = find_player(getuid())->name(WESSEN,1); |
| |
| secure_thing::create(); |
| t_cmds::create(); |
| SetProp( P_NAME, "Tellerstapel" ); |
| SetProp( P_GENDER, MALE ); |
| AddId( ({"teller","stapel","tellerstapel"}) ); |
| SetProp( P_NODROP, "Wozu denn?\n" ); |
| SetProp( P_NEVERDROP, 1 ); |
| SetProp( P_READ_MSG, "Die Gravur besagt: 'Aus der Rumata-Manufaktur'\n" ); |
| tcommands = ([]); |
| |
| tAddCmd( "say" ); |
| tAddCmd( ({"names","nam"}) ); |
| tAddCmd( "secureinv" ); |
| tAddCmd( "logaccess" ); |
| tAddCmd( "pretty" ); |
| tAddCmd( "doprofile" ); |
| tAddCmd( ({"clear","clr"})); |
| tAddCmd( "pop" ); |
| tAddCmd( "dup" ); |
| tAddCmd( "swap" ); |
| tAddCmd( ({"evaluate","eval"}) ); |
| |
| tAddCmd( "here" ); |
| tAddCmd( "me" ); |
| |
| tAddCmd( ({"memory","mem"}) ); |
| tAddCmd( "dump" ); |
| tAddCmd( "restore" ); |
| tAddCmd( "top" ); |
| tAddCmd( "wer" ); |
| tAddCmd( ({"stack","stk"}) ); |
| tAddCmd( ({"snoopers","snoop"}) ); |
| tAddCmd( "callouts" ); |
| tAddCmd( ({"callouts_bang","callouts!"}) ); |
| tAddCmd( ({"heartbeats","beats"}) ); |
| tAddCmd( "inv" ); |
| tAddCmd( ({"rekinv","rinv"}) ); |
| tAddCmd( "scan" ); |
| tAddCmd( "if" ); |
| |
| tAddCmd( ({"array","arr"}) ); |
| tAddCmd( ({"split","spl"}) ); |
| tAddCmd( ({"player","pl"}) ); |
| tAddCmd( ({"living","lv"}) ); |
| tAddCmd( ({"object","ob"}) ); |
| |
| tAddCmd( ({"debuginfo","dinfo"}) ); |
| tAddCmd( ({"clone","cln"}) ); |
| tAddCmd( ({"update","upd"}) ); |
| tAddCmd( ({"update_bang","update!","upd!"}) ); |
| tAddCmd( ({"move","mv"}) ); |
| tAddCmd( ({"destruct","dest","des"}) ); |
| tAddCmd( ({"remove","rem"}) ); |
| tAddCmd( ({"destruct_bang","destruct!","dest!","des!","remove!","rem!"}) ); |
| tAddCmd( ({"roomupdate","rupdate","rupd","rup"}) ); |
| tAddCmd( ({"roomupdate_bang","roomupdate!","rupdate!","rupd!","rup!"}) ); |
| tAddCmd( ({"extroomupdate","rupdate*","rupd*","rup*"}) ); |
| tAddCmd( ({"extroomupdate_bang","roomupdate*!","rupdate*!","rupd*!","rup*!", |
| "rup!*" }) ); |
| tAddCmd( ({"cleanof","clnof"}) ); |
| tAddCmd( ({"cleanof_bang","cleanof!","clnof!"}) ); |
| |
| tAddCmd( "ping" ); |
| } |
| |
| void init() |
| { |
| //logaccess( "init" ); |
| ::init(); |
| if ( !IS_WIZARD(PL) || environment()!=PL ) |
| return; |
| add_action( "parse", ",", 1 ); |
| add_action( "jonglier", "jonglier", 1 ); |
| add_action( "message", "message" ); |
| add_action( "message", "msg" ); |
| } |
| |
| short() |
| { |
| logaccess( "short" ); |
| return "Ein Stapel Teller.\n"; |
| } |
| |
| id( str ) |
| { |
| logaccess( "id" ); |
| return ::id(str); |
| } |
| |
| name( casus, dem, force ) |
| { |
| logaccess( "name" ); |
| return ::name( casus, dem, force ); |
| } |
| |
| long() |
| { |
| string answer; |
| |
| answer = |
| "Du betrachtest "+owner_name+" magischen Tellerstapel. Die einzelnen Teller sind\n" |
| +"bis auf eine kleine Inschrift auf dem Boden weiss. Wenn Du hiermit\n" |
| +"jonglierst, kann ALLES passieren.\n"; |
| |
| if( getuid(PL) == getuid() ) |
| { |
| answer += |
| ( mit_say |
| ? "Die Teller sind beim Jonglieren sichtbar.\n" |
| : "Die Teller sind beim Jonglieren unsichtbar.\n" |
| ) + ( mit_namen |
| ? "Die Teller nennen die Dinge beim Namen.\n" |
| : "Die Teller nennen die Dinge beim Filenamen.\n" |
| ) + ( pretty |
| ? "Die Teller haben ein verschnoerkeltes Muster.\n" |
| : "Die Teller sind geradezu schmucklos.\n" |
| ) + ( dologaccess |
| ? "Die Teller spueren Zugriffe.\n" |
| : "" |
| ) + ( secureinv |
| ? "Die Teller bewachen Dein Inventar.\n" |
| : "" |
| ) + ( do_profile |
| ? "Die Teller werden beim Einloggen aktiv.\n" |
| : "" |
| ); |
| } |
| return answer; |
| } |
| |
| void _set_autoloadobj( mixed val ) |
| { |
| if( !pointerp(val) ) return; |
| val += ({ 0,0,0,0,0,0 }); |
| mit_namen = val[0]; |
| mit_say = val[1]; |
| set_heart_beat( secureinv = val[2] ); |
| dologaccess = val[3]; |
| pretty = val[4]; |
| do_profile = val[5]; |
| if( do_profile ) call_out( "_load_profile", 0, this_player() ); |
| } |
| |
| mixed _query_autoloadobj() |
| { |
| return ({ mit_namen, mit_say, secureinv, dologaccess, pretty, |
| do_profile }); |
| } |
| |
| void _load_profile( object pl ) |
| { |
| string pf,errmsg; |
| |
| if( geteuid() && pl && geteuid(pl)==geteuid() |
| && file_size(pf="/players/"+geteuid()+"/.profile.c")>0 |
| && (errmsg=catch(call_other(pf,"setup",pl))) |
| ) |
| printf( "Error loading profile: %O\n", errmsg ); |
| } |
| |
| void logaccess( string str ) |
| { |
| if( RPL && dologaccess && getuid()!=getuid(RPL) && find_player(getuid()) |
| && previous_object() && getuid(previous_object()) != ROOTID |
| && query_wiz_level(getuid())>=query_wiz_level(getuid(RPL)) |
| ) |
| tell_object( find_player(getuid()), "MEMO: " + str + "() von " |
| + RPL->name(WEM) + " via [" |
| + object_name(previous_object())+"].\n" |
| ); |
| if( secureinv && find_player(getuid()) && !member(heart_beat_info(),ME) ) |
| { |
| tell_object( find_player(getuid()), "MEMO: heart_beat restartet!.\n" ); |
| set_heart_beat(TRUE); |
| } |
| } |
| |
| // ---------------------------------------------------------------------- |
| // Hilfe-Funktionen |
| // ---------------------------------------------------------------------- |
| static int secure() |
| { |
| int i; |
| if( process_call() || secure_level()<query_wiz_level(RPL) ) return 0; |
| for( i=0; previous_object(i)==RPL; i++ ) |
| ; |
| return (!previous_object(i) || previous_object()==ME) |
| && getuid()==getuid(RPL) && IS_WIZARD(RPL); |
| } |
| |
| int jonglier( string str ) |
| { |
| string arg; |
| |
| logaccess( "jongliere" ); |
| if( !str || id(str) || sscanf( str, "mit %s", arg ) == 1 ) |
| { |
| if( !secure() ) |
| write( |
| "Dieser Tellerstapel ist nichts fuer Dich. Suche Dir einen eigenen.\n" |
| ); |
| else |
| write( |
| "Der Jonglierbefehl lautet \";\" oder \",\".\n" |
| + "\";hilfe <befehl>\" gibt Dir Hilfestellung.\n" |
| ); |
| return TRUE; |
| } |
| return 0; |
| } |
| |
| static int zeige_hilfe( string str ) |
| { |
| if( !stringp(str) ) str = "general"; |
| str = implode( old_explode( HELP(str), "/../" ), "/" ); |
| if( file_size(str) > 0 ) |
| { |
| More( str, 1 ); |
| return TRUE; |
| } |
| write( "Zu diesem Thema gibt es keine Hilfe.\n" ); |
| return TRUE; |
| } |
| |
| int message( string str ) |
| { |
| string pl; |
| object dest; |
| |
| if( !secure() ) return FALSE; |
| |
| if( str ) |
| { |
| if( sscanf( str, "to %s", pl ) == 1 ) |
| str = pl; |
| if( !(dest = find_player(str) ) ) |
| { |
| write( capitalize(str) + " ist nicht eingeloggt.\n" ); |
| return TRUE; |
| } |
| } |
| else |
| dest = 0; |
| |
| do_msg( "<Mitteilung von "+PL->name(WEM)+">", dest ); |
| write( "Mitteilung" |
| + ( dest ? " an " + dest->name(WEN) : "" ) |
| + " kann mit '**' beendet werden.\n" ); |
| |
| input_to( "more_message", 0, dest ); |
| return TRUE; |
| } |
| |
| static void do_msg( string str, object obj ) |
| { |
| if( obj ) |
| tell_object( obj, str + "\n" ); |
| else |
| say( str + "\n" ); |
| } |
| |
| static int more_message( string str, object obj ) |
| { |
| if( str != "**" ) |
| { |
| do_msg( str, obj ); |
| input_to( "more_message", 0, obj ); |
| } |
| else |
| do_msg( "<Ende der Mitteilung>", obj ); |
| return TRUE; |
| } |
| |
| // ---------------------------------------------------------------------- |
| // Parse-Funktionen |
| // ---------------------------------------------------------------------- |
| int parse( string str ) |
| { |
| int i; |
| string arg, rest; |
| |
| if( !secure() ) return FALSE; |
| |
| // Die Hilfe faellt aus der allgemeinen Syntax heraus ! |
| if( query_verb()[1..] == "hilfe" || query_verb()[1..] == "help" ) |
| return zeige_hilfe( str ); |
| |
| if( str=this_player()->_unparsed_args() ) |
| str = query_verb()[1..]+" "+str; |
| else |
| str = query_verb()[1..]; |
| |
| fehler_passiert = FALSE; |
| while( !fehler_passiert && str && str!="" ) |
| str = parseNext( str, ({}), "-ROOT-" ); |
| |
| if( mit_say && !PL->QueryProp(P_INVIS) ) |
| { |
| if( !fehler_passiert ) |
| say( PL->name(WER)+" jongliert mit " |
| + PL->QPP(MALE,WEM,PLURAL)+" Tellern.\n" ); |
| else |
| say( PL->name(WEM)+" faellt beim Jonglieren ein Teller herunter.\n" ); |
| } |
| if( !fehler_passiert ) |
| write( "OK.\n" ); |
| return TRUE; |
| } |
| |
| static string|int parseNext( string str, mixed auxstack, string funname ) |
| { |
| mixed *res; |
| string arg, rest; |
| bool mit_return; |
| int num; |
| |
| while( str!="" && str[0]==' ' ) |
| str = str[1..]; |
| if( str=="" ) |
| return FALSE; |
| |
| switch( str[0] ) |
| { |
| case ';': // ---------------------------------------- Kommandobeginn |
| case ',': |
| push( ";" ); |
| return str[1..]; |
| case '\"': // --------------------------------------- Stringkonstante |
| if( sscanf( str, "\"%s\"%s", arg, rest )==2 ) |
| { |
| /* test auf numerisch fehlt hier noch */ |
| push_str( arg ); |
| return rest; |
| } |
| if( !sscanf( str, "\"%s\"", arg ) ) |
| return error( "String ohne Ende" ); |
| push_str( arg ); |
| return FALSE; |
| case '#': // ---------------------------------------- Zahl |
| res = nextAlpha( str[1..] ); |
| if( sscanf( res[0], "%d", num ) == 1 ) |
| { |
| push( num ); |
| return res[1]; |
| } |
| return error( "'#': keine erlaubte Zahl" ); |
| case '^': // ---------------------------------------- Hole env |
| if( !becomes_obj() ) |
| return error( "'^': TOS ist kein Objekt" ); |
| if( !environment(top()) ) |
| return error( "'^': TOS hat kein Environment" ); |
| push(environment(pop())); |
| return str[1..]; |
| case '.': // ---------------------------------------- Hole aus inv |
| if( !becomes_obj() ) |
| return error( "'.': TOS ist kein Objekt" ); |
| res = nextAlpha( str[1..] ); |
| calcinv( res[0] ); |
| return res[1]; |
| case '<': // ---------------------------------------- Recall |
| if( !sscanf( str, "<%s", arg ) || arg=="" ) |
| return error( "'<': Variablenname fehlt" ); |
| res = nextAlpha( str[1..] ); |
| do_recall(res[0]); |
| return res[1]; |
| case '>': // ---------------------------------------- Store |
| if( !sscanf( str, ">%s", arg ) || arg=="" ) |
| return error( "'>': Variablenname fehlt" ); |
| res = nextAlpha( str[1..] ); |
| do_store(res[0]); |
| return res[1]; |
| case '-': // ---------------------------------------- Call mit '-' |
| str = str[1..]; |
| if( mit_return = (str[0] == '-') ) |
| str = str[1..]; |
| res = nextAlpha( str[1..] ); |
| switch( str[0] ) |
| { |
| case '>': |
| if( do_call( res[0], mit_return ) ) |
| return res[1]; |
| break; |
| case '*': |
| if( do_call_efun( res[0], mit_return ) ) |
| return res[1]; |
| break; |
| default: |
| return error( "'-': '>' oder '*' erwartet" ); |
| } |
| return FALSE; |
| case '\'': // --------------------------------------- Call |
| str = str[1..]; |
| if( mit_return = (str[0] == '\'') ) |
| str = str[1..]; |
| res = nextAlpha( str ); |
| if( do_call( res[0], mit_return ) ) |
| return res[1]; |
| return FALSE; |
| case '`': // --------------------------------------- Call Efun |
| str = str[1..]; |
| if( mit_return = (str[0] == '`') ) |
| str = str[1..]; |
| res = nextAlpha( str ); |
| if( do_call_efun( res[0], mit_return ) ) |
| return res[1]; |
| return FALSE; |
| case '@': // --------------------------------------- Evaluate |
| str = str[1..]; |
| if( mit_return = (str[0] == '@') ) |
| str = str[1..]; |
| if( do_lpc( str, mit_return ) ) |
| return FALSE; |
| return FALSE; |
| case '!': // ------------------------------------------- META |
| if( sscanf(str,"!%d%s",num,arg)==2 ) |
| { |
| if( num>=sizeof(auxstack) ) |
| return error( "'"+funname+"': zu weing Argumente" ); |
| push( auxstack[num] ); |
| } |
| else |
| { |
| res = nextAlpha( str[1..] ); |
| memory += ([ res[0]: res[1]; 1 ]); |
| return FALSE; |
| } |
| return arg; |
| default: // ----------------------------------------- default |
| res = nextAlpha( str ); |
| do_cmd(res[0]); |
| return res[1]; |
| } |
| return memo( "Etwas Seltsames ist passiert" ); |
| } |
| |
| static int do_cmd( string str ) |
| { |
| string fun, filename, *spl; |
| mixed* oldstack; |
| int i,max,num; |
| |
| if( member(memory,str) ) |
| { |
| fun = memory[str,0]; |
| if( !memory[str,1] ) // normale Variablen |
| { |
| push( fun ); |
| return TRUE; |
| } |
| oldstack = stack; |
| stack = ({}); |
| spl = regexplode( fun, "![0-9][0-9]*" ); |
| max = -1; |
| for( i=1; i<sizeof(spl); i+=2 ) |
| if( sscanf(spl[i],"!%d",num) && max<num ) max = num; |
| |
| while( !fehler_passiert && fun && fun!="" ) |
| fun = parseNext( fun, oldstack, str ); |
| if( fehler_passiert ) |
| { |
| stack = oldstack; |
| return FALSE; |
| } |
| stack = stack + oldstack[(max+1)..]; |
| return TRUE; |
| } |
| else if (fun=tcommands[str]) |
| return call_other(ME,"cmd_"+fun); |
| |
| if( sscanf( str, "%d", i ) ) |
| push( i ); |
| else |
| { |
| filename = MASTER->_get_path(str,getuid()); |
| if( filename[<1] == '.' ) |
| filename = filename[0..<2]; |
| if( file_size( filename+".c" ) != -1 ) |
| push( filename ); |
| else |
| push( str ); |
| } |
| return TRUE; |
| } |
| |
| static mixed nextAlpha( string str ) |
| { |
| int pos; |
| |
| for( |
| pos=0; |
| pos<sizeof(str) && member( " #\";,^.><", str[pos] ) == -1; |
| pos++ |
| ) |
| ; |
| |
| if( pos==sizeof(str) ) |
| return ({ str, 0 }); |
| else |
| return ({ str[0..pos-1], str[pos..] }); |
| } |
| |
| static varargs void restore_stack( string* argv, int args ) |
| { |
| int i; |
| if( !args ) |
| args = sizeof(argv); |
| if( sizeof(stack) ) push( ";" ); |
| for( i=0; i<args; i++ ) |
| push(argv[i]); |
| } |
| |
| static int do_call( string fun, int mit_return ) |
| { |
| int args; |
| string err; |
| mixed result; |
| mixed arg, *argv; |
| |
| argv = ({}); |
| while( sizeof(stack) && (arg=pop())!=";" ) |
| argv = ({arg}) + argv; |
| if( !becomes_obj(argv) ) |
| { |
| restore_stack( argv ); |
| return error( "call: Funktion nicht an Objekt gerichtet" ); |
| } |
| if( !function_exists(fun,argv[0]) ) |
| { |
| restore_stack(argv); |
| return error( "call: Funktion nicht gefunden" ); |
| } |
| |
| args = sizeof(argv); |
| argv += ({ 0,0,0,0,0 }); |
| err=(catch(result=call_other(argv[0],fun, |
| argv[1],argv[2],argv[3],argv[4],argv[5]))); |
| if( err ) |
| { |
| restore_stack( argv, args ); |
| return error( "call: "+err[1..<2] ); |
| } |
| else |
| { |
| write( "=> " ); |
| dump_obj( result, 3 ); |
| if( mit_return ) |
| push( result ); |
| } |
| return TRUE; |
| } |
| |
| static int do_call_efun( string fun, int mit_return ) |
| { |
| int args; |
| string err; |
| mixed result; |
| mixed arg, *argv; |
| |
| argv = ({}); |
| while( sizeof(stack) && (arg=pop())!=";" ) |
| argv = ({arg}) + argv; |
| |
| if( !function_exists( "efun_"+fun ) ) |
| return error( "call efun: \""+fun+"\" nicht benutzbar" ); |
| fun = "efun_"+fun; |
| |
| args = sizeof(argv); |
| argv += ({ 0,0,0,0,0 }); |
| err=(catch(result=call_other(ME,fun, |
| argv[0],argv[1],argv[2],argv[3],argv[4]))); |
| if( err ) |
| { |
| restore_stack( argv, args ); |
| return error( "call efun: "+err[1..<2] ); |
| } |
| else |
| { |
| write( "=> " ); |
| dump_obj( result, 3 ); |
| if( mit_return ) |
| push( result ); |
| } |
| return TRUE; |
| } |
| |
| static int do_lpc( string str, int mit_return ) |
| { |
| int args, val; |
| string err; |
| string file, cmd, pre, post; |
| mixed result; |
| mixed arg, *argv; |
| |
| argv = ({}); |
| while( sizeof(stack) && (arg=pop())!=";" ) |
| argv = argv + ({arg}); |
| |
| file = "/players/"+getuid()+"/.teller"; |
| cmd = "#include <language.h>\n#include <properties.h>\n" |
| + "#include <moving.h>\n#include <defines.h>\n#include <terminal.h>\n" |
| + "#include <wizlevels.h>\n#include <ansi.h>\ncreate(){}doit(){"; |
| |
| while( str!="" && sscanf( str, "%s@%s", pre, post ) == 2 ) |
| { |
| if( sscanf( str, "%s@%d@%s", pre, val, post ) == 3 ) |
| { |
| if( sizeof(argv)<=val || val<0 ) |
| { |
| restore_stack( argv, args ); |
| return error( "lpc: Illegaler Index auf den Stack" ); |
| } |
| cmd += pre + DumpObj(argv[val]); |
| str = post; |
| } |
| else |
| if( sscanf( str, "%s@%s", pre, post ) == 2 ) |
| { |
| cmd += pre + "@"; |
| str = post; |
| } |
| } |
| cmd += str; |
| rm( file+".c" ); |
| write_file( file+".c" , cmd+";}\n" ); |
| if( find_object(file) ) destruct( find_object(file) ); |
| err=(catch(result=call_other(file,"doit"))); |
| if( err ) |
| { |
| //rm( file+".c" ); |
| restore_stack( argv, args ); |
| return error( "lpc: "+err[1..<2] ); |
| } |
| else |
| { |
| //rm( file+".c" ); |
| write( "=> " ); |
| dump_obj( result, 3 ); |
| if( mit_return ) |
| push( result ); |
| } |
| return TRUE; |
| } |