| // MorgenGrauen MUDlib |
| // |
| // awmaster.c -- Armours- and Weapons-Master |
| // |
| #pragma strict_types |
| #pragma no_clone |
| #pragma no_shadow |
| #pragma no_inherit |
| #pragma verbose_errors |
| #pragma combine_strings |
| #pragma pedantic |
| #pragma range_check |
| #pragma warn_deprecated |
| |
| #include <combat.h> |
| #include <language.h> |
| #include <properties.h> |
| #include <wizlevels.h> |
| |
| #define SAVEFILE "/secure/ARCH/awmaster" |
| #define ADUMPFILE "/log/ARCH/RUESTUNGEN" |
| #define DDUMPFILE "/log/ARCH/DAMAGERS" |
| #define WDUMPFILE "/log/ARCH/WAFFEN" |
| |
| #define AWF_PUTON 1 |
| #define AWF_PUTOFF 2 |
| #define AWF_BOOST 4 |
| #define AWF_ZAUBER 8 |
| #define AWF_RESIST 16 |
| |
| #define AWM_TYPE 0 |
| #define AWM_CLASS 1 |
| #define AWM_EFF_CLASS 2 |
| #define AWM_FLAGS 3 |
| #define AWM_WEIGHT 4 |
| #define AWM_VALUE 5 |
| #define AWM_HANDS 6 |
| #define AWM_D_TYPE 7 |
| #define AWM_X_CLASS 8 |
| #define AWM_TIME 9 |
| |
| mapping armours,weapons,damagers; |
| private int save_me_soon; |
| |
| private int allowed() |
| { |
| if (previous_object() && geteuid(previous_object())==ROOTID) |
| return 1; |
| if (!process_call() && previous_object() && this_interactive() && ARCH_SECURITY) |
| return 1; |
| return 0; |
| } |
| |
| void create() |
| { |
| seteuid(getuid(this_object())); |
| |
| if (!restore_object(SAVEFILE)) |
| { |
| armours = ([]); |
| weapons = ([]); |
| damagers = ([]); |
| } |
| if (widthof(damagers) == 1) { |
| mapping tmp = damagers; |
| damagers = m_allocate(sizeof(tmp),2); |
| foreach(string r, int flag: tmp) { |
| damagers[r,0]=flag; |
| } |
| } |
| } |
| |
| void save_me(int now) |
| { |
| if (now) |
| save_object(SAVEFILE); |
| else |
| save_me_soon=1; |
| } |
| |
| void reset() { |
| if (save_me_soon) |
| { |
| save_me_soon=0; |
| save_me(1); |
| } |
| } |
| |
| public varargs int remove(int silent) { |
| save_me(1); |
| destruct(this_object()); |
| return 1; |
| } |
| |
| int xflags(object ob){ |
| int re; |
| mapping m; |
| if (!ob || !objectp(ob)) |
| return 0; |
| re=0; |
| if (((object)ob->QueryProp(P_WEAR_FUNC))==ob || |
| ((object)ob->QueryProp(P_WIELD_FUNC))==ob ) |
| re += AWF_PUTON; |
| if (((object)ob->QueryProp(P_REMOVE_FUNC))==ob || |
| ((object)ob->QueryProp(P_UNWIELD_FUNC))==ob ) |
| re += AWF_PUTOFF; |
| if (((object)ob->QueryProp(P_DEFEND_FUNC))==ob || |
| ((object)ob->QueryProp(P_HIT_FUNC))==ob ) |
| re += AWF_BOOST; |
| // ists nen Mapping und nicht leer? |
| if (mappingp(m=(mapping)ob->QueryProp(P_RESISTANCE_STRENGTHS)) |
| && sizeof(m)) |
| re += AWF_RESIST; |
| return re; |
| } |
| |
| void RegisterArmour() |
| { object ob; |
| string id; |
| int flag,h; |
| |
| if (!objectp(ob=previous_object()) || |
| member(inherit_list(ob),"/std/armour.c")==-1) |
| return; |
| id = explode(object_name(ob),"#")[0]; |
| if (member(armours,id)) |
| { |
| armours[id][AWM_TIME]=time(); |
| flag=0; |
| if ((h=(int)ob->QueryProp(P_AC)) > armours[id][AWM_CLASS]) |
| { |
| armours[id][AWM_CLASS]=h; |
| flag=1; |
| } |
| if ((h=(int)ob->QueryProp(P_EFFECTIVE_AC)) > armours[id][AWM_EFF_CLASS]) |
| { |
| armours[id][AWM_EFF_CLASS]=h; |
| flag=1; |
| } |
| if ((h=(int)ob->QueryProp(P_NR_HANDS)) < armours[id][AWM_HANDS]) |
| { |
| armours[id][AWM_HANDS]=h; |
| flag=1; |
| } |
| if ((h=xflags(ob)) != armours[id][AWM_FLAGS]) |
| { |
| armours[id][AWM_FLAGS]=h; |
| flag=1; |
| } |
| } |
| else |
| { |
| armours += ([ id : |
| ([ |
| AWM_TYPE : ob->QueryProp(P_ARMOUR_TYPE) , |
| AWM_CLASS : ob->QueryProp(P_AC) , |
| AWM_EFF_CLASS : ob->QueryProp(P_EFFECTIVE_AC) , |
| AWM_FLAGS : xflags(ob), |
| AWM_WEIGHT : ob->QueryProp(P_WEIGHT) , |
| AWM_VALUE : ob->QueryProp(P_VALUE) , |
| AWM_HANDS : ob->QueryProp(P_NR_HANDS) , // Fuer Schilde |
| AWM_D_TYPE : ob->QueryProp(P_DAM_TYPE) , |
| AWM_X_CLASS : ob->QueryProp(P_EFFECTIVE_WC) || |
| ob->QueryProp(P_WC), |
| AWM_TIME : time() |
| ]) ]); |
| } |
| save_me(0); |
| } |
| |
| void RegisterWeapon() |
| { object ob; |
| string id; |
| int flag,h; |
| |
| if (!objectp(ob=previous_object()) || |
| member(inherit_list(ob),"/std/weapon.c")==-1) |
| return; |
| id = explode(object_name(ob),"#")[0]; |
| if (member(weapons,id)) |
| { |
| weapons[id][AWM_TIME] = time(); |
| flag=0; |
| if ((h=(int)ob->QueryProp(P_WC)) > weapons[id][AWM_CLASS]) |
| { |
| weapons[id][AWM_CLASS]=h; |
| flag=1; |
| } |
| if ((h=(int)ob->QueryProp(P_EFFECTIVE_WC)) > weapons[id][AWM_EFF_CLASS]) |
| { |
| weapons[id][AWM_EFF_CLASS]=h; |
| flag=1; |
| } |
| if ((h=(int)ob->QueryProp(P_NR_HANDS)) < weapons[id][AWM_HANDS]) |
| { |
| weapons[id][AWM_HANDS]=h; |
| flag=1; |
| } |
| if ((h=xflags(ob)) != weapons[id][AWM_FLAGS]) |
| { |
| weapons[id][AWM_FLAGS]=h; |
| flag=1; |
| } |
| } |
| else |
| { |
| weapons += ([ id : |
| ([ |
| AWM_TYPE : ob->QueryProp(P_WEAPON_TYPE) , |
| AWM_CLASS : ob->QueryProp(P_WC) , |
| AWM_EFF_CLASS : ob->QueryProp(P_EFFECTIVE_WC) , |
| AWM_FLAGS : xflags(ob), |
| AWM_WEIGHT : ob->QueryProp(P_WEIGHT) , |
| AWM_VALUE : ob->QueryProp(P_VALUE) , |
| AWM_HANDS : ob->QueryProp(P_NR_HANDS) , |
| AWM_D_TYPE : ob->QueryProp(P_DAM_TYPE) , |
| AWM_X_CLASS : ob->QueryProp(P_EFFECTIVE_AC) || |
| ob->QueryProp(P_AC), |
| AWM_TIME : time() |
| ]) ]); |
| } |
| save_me(0); |
| } |
| |
| void RegisterDamager(object dam_ob,int old_dam, int new_dam) |
| { object ob; |
| int flag; |
| string fn; |
| |
| if (!objectp(ob=previous_object()) || |
| (member(inherit_list(ob),"/std/weapon.c")==-1 && |
| member(inherit_list(ob),"/std/armour.c")==-1 )) |
| return; |
| if (old_dam>new_dam) // Repair |
| flag=2; |
| else if (new_dam>old_dam) // Damage |
| flag=1; |
| else |
| return; |
| if (!objectp(dam_ob)) |
| return; |
| if (!(fn=old_explode(object_name(dam_ob),"#")[0]) || !stringp(fn)) |
| return; |
| damagers[fn,0]=damagers[fn,0]|flag; |
| damagers[fn,1]=time(); |
| save_me(0); |
| } |
| |
| string dtdump(mixed arg) |
| { string re; |
| int i,w; |
| |
| if (stringp(arg)) |
| return capitalize(arg); |
| if (!pointerp(arg) || !stringp(arg[0])) |
| return "<NONE>"; |
| if ((i=sizeof(arg))==1) |
| return capitalize(arg[0]); |
| w = (31-i)/i; |
| if (w--<1) |
| return "<MANY>"; |
| for (re="",--i;i>=0;i--) |
| { |
| if (!stringp(arg[i])) |
| re += "-"; |
| else |
| re += capitalize(arg[i][0..w]); |
| if (i) |
| re += "|"; |
| } |
| return re; |
| } |
| |
| int Dump(mixed what, int sortidx) |
| { string file,*ind; |
| mapping dump; |
| |
| if (!allowed()) |
| return -1; |
| |
| if (!what) |
| { |
| write("Nimm doch mal einen richtigen Parameter!\n"); |
| return 0; |
| } |
| if (stringp(what) && sizeof(what)>0) |
| { |
| what==what[0..0]; |
| if (what=="a") |
| what=1; |
| else if (what=="w") |
| what=2; |
| else if (what=="d") |
| what=3; |
| else |
| { |
| write("Nimm doch mal einen richtigen Parameter!\n"); |
| return 0; |
| } |
| } |
| if (!intp(what) || what<1 || what>3) |
| { |
| write("Nimm doch mal einen richtigen Parameter!\n"); |
| return 0; |
| } |
| if (what==3) // Die 'damagers' haben ein anderes Ausgabeformat |
| { |
| printf("AWM: Dumping 'damagers' to '%s'\n",DDUMPFILE); |
| if (sizeof(damagers) < 1) { |
| write("AWM: Dump aborted, mapping empty.\n"); |
| return 1; |
| } |
| if (file_size(DDUMPFILE)>1) |
| rm(DDUMPFILE); |
| |
| // nach letzter Aktualisierung sortieren. |
| mixed sorted = sort_array(m_indices(damagers), |
| function int (string a, string b) { |
| return damagers[a,1] < damagers[b,1]; |
| } ); |
| |
| string ausgabe = sprintf( |
| "--- Damagers-Dump --- %s --- %s ---\n\n"+ |
| "%:15s D R [Filename]\n", |
| dtime(time()),capitalize(getuid(this_interactive())), |
| "Datum/Zeit"); |
| foreach(string rue : sorted) { |
| ausgabe += sprintf("%:15s %1s %1s %s\n", |
| strftime("%y%m%d-%H:%M:%S",damagers[rue,1]), |
| (damagers[rue,0]&1?"+":"-"), |
| (damagers[rue,0]&2?"+":"-"), |
| rue); |
| } |
| |
| write_file(DDUMPFILE, ausgabe); |
| return 1; |
| } |
| if (what==2) |
| what=0; |
| file=(what?ADUMPFILE:WDUMPFILE); |
| |
| printf("AWM: Dumping '%s' to '%s'\n", |
| (what?"armours":"weapons"),file); |
| |
| dump=(what?armours:weapons); |
| |
| if (sortidx) { |
| ind = sort_array(m_indices(dump), |
| function int (string a, string b) |
| {return dump[a][sortidx] < dump[b][sortidx];} ); |
| } |
| else |
| ind = sort_array(m_indices(dump),#'>); |
| |
| if (sizeof(ind) < 1) |
| { |
| write("AWM: Dump aborted, mapping empty.\n"); |
| return 1; |
| } |
| |
| if (file_size(file)>1) |
| rm(file); |
| |
| string ausgabe = sprintf( |
| "--- %s-Dump --- %s --- %s ---\n\n"+ |
| "[Filename], Datum/Zeit\n"+ |
| " ____Typ___ CLS ECL XCL NFBR WGHT. VALUE H %30.30'_'|s\n", |
| (what?"Ruestungs":"Waffen"),dtime(time()), |
| capitalize(getuid(this_interactive())),"DamType(s)"); |
| |
| foreach(string index : ind) |
| { |
| ausgabe += sprintf( |
| "[%s] %s\n %10s %3d %3d %3d %1s%1s%1s%1s %5d %5d %1d %-30.30s\n", |
| index, strftime("%y%m%d-%H:%M:%S",dump[index][AWM_TIME]), |
| dump[index][AWM_TYPE], |
| dump[index][AWM_CLASS], |
| dump[index][AWM_EFF_CLASS], |
| dump[index][AWM_X_CLASS], |
| (dump[index][AWM_FLAGS]&AWF_PUTON?"+":"-"), |
| (dump[index][AWM_FLAGS]&AWF_PUTOFF?"+":"-"), |
| (dump[index][AWM_FLAGS]&AWF_BOOST?"+":"-"), |
| (dump[index][AWM_FLAGS]&AWF_RESIST?"+":"-"), |
| dump[index][AWM_WEIGHT], |
| dump[index][AWM_VALUE], |
| dump[index][AWM_HANDS], |
| dtdump(dump[index][AWM_D_TYPE]) ); |
| } |
| write_file(file,ausgabe); |
| write("AWM: Done.\n"); |
| return 1; |
| } |
| |
| int Unregister(string what) |
| { |
| if (!allowed()) |
| return -1; |
| if (!what) |
| { |
| write("Du solltest schon einen Filenamen angeben!\n"); |
| return 0; |
| } |
| if (member(armours,what)) |
| { |
| m_delete(armours,what); |
| write("Unregistered "+what+" from 'armours'.\n"); |
| return 1; |
| } |
| if (member(weapons,what)) |
| { |
| m_delete(weapons,what); |
| write("Unregistered "+what+" from 'weapons'.\n"); |
| return 1; |
| } |
| if (member(damagers,what)) |
| { |
| m_delete(damagers,what); |
| write("Unregistered "+what+" from 'damagers'.\n"); |
| return 1; |
| } |
| save_me(0); |
| return 0; |
| } |
| |
| int ResetDamagers() |
| { |
| if (!allowed()) |
| return -1; |
| damagers = m_allocate(0,2); |
| save_me(1); |
| return 1; |
| } |
| |