| // 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; |
| } |