Added public files
Roughly added all public files. Probably missed some, though.
diff --git a/std/food.c b/std/food.c
new file mode 100644
index 0000000..7b75921
--- /dev/null
+++ b/std/food.c
@@ -0,0 +1,732 @@
+// MorgenGrauen MUDlib
+//
+// /std/food.c - Standardobjekt fuer Lebensmittel
+//
+// $Id: food.c 8248 2012-11-23 21:28:04Z Zesstra $
+#pragma strict_types,save_types,rtt_checks
+#pragma no_clone
+#pragma pedantic,range_check
+
+inherit "/std/thing";
+
+#include <food.h>
+#include <living/life.h>
+#include <break_string.h>
+
+// Standard-IDs und -Adjektive muessen gesichert werden
+#define ID_BACKUP "std_food_id_backup"
+#define ADJ_BACKUP "std_food_adj_backup"
+
+// Zeitpunkt, an dem die Speise verdorben ist
+private nosave int time_gone_bad;
+
+// Zeitpunkt, an dem die Speise verderben darf
+// wird immer erst gesetzt, wenn ein Spieler hiermit in Beruehrung kommt
+private nosave int time_togo_bad;
+
+// Zeitpunkt, an dem die Speise zerstoert werden darf
+// wird immer erst gesetzt, wenn ein Spieler hiermit in Beruehrung kommt
+private nosave int time_to_remove;
+
+// Zeitpunkt, ab dem die Speise mit einem Spieler in Beruehrung kam
+// bei ewig haltbaren Speisen ist sie immer 0;
+private nosave int start_life = 0;
+
+// Dauer des ersten Resets
+private nosave int first_reset_length = 0;
+
+// Wertet Properties aus (Ersetzungen werden durchgefuehrt)
+protected mixed eval_property(string val,object consumer) {
+ mixed what = QueryProp(val);
+ if (stringp(what)) {
+ what=capitalize(replace_personal(what,({this_object(),consumer}),1));
+ }
+ return break_string(what,78,"",BS_LEAVE_MY_LFS);
+}
+
+// wird nur verwendet, wenn der gesetzte Reset ein Timerende darstellt,
+// um zu garantieren, dass der nicht abgestellt wird.
+// Zugegebenenermassen keine schoener Hack :-/
+private void my_set_next_reset(int zeit) {
+ set_next_reset(zeit);
+ // Damit der Reset auch wirklich ausgefuehrt wird ...
+ call_out(#'id,1);
+}
+
+// Ausgabe von Meldungen an Besitzer oder Raum
+protected void message(string prop) {
+ object env = environment(this_object());
+ if (objectp(env)) {
+ if (interactive(env)) {
+ tell_object(env,
+ break_string(eval_property(prop,env),78,"",BS_LEAVE_MY_LFS));
+ }
+ else if(!living(env)) {
+ tell_room(env,
+ break_string(eval_property(prop,0),78,"",BS_LEAVE_MY_LFS));
+ }
+ }
+}
+
+// Flag, ob die Speise verdorben ist
+public int is_bad() {
+ return time_gone_bad > 0;
+}
+
+// Anzahl der Sekunden, die das Lebensmittel bereits hinter sich hat,
+// seit es mit einem Spieler in Beruehrung kam
+public int get_current_lifetime() {
+ if (!start_life) return 0;
+ return time() - start_life;
+}
+
+// Berechnet den Wert der Speise korrekt
+int _query_value() {
+ int result = 0;
+ if (!is_bad()) {
+ result += to_int(QueryProp(P_PORTIONS)*Query(P_VALUE,F_VALUE));
+ }
+ if (mappingp(QueryProp(P_EMPTY_PROPS))) {
+ result += QueryProp(P_EMPTY_PROPS)[P_VALUE];
+ }
+ return result;
+}
+
+// Berechnet den Wert der Speise korrekt
+int _query_weight() {
+ int result = to_int(QueryProp(P_PORTIONS)*Query(P_WEIGHT,F_VALUE));
+ if (mappingp(QueryProp(P_EMPTY_PROPS))) {
+ result += QueryProp(P_EMPTY_PROPS)[P_WEIGHT];
+ }
+ return result;
+}
+
+// Dauer des ersten Resets wird wieder hinzugerechnet
+// damit wird bei Nichtsetzen der Prop der Standard geliefert
+int _query_std_food_lifetime() {
+ return Query(P_LIFETIME,F_VALUE)+(first_reset_length);
+}
+
+// Setter fuer die Lifetime, damit die Resettime immer mitkorrigiert wird
+// und Dauer des ersten Resets abgezogen werden, da die als Standard immer
+// dazukommen
+protected void set_std_food_lifetime(int val) {
+ if (val > 0) {
+ if (!time_togo_bad && !is_bad()) {
+ Set(P_LIFETIME,val-(first_reset_length),F_VALUE);
+ // Anzahl der Resets richtet sich nach dem Mittelwert
+ Set(P_RESET_LIFETIME,to_int((val-(first_reset_length))
+ /(__RESET_TIME__*0.75))+1,F_VALUE);
+ set_next_reset(val);
+ }
+ }
+ else {
+ write("Da ist was schief gelaufen! Sprich mal mit einem Magier.\n");
+ raise_error("setting P_LIFETIME to invalid int value: "+
+ to_string(val)+"\n");
+ }
+}
+
+// Anzahl der Resets als Lebenszeit
+void _set_std_food_lifetime_reset(int value) {
+ if (value < 1) value = 1;
+
+ Set(P_RESET_LIFETIME,value,F_VALUE);
+ // per Zufall die Laenge der einzelnen Resets berechnen
+ int length = first_reset_length;
+ foreach(int i: value) {
+ length += to_int((__RESET_TIME__ + random(__RESET_TIME__)) / 2);
+ }
+ set_std_food_lifetime(length);
+}
+
+// Flag, ob Speise "essbar" ist
+public int is_eatable() {
+ return QueryProp(P_FOOD) > 0;
+}
+
+// Flag, ob Speise "trinkbar" ist
+public int is_drinkable() {
+ return QueryProp(P_FOOD) == 0 && QueryProp(P_DRINK) > 0;
+}
+
+// Flag, ob noch Portionen der Speise vorhanden sind
+public int is_not_empty() {
+ return QueryProp(P_PORTIONS) > 0;
+}
+
+// Macht eine Speise leer bzw. zerstoert sie.
+// Muss beim Ueberschreiben immer als letztes aufgerufen werden.
+// Diese Methode wird aufgerufen, wenn ein Behaelter leergefuttert wird
+// oder der Inhalt zerstoert werden soll
+// Rueckgabewert: Ergebnis von remove() bzw. 0, wenn Objekt nicht
+// zerstoert werden muss
+// Beim Aufruf bitte IMMER das Ergebnis pruefen, damit keine Aufrufe an
+// geloeschten Objekten passieren! if (make_empty()) return ...;
+public int make_empty() {
+ mixed props = QueryProp(P_EMPTY_PROPS);
+ if (mappingp(props)) {
+ foreach(string key:m_indices(props)) {
+ if (key == P_IDS) {
+ RemoveId(QueryProp(P_IDS));
+ AddId(QueryProp(ID_BACKUP));
+ AddId(props[key]);
+ }
+ else if (key == P_ADJECTIVES) {
+ RemoveId(QueryProp(P_ADJECTIVES));
+ AddAdjective(QueryProp(ADJ_BACKUP));
+ AddAdjective(props[key]);
+ }
+ else {
+ SetProp(key,props[key]);
+ }
+ }
+
+ // Sicherheitshalber :-)
+ SetProp(P_PORTIONS,0);
+ return 0;
+ }
+ else {
+ return remove(1);
+ }
+}
+
+// wird aufgerufen, wenn die Speise schlecht war und der Removetimer
+// abgelaufen ist
+// Zerstoert die Speise oder den Inhalt eines Behaelters
+// Rueckgabewert: Ergebnis von remove() bzw. 0, wenn Objekt nicht
+// zerstoert werden muss
+public int make_destroy() {
+ message(P_REMOVE_MSG);
+ set_next_reset(-1);
+ return make_empty(); // Leermachen oder zerstoeren
+}
+
+// Laesst die Speise schlecht werden (mit Meldungen)
+// muss beim Ueberschreiben immer mit aufgerufen werden
+// Rueckgabewert: Ergebnis von remove() bzw. 0, wenn Objekt nicht
+// zerstoert werden muss
+// Beim Aufruf bitte IMMER das Ergebnis pruefen, damit keine Aufrufe an
+// geloeschten Objekten passieren! if (make_bad()) return ...;
+public int make_bad() {
+ time_gone_bad = time();
+ if (is_not_empty()) {
+ message(P_BAD_MSG);
+ }
+ if (QueryProp(P_DESTROY_BAD) == DESTROY_BAD && !QueryProp(P_EMPTY_PROPS)) {
+ return remove(1);
+ }
+ return 0;
+}
+
+// Startet den Timer zum Schlechtwerden der Speise
+public void start_lifetime() {
+ // Test, ob Lebensmittel schlecht werden darf
+ if (!QueryProp(P_NO_BAD) && !time_togo_bad) {
+ start_life = time();
+ int zeit = QueryProp(P_LIFETIME);
+ // Zeitpunkt des Schlechtwerdens
+ time_togo_bad = start_life + zeit;
+ // Zeitpunkt des Zerstoerens
+ time_to_remove = time_togo_bad + QueryProp(P_DESTROY_BAD);
+ my_set_next_reset(zeit);
+ }
+}
+
+// Reset wird in 2 Situationen aufgerufen:
+// 1. Timer zum schlecht werden ist abgelaufen, das Futter muss also
+// schlecht werden und evtl. der Timer zum Zerstoeren gestartet werden
+// 2. Timer zum Zerstoeren ist abgelaufen, also wird Futter zerstoert.
+// Wird der Reset aus irgendeinem Grund zu falschen Zeiten aufgerufen,
+// wird der naechste Reset korrekt initialisiert.
+void reset() {
+ // wenn kein env, Abbruch und reset abschalten.
+ if (!environment()) {
+ set_next_reset(-1);
+ return;
+ }
+
+ // Test, ob Lebensmittel schlecht werden darf
+ if (!QueryProp(P_NO_BAD)) {
+ if (!is_bad()) {
+ // Test, ob Timer laeuft
+ if (time_togo_bad) {
+ // Pruefen, ob der Reset so in etwa zur richtigen Zeit aufgerufen wurde
+ // 10% Abweichung sind erlaubt
+ int diff = time() - time_togo_bad;
+ int std = to_int(QueryProp(P_LIFETIME)/10);
+ if (abs(diff) < std || diff > 0) {
+ if (make_bad()) return;
+ // Reset zum Zerstoeren vorbereiten
+ if (QueryProp(P_DESTROY_BAD) > 0) {
+ my_set_next_reset(time_to_remove - time());
+ }
+ else {
+ set_next_reset(-1);
+ }
+ }
+ else {
+ // Reset nochmal zum Ablauf der Frist
+ my_set_next_reset(abs(diff));
+ }
+ }
+ }
+ else if (time_to_remove && QueryProp(P_DESTROY_BAD) > 0) {
+ // wir sind im Reset nach dem Schlechtwerden
+ int diff = time() - time_to_remove;
+ int std = to_int((QueryProp(P_LIFETIME)+QueryProp(P_DESTROY_BAD))/10);
+ // Pruefen, ob der Reset so in etwa zur richtigen Zeit aufgerufen wurde
+ // 10% Abweichung sind erlaubt
+ if (abs(diff) < std || diff > 0) {
+ if (make_destroy()) return; // Leermachen oder zerstoeren
+ }
+ else {
+ // Reset nochmal zum Ablauf der Frist
+ my_set_next_reset(abs(diff));
+ }
+ }
+ } // if (P_NO_BAD)
+
+ ::reset();
+}
+
+private int safety_check() {
+ // Damit ein Spieler auch gaaaanz sicher nicht Speisen ausserhalb der
+ // P_LIFETIME nutzen kann ...
+ if (time_togo_bad && !is_bad() && time() > time_togo_bad) {
+ if (make_bad()) return 0;
+ // Reset zum Zerstoeren vorbereiten
+ if (QueryProp(P_DESTROY_BAD) > 0) {
+ my_set_next_reset(time_to_remove - time());
+ }
+ else {
+ set_next_reset(-1);
+ }
+ return 0;
+ }
+ else if (time_to_remove && time() > time_to_remove
+ && QueryProp(P_DESTROY_BAD) > 0) {
+ make_destroy(); // Leermachen oder zerstoeren
+ return 0;
+ }
+ return 1;
+}
+
+// Pruefung zum Starten ausgelagert, da das im init und in
+// NotifyMove gebraucht wird
+private void check_start_timer(object oldenv) {
+ // Test, ob Lebensmittel schlecht werden kann
+ if (!QueryProp(P_NO_BAD) && !time_togo_bad) {
+ // Wenn wir irgendwie in einem Spieler stecken oder ein Spieler in der
+ // Umgebung ist oder das Futter mehrfach bewegt wurde
+ if (sizeof(filter(all_environment(),#'query_once_interactive))
+ || sizeof(filter(all_inventory(environment()),#'query_once_interactive))
+ || objectp(oldenv)) {
+ start_lifetime();
+ }
+ }
+ else {
+ // Damit ein Spieler auch gaaaanz sicher nicht Speisen ausserhalb
+ // der P_LIFETIME nutzen kann ...
+ safety_check();
+ }
+}
+
+// hier wird geprueft, ob das Futter dem Spieler zugaenglich ist.
+void init() {
+ ::init();
+ check_start_timer(environment());
+}
+
+// hier wird geprueft, ob das Futter dem Spieler zugaenglich ist.
+// das ist sicherer als nur im init()
+protected void NotifyMove(object dest, object oldenv, int method) {
+ ::NotifyMove(dest, oldenv, method);
+ check_start_timer(oldenv);
+}
+
+void create() {
+ // Sicherheitshalber,
+ // falls jemand die Blueprint mit Props initialisieren will
+ ::create();
+ Set(P_LIFETIME, #'set_std_food_lifetime, F_SET_METHOD);
+ Set(P_LIFETIME, PROTECTED, F_MODE_AS);
+
+ time_togo_bad = 0;
+ time_to_remove = 0;
+ time_gone_bad = 0;
+
+ // Standardlaufzeit 1 Reset
+ first_reset_length = to_int((__RESET_TIME__ + random(__RESET_TIME__)) / 2);
+ // Reset wird erstmal abgeschaltet, das wird im NotifyMove geprueft
+ set_next_reset(-1);
+
+ SetProp(P_SHORT,"Ein Lebensmittel");
+ SetProp(P_LONG,"Das ist ein Lebensmittel.\n");
+ SetProp(P_NAME,"Lebensmittel");
+ SetProp(P_MATERIAL, MAT_MISC_FOOD);
+ SetProp(P_GENDER,NEUTER);
+ SetProp(P_WEIGHT,50);
+ SetProp(P_VALUE,10);
+ SetProp(P_PORTIONS,1); // einmal Abbeissen
+ SetProp(P_DESTROY_BAD,DESTROY_BAD); // Zerstoeren beim Schlechtwerden
+ SetProp(P_DISTRIBUTION,HD_STANDARD); // Heilung per Standardverteilung (5/hb)
+
+ SetProp(P_CONSUME_MSG,"@WER2 konsumiert @WEN1.");
+ SetProp(P_EATER_MSG,"Du konsumierst @WEN1.");
+ SetProp(P_EMPTY_MSG,"@WER1 ist bereits leer.");
+ SetProp(P_NOFOOD_MSG,"@WEN1 kann man nicht essen!");
+ SetProp(P_NODRINK_MSG,"@WEN1 kann man nicht trinken!");
+ SetProp(P_BAD_MSG,"@WER1 verdirbt.");
+ SetProp(P_FOOD_FULL_MSG,"Du bist zu satt, das schaffst Du nicht mehr.");
+ SetProp(P_DRINK_FULL_MSG,"So viel kannst Du im Moment nicht trinken.");
+ SetProp(P_ALC_FULL_MSG,"Soviel Alkohol vertraegst Du nicht mehr.");
+ SetProp(P_ENV_MSG,"Vielleicht solltest Du @WEN1 vorher nehmen.");
+ SetProp(P_REMOVE_MSG,"@WER1 zerfaellt zu Staub.");
+
+ // Sichern der Standards
+ SetProp(ID_BACKUP,QueryProp(P_IDS));
+ SetProp(ADJ_BACKUP,QueryProp(P_ADJECTIVES));
+
+ AddId(({"lebensmittel","nahrung","\nfood"}));
+
+ AddCmd(({"iss","esse"}),"cmd_eat");
+ AddCmd(({"trink","trinke"}),"cmd_drink");
+}
+
+// Aendert Werte der Speise, wenn sie vergammelt ist und konsumiert wird
+protected void consume_bad(mapping entry_info) {
+ entry_info[P_HP] = 0;
+ entry_info[P_SP] = 0;
+ entry_info[H_EFFECTS] = ([P_POISON:1]);
+}
+
+// Stellt Mapping zum Konsumieren zusammen und konsumiert.
+// kann mit testonly=1 aufgerufen werden, um zu pruefen, ob konsumieren klappt
+// Gibt das Ergebnis von living->consume() zurueck:
+// >0 -> erfolgreich konsumiert
+// <0 -> nicht konsumiert (siehe Hilfe zu consume)
+protected varargs int try_consume(object consumer, int testonly) {
+ mapping entry_info = ([P_FOOD:QueryProp(P_FOOD),
+ P_DRINK:QueryProp(P_DRINK),
+ P_HP:QueryProp(P_HP),
+ P_SP:QueryProp(P_SP),
+ P_POISON:QueryProp(P_POISON),
+ P_ALCOHOL:QueryProp(P_ALCOHOL),
+ H_DISTRIBUTION:QueryProp(P_DISTRIBUTION)]);
+
+ if (is_bad()) consume_bad(entry_info);
+
+ int result = (int)consumer->consume(entry_info, testonly);
+ if (!result) {
+ tell_object(consumer,
+ "Da ist was schief gelaufen! Sprich mal mit einem Magier.\n");
+ raise_error("living->consume() mit falschen Parametern aufgerufen:\n"+
+ sprintf("%O\n",entry_info));
+ }
+
+ return result;
+}
+
+// Konsumieren war erfolgreich
+// Hier kann man beim Ueberschreiben noch zusaetzliche Sachen machen
+// P_PORTIONS ist bereits runtergezaehlt, Speise ist aber noch nicht leer!
+// make_empty() wird also eventuell noch danach aufgerufen
+// entspricht alter Func BeimEssen()
+protected void success_consume(object consumer) {
+ tell_room(environment(consumer),eval_property(P_CONSUME_MSG,consumer),({consumer}));
+ tell_object(consumer,eval_property(P_EATER_MSG,consumer));
+}
+
+// Konsumieren war nicht erfolgreich
+// Hier kann man beim Ueberschreiben noch zusaetzliche Sachen machen
+// in reason wird der Grund des Fehlschlagens uebergeben (siehe 'man consume')
+protected void failed_consume(object consumer, int reason) {
+ if (reason & HC_MAX_FOOD_REACHED)
+ tell_object(consumer,eval_property(P_FOOD_FULL_MSG,consumer));
+ else if (reason & HC_MAX_DRINK_REACHED)
+ tell_object(consumer,eval_property(P_DRINK_FULL_MSG,consumer));
+ else if (reason & HC_MAX_ALCOHOL_REACHED)
+ tell_object(consumer,eval_property(P_ALC_FULL_MSG,consumer));
+}
+
+// Konsumiert die Speise
+// Gibt das Ergebnis von living->consume() zurueck:
+// >0 -> erfolgreich konsumiert
+// <0 -> nicht konsumiert (siehe Hilfe zu consume)
+protected int consume(object consumer) {
+ if (!objectp(consumer) || !living(consumer)) {
+ raise_error("argument pl not a living:\n"+
+ sprintf("%O\n",consumer));
+ }
+ // damit abgelaufene Speisen auch wirklich abgelaufen sind
+ if (!safety_check()) return 0;
+
+ if (!is_not_empty()) {
+ notify_fail(eval_property(P_EMPTY_MSG,consumer));
+ return 0;
+ }
+ int result = try_consume(consumer);
+ if (result > 0) {
+ SetProp(P_PORTIONS,QueryProp(P_PORTIONS)-1);
+ success_consume(consumer);
+ if (!is_not_empty()) make_empty();
+ }
+ else if (result < 0) {
+ failed_consume(consumer,result);
+ }
+ return result;
+}
+
+// Futtern
+int cmd_eat(string str) {
+ notify_fail("WAS moechtest Du essen?\n");
+ if (!str || !id(str)) return 0;
+ object env = environment(this_object());
+ if (env != this_player() && QueryProp(P_ENV_MSG)) {
+ notify_fail(eval_property(P_ENV_MSG,env));
+ return 0;
+ }
+
+ if (!is_eatable() && !is_drinkable()) {
+ write("Mit diesem Futter stimmt was nicht!"
+ " Sprich mal mit einem Magier.\n");
+ raise_error("Food ohne Werte.\n");
+ return 0;
+ }
+
+ if (!is_eatable()) {
+ notify_fail(eval_property(P_NOFOOD_MSG,env));
+ return 0;
+ }
+
+ return consume(this_player());
+}
+
+// Trinken
+int cmd_drink(string str) {
+ notify_fail("WAS moechtest Du trinken?\n");
+ if (!str || !id(str)) return 0;
+ object env = environment(this_object());
+ if (env != this_player() && QueryProp(P_ENV_MSG)) {
+ notify_fail(eval_property(P_ENV_MSG,env));
+ return 0;
+ }
+
+ if (!is_eatable() && !is_drinkable()) {
+ write("Mit diesem Futter stimmt was nicht!"
+ " Sprich mal mit einem Magier.\n");
+ raise_error("Food ohne Werte.\n");
+ return 0;
+ }
+
+ if (!is_drinkable()) {
+ notify_fail(eval_property(P_NODRINK_MSG,env));
+ return 0;
+ }
+
+ return consume(this_player());
+}
+
+//============================================================================
+// Kompatibilitaetscode
+// um eventuell vergessenes Food oder Zugriff von aussen auf altes Food
+// mitzubekommen
+
+nosave deprecated int alc, alc_pp, food, food_pp, heal, p, soft, soft_pp, c;
+
+deprecated int eat_this( string str ) {
+ return cmd_eat(str);
+}
+
+deprecated int drink_this(string str) {
+ return cmd_drink(str);
+}
+
+deprecated void MakeDrink() {
+ SetProp(P_DRINK,1);
+ SetProp(P_FOOD,0);
+}
+
+deprecated mixed _query_old_is_food() {
+ return is_eatable();
+}
+
+deprecated void _set_old_is_food(mixed value) {
+ SetProp(P_DRINK,0);
+ SetProp(P_FOOD,value);
+}
+
+deprecated mixed _query_old_is_drink() {
+ return is_drinkable();
+}
+
+deprecated void _set_old_is_drink(mixed value) {
+ SetProp(P_DRINK,value);
+ SetProp(P_FOOD,0);
+}
+
+deprecated mixed _query_old_is_full() {
+ return is_not_empty();
+}
+
+deprecated void _set_old_is_full(mixed value) {
+ SetProp(P_PORTIONS,value);
+}
+
+deprecated mixed _query_old_alc() {
+ return QueryProp(P_ALCOHOL);
+}
+
+deprecated void _set_old_alc(mixed value) {
+ SetProp(P_ALCOHOL,value);
+}
+
+deprecated mixed _query_old_water() {
+ return QueryProp(P_DRINK);
+}
+
+deprecated void _set_old_water(mixed value) {
+ SetProp(P_DRINK,value);
+}
+
+deprecated mixed _query_old_food_size() {
+ return QueryProp(P_FOOD);
+}
+
+deprecated void _set_old_food_size(mixed value) {
+ SetProp(P_FOOD,value);
+}
+
+deprecated mixed _query_old_potion() {
+ return QueryProp(P_PORTIONS);
+}
+
+deprecated void _set_old_potion(mixed value) {
+ SetProp(P_PORTIONS,value);
+}
+
+deprecated mixed _query_old_heal_hp() {
+ return QueryProp(P_HP);
+}
+
+deprecated void _set_old_heal_hp(mixed value) {
+ SetProp(P_HP,value);
+}
+
+deprecated mixed _query_old_heal_sp() {
+ return QueryProp(P_SP);
+}
+
+deprecated void _set_old_heal_sp(mixed value) {
+ SetProp(P_SP,value);
+}
+
+deprecated mixed _query_old_bad() {
+ return is_bad();
+}
+
+deprecated void _set_old_bad(mixed value) {
+ return;
+}
+
+deprecated mixed _query_old_mess() {
+ return QueryProp(P_CONSUME_MSG);
+}
+
+deprecated void _set_old_mess(mixed value) {
+ SetProp(P_CONSUME_MSG,value);
+}
+
+deprecated mixed _query_old_eater() {
+ return QueryProp(P_EATER_MSG);
+}
+
+deprecated void _set_old_eater(mixed value) {
+ SetProp(P_EATER_MSG,value);
+}
+
+deprecated mixed _query_old_poison() {
+ return QueryProp(P_POISON);
+}
+
+deprecated void _set_old_poison(mixed value) {
+ SetProp(P_POISON,value);
+}
+
+// interne Methode
+private mixed get_old_empty(string prop) {
+ mixed props = QueryProp(P_EMPTY_PROPS);
+ if (mappingp(props)) return props[prop];
+ return 0;
+}
+// interne Methode
+private void set_old_empty(string prop, mixed value) {
+ mixed props = QueryProp(P_EMPTY_PROPS);
+ if (!mappingp(props)) props = ([prop:value]);
+ else props[prop] = value;
+ SetProp(P_EMPTY_PROPS,props);
+}
+
+deprecated mixed _query_old_empty_con() {
+ return get_old_empty(P_SHORT);
+}
+
+deprecated void _set_old_empty_con(mixed value) {
+ set_old_empty(P_SHORT,value);
+}
+
+deprecated mixed _query_old_empty_gender() {
+ return get_old_empty(P_GENDER);
+}
+
+deprecated void _set_old_empty_gender(mixed value) {
+ set_old_empty(P_GENDER,value);
+}
+
+deprecated mixed _query_old_empty_id() {
+ return get_old_empty(P_IDS);
+}
+
+deprecated void _set_old_empty_id(mixed value) {
+ set_old_empty(P_IDS,value);
+}
+
+deprecated mixed _query_old_empty_long() {
+ return get_old_empty(P_LONG);
+}
+
+deprecated void _set_old_empty_long(mixed value) {
+ set_old_empty(P_LONG,value);
+}
+
+deprecated mixed _query_old_no_con() {
+ return mappingp(QueryProp(P_EMPTY_PROPS));
+}
+
+deprecated void _set_old_no_con(mixed value) {
+ if (value) SetProp(P_EMPTY_PROPS,([]));
+ else SetProp(P_EMPTY_PROPS,0);
+}
+
+// Mupfel
+deprecated int Essbar() {
+ return 1;
+}
+
+deprecated mixed _query_food_info() {
+ return ([]);
+}
+
+deprecated void _set_food_info(mixed value) {
+ return;
+}
+
+// Troy
+deprecated void food_decay() {
+ return;
+}
+
+deprecated int eat_me(string str) {
+ return 0;
+}