| // (c) 2003 by Thomas Winheller (padreic@mg.mud.de) |
| // Bei diesem File handelt es sich um einen universellen |
| // Kessel zum Brauen von Traenken. Damit er sich in den |
| // Raum entsprechend einpassen kann, ist er invis. |
| |
| // Ein Raum, in dem Traenke und Gift gebraut werden koennen |
| // soll, braucht nichts weiter machen als: |
| // - eine Moeglichkeit zu implementieren Wasser in den Kessel |
| // zu fuellen. Hierzu muss dann mittels AddWater(3000) |
| // insgesamt 3l Wasser eingefuellt werden. AddWater gibt die |
| // Menge des tatsaechlich noch eingefuelltn Wassers zurueck. |
| // Anmerkung: bisher enthaelt /obj/flasche noch keine Moeglichkeit |
| // Fluessigkeiten von einem Fluessigkeitencontainer in |
| // einen anderen zu schuetten, aber vielleicht aendert |
| // das ja irgendwann mal wer - der Kessel kann dann |
| // durch alle diese Flaschen befuellt werden! |
| #pragma strong_types,rtt_checks |
| |
| inherit "/std/container"; |
| |
| #include <defines.h> |
| #include <properties.h> |
| #include <moving.h> |
| #include <fishing.h> |
| #include <items/kraeuter/kraeuter.h> |
| #include <items/flasche.h> |
| |
| #ifndef BS |
| # define BS(x) break_string(x, 78) |
| #endif |
| |
| private int wassermenge; |
| |
| // Aktueller Nutzer des Kessels in Form der Spieler-UID |
| private string current_user; |
| |
| // Zeitpunkt, wann die Sperre endet. |
| private int timeout; |
| |
| protected void create() |
| { |
| ::create(); |
| SetProp(P_SHORT, "Ein schwerer Kessel"); |
| // \n werden in long() eingefuegt |
| SetProp(P_LONG, |
| "Ein kleiner, aber sehr schwerer Kessel, in dem die verschiedensten " |
| "Traenke gebraut werden koennen."); |
| SetProp(P_NAME, "Kessel"); |
| SetProp(P_NAME_ADJ, "klein"); |
| SetProp(P_MATERIAL, MAT_BRONCE); |
| SetProp(P_NOGET, "Der Kessel ist zu schwer, um ihn einfach mitnehmen " |
| "zu koennen.\n"); |
| SetProp(P_MAX_WEIGHT, 100000); // ein _wirklich_ grosser Kessel ;o) |
| SetProp(P_WEIGHT, 50000); |
| SetProp(P_VALUE, 25000); |
| SetProp(P_MAX_OBJECTS, 9); // max. 8 Kraeuter + Wasser |
| SetProp(P_GENDER, MALE); |
| SetProp(P_LIQUID, 3000); // in den Kessel passen 3l :o) |
| AddId(({"kessel", KESSELID})); |
| AddAdjective(({"klein", "kleiner"})); |
| AddCmd("leer|leere&@ID&aus", "cmd_leeren", |
| "Was moechtest Du leeren?|Moechtest Du den Kessel etwa ausleeren?"); |
| AddCmd(({"brau", "braue", "koch", "koche"}), "cmd_brauen"); |
| AddCmd("fuell|fuelle&trank|heiltrank|ergebnis|kesselinhalt|inhalt&in&" |
| "@PRESENT", "cmd_fuellen", |
| "Was willst Du fuellen?|Willst Du etwas in etwas fuellen?|" |
| "Worein willst Du den Kesselinhalt fuellen?"); |
| AddCmd(({"tauch", "tauche"}), "cmd_tauchen"); |
| } |
| |
| #define TRANKFERTIG "_lib_p_krauttrankfertig" |
| |
| private int check_busy(int useronly) |
| { |
| if (useronly) |
| return current_user && current_user != getuid(PL); |
| // Timeout darf noch nicht abgelaufen sein. Wird beim Entleeren geprueft. |
| return current_user && timeout > time() && current_user != getuid(PL); |
| } |
| |
| private void clear_kessel() |
| { |
| all_inventory()->remove(1); |
| // gespeicherte Daten nullen |
| wassermenge = current_user = timeout = 0; |
| SetProp(P_WATER, 0); |
| SetProp(TRANKFERTIG, 0); |
| } |
| |
| int AddWater(int menge) |
| { |
| // Wenn ein User eingetragen ist, dieser nicht PL ist und die Sperre |
| // auch noch nicht abgelaufen ist, dann wird das Einfuellen von Wasser |
| // verhindert. Nutzer der Funktion muessen die Rueckgabewerte pruefen |
| // und entsprechende Meldungen ausgeben. |
| if (check_busy(1)) |
| return -1; |
| |
| int old = wassermenge; |
| wassermenge = min(wassermenge+menge, QueryProp(P_LIQUID)); |
| |
| if (wassermenge<=0) |
| { |
| wassermenge=0; // wasser entnahme |
| SetProp(P_WATER, 0); |
| } |
| else |
| SetProp(P_WATER, W_DEAD); |
| return wassermenge-old; |
| } |
| |
| static int cmd_leeren(string str) |
| { |
| if (!QueryProp(P_WATER) && !sizeof(all_inventory())) |
| { |
| write(BS("Im Kessel ist bisher noch nichts enthalten, was Du ausleeren " |
| "koenntest.")); |
| } |
| // Es gibt einen aktuellen User, dieser ist nicht PL, und der Timeout |
| // ist auch noch nicht abgelaufen => Finger weg. |
| else if (check_busy(0)) |
| { |
| tell_object(PL, BS( |
| "Der Inhalt des Kessels wurde erst kuerzlich von jemand anderem dort " |
| "hineingefuellt. Du solltest Dich nicht daran zu schaffen machen.")); |
| } |
| write("Vorsichtig nimmst Du den Kessel und schuettest seinen Inhalt in den Abfluss.\n"); |
| say(BS(PL->Name(WER)+" nimmt den Kessel und schuettet den Inhalt in den Abfluss.")); |
| clear_kessel(); |
| return 1; |
| } |
| |
| /*#include "/d/erzmagier/boing/balance/balance.h" |
| #include <wizlevels.h> |
| #define TESTER (BTEAM+({"elendil","saray", "huraxprax"}))*/ |
| static int cmd_brauen(string str) |
| { |
| /*if (!IS_ARCH(this_interactive()) |
| && !member(TESTER, PL->query_real_name())) |
| return 0;*/ |
| |
| notify_fail("WAS moechtest Du brauen?\n"); |
| if (!str) return 0; |
| /* if (str=="zaubertrank") { |
| write("Ohne passendes Rezept duerfte dies schwierig werden...\n"); |
| return 1; |
| }*/ |
| if (member(({"trank","zaubertrank","kraeutertrank","tee","kraeutertee"}), |
| str)<0) |
| return 0; |
| |
| if (check_busy(1)) { |
| tell_object(PL, BS( |
| "An dem Trank in dem Kessel arbeitet gerade noch "+ |
| capitalize(current_user)+". Du kannst hoechstens in ein paar " |
| "Minuten versuchen, den Inhalt des Kessels auszuleeren. Selbst " |
| "Hand anzulegen, wuerde man Dir sicherlich uebelnehmen.")); |
| } |
| else if (!QueryProp(P_WATER)) { |
| write("Vielleicht solltest Du zunaechst noch Wasser in den Kessel " |
| "fuellen...\n"); |
| } |
| else if (wassermenge<QueryProp(P_LIQUID)) { |
| write("Vielleicht solltest Du zunaechst noch etwas mehr Wasser in " |
| "den Kessel\nfuellen...\n"); |
| } |
| else if (sizeof(all_inventory())<3) { |
| write("Derzeit ist Dein Trank noch ein wenig waessrig.\n" |
| +"Mindestens drei Zutaten muessen in einen Trank schon hinein.\n"); |
| } |
| else { |
| write(BS("Vorsichtig laesst Du den Kessel etwas naeher zur Feuerstelle " |
| "runter und wartest unter gelegentlichem Ruehren, bis er kocht. " |
| "Dein Trank sollte nun fertig sein und Du kannst ihn nun abfuellen. " |
| "Was er wohl fuer eine Wirkung haben wird?")); |
| say(BS(PL->Name()+" laesst den Kessel zur Feuerstelle herunter und " |
| "ruehrt langsam darin herum. Nach einer Weile kocht die Fluessigkeit " |
| "darin, und "+PL->Name(WER)+" stellt das Ruehren wieder ein.")); |
| SetProp(TRANKFERTIG, 1); |
| } |
| return 1; |
| } |
| |
| static int cmd_fuellen(string str,mixed* params) |
| { |
| /* if (!IS_ARCH(this_interactive()) |
| && !member(TESTER, this_player()->query_real_name())) |
| return 0;*/ |
| |
| if ( !QueryProp(TRANKFERTIG) ) |
| { |
| write("Im Kessel befindet sich aber gar kein Trank.\n"); |
| } |
| // Abfuellen ist nur fuer den Spieler moeglich, der die Kraeuter |
| // reingetan hat. |
| else if (check_busy(1)) |
| { |
| tell_object(PL, BS("Diesen Trank hast Du doch gar nicht selbst " |
| "gebraut! Du solltest noch eine Weile warten, ob "+ |
| capitalize(current_user)+" ihn nicht doch noch selbst abfuellen " |
| "will. Wenn nicht, koenntest Du nur noch versuchen, den Kessel " |
| "auszuleeren - jedenfalls es erscheint Dir viel zu riskant, das " |
| "Gebraeu selbst zu trinken, das "+capitalize(current_user)+ |
| " da zusammengeruehrt hat.")); |
| } |
| else if (BLUE_NAME(params[2])==TRANKITEM) |
| { |
| int ret = params[2]->Fill(all_inventory()); |
| switch( ret ) { |
| case -3: |
| case -1: |
| write(BS("Fehler beim Fuellen der Phiole. Bitte sag einem Magier " |
| "Bescheid und nenne den Fehlercode "+ret+".")); |
| break; |
| case -2: |
| write(BS("Die Phiole ist bereits gefuellt.")); |
| break; |
| default: |
| write(BS("Du nimmst den Kessel und fuellst seinen konzentrierten " |
| "Inhalt in Deine Glasflasche. Hoffentlich ist Dir hier ein " |
| "toller Trank gelungen.")); |
| say(BS(PL->Name(WER)+" nimmt den Kessel und fuellt dessen " |
| "konzentrierten Inhalt in eine kleine Glasflasche. Was "+ |
| PL->QueryPronoun(WER)+" da wohl gebraut hat?")); |
| clear_kessel(); |
| break; |
| } |
| } |
| else { |
| write("Darein kannst Du den Trank leider nicht fuellen.\n"); |
| } |
| return 1; |
| } |
| |
| varargs string long(int mode) |
| { |
| string inv_desc = make_invlist(PL, all_inventory(ME)); |
| if (inv_desc=="") { |
| if (QueryProp(P_WATER)) |
| return BS(Query(P_LONG)+" Derzeit ist er lediglich mit Wasser " |
| "gefuellt."); |
| return BS(Query(P_LONG)+" Er ist im Moment leer."); |
| } |
| if (QueryProp(P_WATER)) |
| return BS(Query(P_LONG)+" Er ist mit Wasser gefuellt, und Du siehst " |
| +"folgende Kraeuter in ihm schwimmen:")+inv_desc; |
| return BS(Query(P_LONG))+"Er enthaelt:\n"+inv_desc; |
| } |
| |
| static int _query_invis() |
| { |
| if (member(({"nimm", "nehm", "nehme", "leg", "lege", |
| "steck", "stecke"}), query_verb())!=-1) return 0; |
| return Query(P_INVIS, F_VALUE); |
| } |
| /* |
| varargs string name(int casus, int demon) |
| { |
| SetProp(P_INVIS, 0); |
| string ret=::name(casus, demon); |
| SetProp(P_INVIS, 1); |
| return ret; |
| } |
| */ |
| varargs int PreventInsert(object ob) |
| { |
| int plantid = ob->QueryPlantId(); |
| int *inv = all_inventory(ME)->QueryPlantId(); |
| |
| // es koennen natuerlich nur echte Kraeuter in den Kessel gelegt werden |
| if ( plantid<=0 || !IS_PLANT(ob) ) |
| return 1; |
| |
| if (QueryProp(TRANKFERTIG)) |
| { |
| tell_object(PL, break_string( |
| "Im Kessel ist ein fertiger Trank. Wenn Du etwas neues machen " |
| "willst, leere den Kessel oder fuelle den Trank ab.")); |
| return 1; |
| } |
| // Reintun darf nur der aktuelle User, es sei denn, ein anderer Spieler |
| // faengt frisch an, wenn der Kessel gerade unbenutzt ist. |
| else if ( check_busy(1) ) |
| { |
| tell_object(PL, BS("Dieser Kessel wurde bis gerade eben noch von "+ |
| capitalize(current_user)+" genutzt. Warte besser, bis der Kessel " |
| "wieder frei ist.")); |
| return 1; |
| } |
| else if ( !SECURE("krautmaster")->CanUseIngredient(PL, plantid) ) |
| { |
| // mit Kraeutern ueber die man nichts weiss, kann man nicht brauen |
| tell_object(PL, BS("Ueber die Wirkungsweise von "+ob->name(WEM)+ |
| " weisst Du bisher leider wirklich ueberhaupt nichts.")); |
| return 1; |
| } |
| else if ( sizeof(inv) >= 8 ) |
| { |
| tell_object(PL, BS("Mehr als acht Zutaten sollte man nie zu einem " |
| "Trank vereinigen, und es sind schon acht im Kessel.")); |
| return 1; |
| } |
| else if (member(inv, plantid)>-1) |
| { |
| tell_object(PL, BS("Im Kessel befindet sich bereits "+ob->name(WER)+ |
| ". Du kannst kein Kraut mehr als einmal verwenden.")); |
| return 1; |
| } |
| current_user = getuid(PL); |
| timeout = time()+120; |
| return ::PreventInsert(ob); |
| } |
| |
| int PreventLeave(object ob, mixed dest) |
| { |
| if (QueryProp(P_WATER)) { |
| tell_object(PL, BS("Es befindet sich bereits Wasser im Kessel, die " |
| "einzelnen Zutaten kannst Du nun leider nicht mehr einzeln " |
| "rausholen, ohne den ganzen Kessel auszuleeren.")); |
| return 1; |
| } |
| // Rausnehmen ist nur fuer den aktuellen User moeglich. Alle anderen |
| // koennen auch nach Ablauf der Zeitsperre nur ausleeren. |
| else if ( check_busy(1) ) { |
| tell_object(PL, BS("Du hast "+ob->name(WEN,1)+" nicht dort hineingetan, " |
| "also kannst Du "+ob->QueryPronoun(WEN)+" auch nicht herausnehmen. " |
| "Zumindest vorerst nicht. Sollte "+capitalize(current_user)+ |
| "nicht innerhalb der naechsten paar Minuten weiterbrauen, kannst " |
| "Du den Kesselinhalt zumindest mit einem guten Schluck Wasser " |
| "rausspuelen.")); |
| return 1; |
| } |
| return ::PreventLeave(ob, dest); |
| } |
| |