Added public files
Roughly added all public files. Probably missed some, though.
diff --git a/items/kraeuter/kessel.c b/items/kraeuter/kessel.c
new file mode 100644
index 0000000..909eead
--- /dev/null
+++ b/items/kraeuter/kessel.c
@@ -0,0 +1,335 @@
+// (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);
+}
+