| // ---------------------------------------------------------------------- |
| // Die Basis- und Hilfsfunktionen der Teller. |
| // Stack und Memory |
| // ---------------------------------------------------------------------- |
| #include "teller.h" |
| |
| #include <moving.h> |
| #include <terminal.h> |
| |
| static mixed *stack; |
| static mapping memory; |
| static object *oldinv; |
| static bool mit_namen; |
| static bool fehler_passiert; |
| static bool mit_say; |
| static bool secureinv; |
| static bool dologaccess; |
| static bool pretty; |
| static bool do_profile; |
| |
| static mixed top(); |
| static mixed pop(); |
| static void push( mixed ob ); |
| |
| static void dump_obj( mixed ob, int indent ); |
| |
| void create() |
| { |
| stack = ({}); |
| memory = ([]); |
| mit_namen = TRUE; |
| fehler_passiert = FALSE; |
| mit_say = TRUE; |
| secureinv = FALSE; |
| dologaccess = FALSE; |
| pretty = TRUE; |
| } |
| |
| // ---------------------------------------------------------------------- |
| // Hilfsfunktionen |
| // ---------------------------------------------------------------------- |
| |
| static int error( string msg ) |
| { |
| write( "Fehler in "+msg+".\n" ); |
| fehler_passiert = TRUE; |
| return FALSE; |
| } |
| |
| static int memo( string msg ) |
| { |
| write( "MEMO: "+msg+".\n" ); |
| return FALSE; |
| } |
| |
| static int calcinv( string str ) |
| { |
| object* obs; |
| object ob; |
| int val; |
| |
| if( sscanf( str, "%d", val ) == 1 ) |
| { |
| obs = all_inventory(top()); |
| if( val<0 || val>=sizeof(obs) ) |
| return error( "'.': Kein Objekt mit dieser Nummer" ); |
| pop(); |
| push(obs[val]); |
| return TRUE; |
| } |
| |
| if( !(ob=present(str,top())) ) |
| return error( "'.': Kein Objekt namens \""+str+"\" gefunden" ); |
| pop(); |
| push(ob); |
| return TRUE; |
| } |
| |
| static mixed push_str( string str ) |
| { |
| return |
| push( implode(old_explode( implode(old_explode( implode(old_explode( |
| " "+str+" ", |
| "\\n"),"\n"), "\\e"),ESC), "\\b"),"\b") |
| [1..<2] ); |
| } |
| |
| static void do_move( object ob, mixed dest ) |
| { |
| int weight; |
| |
| weight = ob->QueryWeight(); |
| if( environment(ob) ) |
| environment(ob)->AddWeight(-weight); |
| ob->move(dest,M_NOCHECK); |
| dest->AddWeight(weight); |
| } |
| |
| void heart_beat() |
| { |
| object *newinv; |
| object owner; |
| int i,j; |
| |
| if( owner=find_player(getuid()) ) |
| { |
| newinv = sort_array( all_inventory(owner), lambda( ({'a,'b}), |
| ({ #'<, |
| ({ #'object_name, 'a }), |
| ({ #'object_name, 'b }) |
| }) |
| ) ); |
| if( pointerp(oldinv) ) |
| { |
| for( i=0,j=0; i<sizeof(newinv) && j<sizeof(oldinv) ; ) |
| { |
| if( newinv[i] == oldinv[j] ) |
| { i++; j++; } |
| else if( object_name(newinv[i]) > object_name(oldinv[j]) ) |
| { |
| tell_object(owner, |
| "MEMO: \""+object_name(newinv[i])+"\" entered inventory.\n" ); |
| i++; |
| } |
| else |
| j++; |
| } |
| for( ; i<sizeof(newinv) ; i++ ) |
| tell_object( owner, |
| "MEMO: \""+object_name(newinv[i])+"\" entered inventory.\n" ); |
| } |
| } |
| oldinv = newinv; |
| } |
| |
| // ---------------------------------------------------------------------- |
| // Dumpfunktionen |
| // ---------------------------------------------------------------------- |
| |
| static void dump_array( mixed* ob, int indent ) |
| { |
| int i; |
| for( i=0; i<sizeof(ob); i++ ) |
| { |
| printf( "%*s", indent, "" ); |
| dump_obj( ob[i], indent ); |
| } |
| } |
| |
| static void dump_mapping( mapping ob, int indent ) |
| { |
| mixed *index; |
| mixed key; |
| int i,j,values; |
| |
| index = m_indices( ob ); |
| values = get_type_info(ob)[1]; |
| for( i=0; i<sizeof(index); i++ ) |
| { |
| key = index[i]; |
| printf( "%*s", indent, "" ); |
| dump_obj( key, indent ); |
| for( j=0; j<values; j++ ) |
| { |
| printf( "%*s: ", indent+1, "" ); |
| dump_obj( ob[key,j], indent+3 ); |
| } |
| } |
| } |
| |
| static void dump_obj( mixed ob, int indent ) |
| { |
| if( !pretty ) |
| { |
| printf( "%O\n", ob ); |
| return; |
| } |
| if( intp(ob) ) |
| write( ob + "\n" ); |
| else if( floatp(ob) ) |
| printf( "%1.5f\n", ob ); |
| else if( stringp(ob) ) |
| { |
| if ( ob==";" ) |
| write( ";\n" ); |
| else |
| { |
| write( "\"" + implode(old_explode( implode(old_explode( implode(old_explode( |
| " "+ob+" ", |
| "\n"),"\\n"), ESC), "\\e"), "\b"),"\\b") |
| [1..<2] + "\"\n" |
| ); |
| } |
| } |
| else if( objectp(ob) ) |
| { |
| if( mit_namen ) |
| write( object_name(ob)+" ("+ob->name(WER,0)+")\n" ); |
| else |
| write( object_name(ob)+"\n" ); |
| } |
| else if( mappingp(ob) ) |
| { |
| write( "([\n" ); |
| dump_mapping( ob, indent + 2 ); |
| printf( "%*s\n", indent + 2, "])" ); |
| } |
| else if( pointerp(ob) ) |
| { |
| write( "({\n" ); |
| dump_array( ob, indent+2 ); |
| printf( "%*s\n", indent+2 , "})" ); |
| } |
| else |
| printf( "%O\n", ob ); |
| } |
| |
| // ---------------------------------------------------------------------- |
| // Speicherfunktionen |
| // ---------------------------------------------------------------------- |
| |
| static void do_recall( mixed arg ) |
| { |
| if( member(memory,arg) ) |
| push( memory[arg,0] ); |
| } |
| |
| static void do_store( mixed arg ) |
| { |
| if ( sizeof(stack) ) |
| { |
| if( !top() ) |
| memory = m_delete(memory,arg); |
| else |
| memory += ([ arg: top(); 0 ]); |
| } |
| else |
| memo( "Es wurde kein Wert in \""+arg+"\" gespeichert" ); |
| } |
| |
| // ---------------------------------------------------------------------- |
| // Stack-Funktionen |
| // ---------------------------------------------------------------------- |
| |
| static void push( mixed ob ) |
| { |
| stack = ({ ob }) + stack; |
| } |
| |
| static mixed pop() |
| { |
| mixed answer; |
| |
| if( !sizeof( stack ) ) |
| return FALSE; |
| answer = stack[0]; |
| stack = stack[1..]; |
| return answer; |
| } |
| |
| static mixed top() |
| { |
| if( sizeof(stack) ) |
| return stack[0]; |
| } |
| |
| static varargs int becomes_obj( mixed argv) |
| { |
| object ob; |
| |
| if( !pointerp(argv) ) // default ist der stack ! |
| argv = stack; |
| if( !sizeof(argv) ) |
| return FALSE; |
| if( stringp(argv[0]) && !catch(call_other(argv[0],"?")) ) |
| { |
| argv[0] = find_object(argv[0]); |
| return TRUE; |
| } |
| else |
| return objectp(argv[0]); |
| } |
| |
| static isSubStr( pl, str, len ) |
| { |
| return getuid(pl)[0..len] == str; |
| } |
| |
| static becomes_pl(argv) |
| { |
| object pl; |
| object* pllist; |
| string str; |
| int len; |
| |
| if( !argv ) argv = stack; |
| if( !sizeof(argv) || ( becomes_obj() && !interactive(argv[0]) ) ) |
| return FALSE; |
| if( stringp(argv[0]) ) |
| { |
| str = lower_case( argv[0] ); |
| pl = 0; |
| if( str[<1..<1] == "*" ) |
| { |
| str = str[0..<2]; |
| len = sizeof(str) - 1; |
| pllist = filter( users(), #'isSubStr, str, len ); |
| if( sizeof(pllist) == 1 ) |
| { |
| pl=pllist[0]; |
| argv[0] = pl; |
| } |
| } |
| if( !pl && pl=find_player(argv[0]) ) |
| argv[0] = pl; |
| return pl; |
| } |
| return argv[0]; |
| } |
| |
| static DumpObj( ob ) |
| { |
| string ans; |
| int i,j; |
| |
| if( intp(ob) ) |
| return ""+ob; |
| else if( stringp(ob) ) |
| return "\""+implode(explode(ob,"\n"),"\\n")+"\""; |
| else if( objectp(ob) ) |
| return "\""+object_name(ob)+"\""; |
| else if( mappingp(ob) ) |
| { |
| ans="(["; |
| for( i=0; i<sizeof(ob)-1; i++ ) |
| ans += DumpMapp(ob,i)+","; |
| // rely on right value of i |
| return ans+DumpMapp(ob,i)+"])"; |
| } |
| else |
| { |
| ans="({"; |
| for( i=0; i<sizeof(ob)-1; i++ ) |
| ans += DumpObj(ob[i])+","; |
| // rely on right value of i |
| return ans+DumpObj(ob[i])+"})"; |
| } |
| } |
| |
| static DumpMapp(ob,i) |
| { |
| int j,vz; |
| string ans; |
| |
| vz = get_type_info(ob)[1]; |
| ans = DumpObj(m_indices(ob)[i])+":"; |
| for( j=0; j<vz-1; j++ ) |
| ans += DumpObj(ob[m_indices(ob)[i],j])+";"; |
| // rely on value of j |
| return ans + DumpObj(ob[m_indices(ob)[i],j]); |
| } |