blob: 7b75921ded77e4daca091f59e2a23a6ed7ff420a [file] [log] [blame]
MG Mud User88f12472016-06-24 23:31:02 +02001// MorgenGrauen MUDlib
2//
3// /std/food.c - Standardobjekt fuer Lebensmittel
4//
5// $Id: food.c 8248 2012-11-23 21:28:04Z Zesstra $
6#pragma strict_types,save_types,rtt_checks
7#pragma no_clone
8#pragma pedantic,range_check
9
10inherit "/std/thing";
11
12#include <food.h>
13#include <living/life.h>
14#include <break_string.h>
15
16// Standard-IDs und -Adjektive muessen gesichert werden
17#define ID_BACKUP "std_food_id_backup"
18#define ADJ_BACKUP "std_food_adj_backup"
19
20// Zeitpunkt, an dem die Speise verdorben ist
21private nosave int time_gone_bad;
22
23// Zeitpunkt, an dem die Speise verderben darf
24// wird immer erst gesetzt, wenn ein Spieler hiermit in Beruehrung kommt
25private nosave int time_togo_bad;
26
27// Zeitpunkt, an dem die Speise zerstoert werden darf
28// wird immer erst gesetzt, wenn ein Spieler hiermit in Beruehrung kommt
29private nosave int time_to_remove;
30
31// Zeitpunkt, ab dem die Speise mit einem Spieler in Beruehrung kam
32// bei ewig haltbaren Speisen ist sie immer 0;
33private nosave int start_life = 0;
34
35// Dauer des ersten Resets
36private nosave int first_reset_length = 0;
37
38// Wertet Properties aus (Ersetzungen werden durchgefuehrt)
39protected mixed eval_property(string val,object consumer) {
40 mixed what = QueryProp(val);
41 if (stringp(what)) {
42 what=capitalize(replace_personal(what,({this_object(),consumer}),1));
43 }
44 return break_string(what,78,"",BS_LEAVE_MY_LFS);
45}
46
47// wird nur verwendet, wenn der gesetzte Reset ein Timerende darstellt,
48// um zu garantieren, dass der nicht abgestellt wird.
49// Zugegebenenermassen keine schoener Hack :-/
50private void my_set_next_reset(int zeit) {
51 set_next_reset(zeit);
52 // Damit der Reset auch wirklich ausgefuehrt wird ...
53 call_out(#'id,1);
54}
55
56// Ausgabe von Meldungen an Besitzer oder Raum
57protected void message(string prop) {
58 object env = environment(this_object());
59 if (objectp(env)) {
60 if (interactive(env)) {
61 tell_object(env,
62 break_string(eval_property(prop,env),78,"",BS_LEAVE_MY_LFS));
63 }
64 else if(!living(env)) {
65 tell_room(env,
66 break_string(eval_property(prop,0),78,"",BS_LEAVE_MY_LFS));
67 }
68 }
69}
70
71// Flag, ob die Speise verdorben ist
72public int is_bad() {
73 return time_gone_bad > 0;
74}
75
76// Anzahl der Sekunden, die das Lebensmittel bereits hinter sich hat,
77// seit es mit einem Spieler in Beruehrung kam
78public int get_current_lifetime() {
79 if (!start_life) return 0;
80 return time() - start_life;
81}
82
83// Berechnet den Wert der Speise korrekt
84int _query_value() {
85 int result = 0;
86 if (!is_bad()) {
87 result += to_int(QueryProp(P_PORTIONS)*Query(P_VALUE,F_VALUE));
88 }
89 if (mappingp(QueryProp(P_EMPTY_PROPS))) {
90 result += QueryProp(P_EMPTY_PROPS)[P_VALUE];
91 }
92 return result;
93}
94
95// Berechnet den Wert der Speise korrekt
96int _query_weight() {
97 int result = to_int(QueryProp(P_PORTIONS)*Query(P_WEIGHT,F_VALUE));
98 if (mappingp(QueryProp(P_EMPTY_PROPS))) {
99 result += QueryProp(P_EMPTY_PROPS)[P_WEIGHT];
100 }
101 return result;
102}
103
104// Dauer des ersten Resets wird wieder hinzugerechnet
105// damit wird bei Nichtsetzen der Prop der Standard geliefert
106int _query_std_food_lifetime() {
107 return Query(P_LIFETIME,F_VALUE)+(first_reset_length);
108}
109
110// Setter fuer die Lifetime, damit die Resettime immer mitkorrigiert wird
111// und Dauer des ersten Resets abgezogen werden, da die als Standard immer
112// dazukommen
113protected void set_std_food_lifetime(int val) {
114 if (val > 0) {
115 if (!time_togo_bad && !is_bad()) {
116 Set(P_LIFETIME,val-(first_reset_length),F_VALUE);
117 // Anzahl der Resets richtet sich nach dem Mittelwert
118 Set(P_RESET_LIFETIME,to_int((val-(first_reset_length))
119 /(__RESET_TIME__*0.75))+1,F_VALUE);
120 set_next_reset(val);
121 }
122 }
123 else {
124 write("Da ist was schief gelaufen! Sprich mal mit einem Magier.\n");
125 raise_error("setting P_LIFETIME to invalid int value: "+
126 to_string(val)+"\n");
127 }
128}
129
130// Anzahl der Resets als Lebenszeit
131void _set_std_food_lifetime_reset(int value) {
132 if (value < 1) value = 1;
133
134 Set(P_RESET_LIFETIME,value,F_VALUE);
135 // per Zufall die Laenge der einzelnen Resets berechnen
136 int length = first_reset_length;
137 foreach(int i: value) {
138 length += to_int((__RESET_TIME__ + random(__RESET_TIME__)) / 2);
139 }
140 set_std_food_lifetime(length);
141}
142
143// Flag, ob Speise "essbar" ist
144public int is_eatable() {
145 return QueryProp(P_FOOD) > 0;
146}
147
148// Flag, ob Speise "trinkbar" ist
149public int is_drinkable() {
150 return QueryProp(P_FOOD) == 0 && QueryProp(P_DRINK) > 0;
151}
152
153// Flag, ob noch Portionen der Speise vorhanden sind
154public int is_not_empty() {
155 return QueryProp(P_PORTIONS) > 0;
156}
157
158// Macht eine Speise leer bzw. zerstoert sie.
159// Muss beim Ueberschreiben immer als letztes aufgerufen werden.
160// Diese Methode wird aufgerufen, wenn ein Behaelter leergefuttert wird
161// oder der Inhalt zerstoert werden soll
162// Rueckgabewert: Ergebnis von remove() bzw. 0, wenn Objekt nicht
163// zerstoert werden muss
164// Beim Aufruf bitte IMMER das Ergebnis pruefen, damit keine Aufrufe an
165// geloeschten Objekten passieren! if (make_empty()) return ...;
166public int make_empty() {
167 mixed props = QueryProp(P_EMPTY_PROPS);
168 if (mappingp(props)) {
169 foreach(string key:m_indices(props)) {
170 if (key == P_IDS) {
171 RemoveId(QueryProp(P_IDS));
172 AddId(QueryProp(ID_BACKUP));
173 AddId(props[key]);
174 }
175 else if (key == P_ADJECTIVES) {
176 RemoveId(QueryProp(P_ADJECTIVES));
177 AddAdjective(QueryProp(ADJ_BACKUP));
178 AddAdjective(props[key]);
179 }
180 else {
181 SetProp(key,props[key]);
182 }
183 }
184
185 // Sicherheitshalber :-)
186 SetProp(P_PORTIONS,0);
187 return 0;
188 }
189 else {
190 return remove(1);
191 }
192}
193
194// wird aufgerufen, wenn die Speise schlecht war und der Removetimer
195// abgelaufen ist
196// Zerstoert die Speise oder den Inhalt eines Behaelters
197// Rueckgabewert: Ergebnis von remove() bzw. 0, wenn Objekt nicht
198// zerstoert werden muss
199public int make_destroy() {
200 message(P_REMOVE_MSG);
201 set_next_reset(-1);
202 return make_empty(); // Leermachen oder zerstoeren
203}
204
205// Laesst die Speise schlecht werden (mit Meldungen)
206// muss beim Ueberschreiben immer mit aufgerufen werden
207// Rueckgabewert: Ergebnis von remove() bzw. 0, wenn Objekt nicht
208// zerstoert werden muss
209// Beim Aufruf bitte IMMER das Ergebnis pruefen, damit keine Aufrufe an
210// geloeschten Objekten passieren! if (make_bad()) return ...;
211public int make_bad() {
212 time_gone_bad = time();
213 if (is_not_empty()) {
214 message(P_BAD_MSG);
215 }
216 if (QueryProp(P_DESTROY_BAD) == DESTROY_BAD && !QueryProp(P_EMPTY_PROPS)) {
217 return remove(1);
218 }
219 return 0;
220}
221
222// Startet den Timer zum Schlechtwerden der Speise
223public void start_lifetime() {
224 // Test, ob Lebensmittel schlecht werden darf
225 if (!QueryProp(P_NO_BAD) && !time_togo_bad) {
226 start_life = time();
227 int zeit = QueryProp(P_LIFETIME);
228 // Zeitpunkt des Schlechtwerdens
229 time_togo_bad = start_life + zeit;
230 // Zeitpunkt des Zerstoerens
231 time_to_remove = time_togo_bad + QueryProp(P_DESTROY_BAD);
232 my_set_next_reset(zeit);
233 }
234}
235
236// Reset wird in 2 Situationen aufgerufen:
237// 1. Timer zum schlecht werden ist abgelaufen, das Futter muss also
238// schlecht werden und evtl. der Timer zum Zerstoeren gestartet werden
239// 2. Timer zum Zerstoeren ist abgelaufen, also wird Futter zerstoert.
240// Wird der Reset aus irgendeinem Grund zu falschen Zeiten aufgerufen,
241// wird der naechste Reset korrekt initialisiert.
242void reset() {
243 // wenn kein env, Abbruch und reset abschalten.
244 if (!environment()) {
245 set_next_reset(-1);
246 return;
247 }
248
249 // Test, ob Lebensmittel schlecht werden darf
250 if (!QueryProp(P_NO_BAD)) {
251 if (!is_bad()) {
252 // Test, ob Timer laeuft
253 if (time_togo_bad) {
254 // Pruefen, ob der Reset so in etwa zur richtigen Zeit aufgerufen wurde
255 // 10% Abweichung sind erlaubt
256 int diff = time() - time_togo_bad;
257 int std = to_int(QueryProp(P_LIFETIME)/10);
258 if (abs(diff) < std || diff > 0) {
259 if (make_bad()) return;
260 // Reset zum Zerstoeren vorbereiten
261 if (QueryProp(P_DESTROY_BAD) > 0) {
262 my_set_next_reset(time_to_remove - time());
263 }
264 else {
265 set_next_reset(-1);
266 }
267 }
268 else {
269 // Reset nochmal zum Ablauf der Frist
270 my_set_next_reset(abs(diff));
271 }
272 }
273 }
274 else if (time_to_remove && QueryProp(P_DESTROY_BAD) > 0) {
275 // wir sind im Reset nach dem Schlechtwerden
276 int diff = time() - time_to_remove;
277 int std = to_int((QueryProp(P_LIFETIME)+QueryProp(P_DESTROY_BAD))/10);
278 // Pruefen, ob der Reset so in etwa zur richtigen Zeit aufgerufen wurde
279 // 10% Abweichung sind erlaubt
280 if (abs(diff) < std || diff > 0) {
281 if (make_destroy()) return; // Leermachen oder zerstoeren
282 }
283 else {
284 // Reset nochmal zum Ablauf der Frist
285 my_set_next_reset(abs(diff));
286 }
287 }
288 } // if (P_NO_BAD)
289
290 ::reset();
291}
292
293private int safety_check() {
294 // Damit ein Spieler auch gaaaanz sicher nicht Speisen ausserhalb der
295 // P_LIFETIME nutzen kann ...
296 if (time_togo_bad && !is_bad() && time() > time_togo_bad) {
297 if (make_bad()) return 0;
298 // Reset zum Zerstoeren vorbereiten
299 if (QueryProp(P_DESTROY_BAD) > 0) {
300 my_set_next_reset(time_to_remove - time());
301 }
302 else {
303 set_next_reset(-1);
304 }
305 return 0;
306 }
307 else if (time_to_remove && time() > time_to_remove
308 && QueryProp(P_DESTROY_BAD) > 0) {
309 make_destroy(); // Leermachen oder zerstoeren
310 return 0;
311 }
312 return 1;
313}
314
315// Pruefung zum Starten ausgelagert, da das im init und in
316// NotifyMove gebraucht wird
317private void check_start_timer(object oldenv) {
318 // Test, ob Lebensmittel schlecht werden kann
319 if (!QueryProp(P_NO_BAD) && !time_togo_bad) {
320 // Wenn wir irgendwie in einem Spieler stecken oder ein Spieler in der
321 // Umgebung ist oder das Futter mehrfach bewegt wurde
322 if (sizeof(filter(all_environment(),#'query_once_interactive))
323 || sizeof(filter(all_inventory(environment()),#'query_once_interactive))
324 || objectp(oldenv)) {
325 start_lifetime();
326 }
327 }
328 else {
329 // Damit ein Spieler auch gaaaanz sicher nicht Speisen ausserhalb
330 // der P_LIFETIME nutzen kann ...
331 safety_check();
332 }
333}
334
335// hier wird geprueft, ob das Futter dem Spieler zugaenglich ist.
336void init() {
337 ::init();
338 check_start_timer(environment());
339}
340
341// hier wird geprueft, ob das Futter dem Spieler zugaenglich ist.
342// das ist sicherer als nur im init()
343protected void NotifyMove(object dest, object oldenv, int method) {
344 ::NotifyMove(dest, oldenv, method);
345 check_start_timer(oldenv);
346}
347
348void create() {
349 // Sicherheitshalber,
350 // falls jemand die Blueprint mit Props initialisieren will
351 ::create();
352 Set(P_LIFETIME, #'set_std_food_lifetime, F_SET_METHOD);
353 Set(P_LIFETIME, PROTECTED, F_MODE_AS);
354
355 time_togo_bad = 0;
356 time_to_remove = 0;
357 time_gone_bad = 0;
358
359 // Standardlaufzeit 1 Reset
360 first_reset_length = to_int((__RESET_TIME__ + random(__RESET_TIME__)) / 2);
361 // Reset wird erstmal abgeschaltet, das wird im NotifyMove geprueft
362 set_next_reset(-1);
363
364 SetProp(P_SHORT,"Ein Lebensmittel");
365 SetProp(P_LONG,"Das ist ein Lebensmittel.\n");
366 SetProp(P_NAME,"Lebensmittel");
367 SetProp(P_MATERIAL, MAT_MISC_FOOD);
368 SetProp(P_GENDER,NEUTER);
369 SetProp(P_WEIGHT,50);
370 SetProp(P_VALUE,10);
371 SetProp(P_PORTIONS,1); // einmal Abbeissen
372 SetProp(P_DESTROY_BAD,DESTROY_BAD); // Zerstoeren beim Schlechtwerden
373 SetProp(P_DISTRIBUTION,HD_STANDARD); // Heilung per Standardverteilung (5/hb)
374
375 SetProp(P_CONSUME_MSG,"@WER2 konsumiert @WEN1.");
376 SetProp(P_EATER_MSG,"Du konsumierst @WEN1.");
377 SetProp(P_EMPTY_MSG,"@WER1 ist bereits leer.");
378 SetProp(P_NOFOOD_MSG,"@WEN1 kann man nicht essen!");
379 SetProp(P_NODRINK_MSG,"@WEN1 kann man nicht trinken!");
380 SetProp(P_BAD_MSG,"@WER1 verdirbt.");
381 SetProp(P_FOOD_FULL_MSG,"Du bist zu satt, das schaffst Du nicht mehr.");
382 SetProp(P_DRINK_FULL_MSG,"So viel kannst Du im Moment nicht trinken.");
383 SetProp(P_ALC_FULL_MSG,"Soviel Alkohol vertraegst Du nicht mehr.");
384 SetProp(P_ENV_MSG,"Vielleicht solltest Du @WEN1 vorher nehmen.");
385 SetProp(P_REMOVE_MSG,"@WER1 zerfaellt zu Staub.");
386
387 // Sichern der Standards
388 SetProp(ID_BACKUP,QueryProp(P_IDS));
389 SetProp(ADJ_BACKUP,QueryProp(P_ADJECTIVES));
390
391 AddId(({"lebensmittel","nahrung","\nfood"}));
392
393 AddCmd(({"iss","esse"}),"cmd_eat");
394 AddCmd(({"trink","trinke"}),"cmd_drink");
395}
396
397// Aendert Werte der Speise, wenn sie vergammelt ist und konsumiert wird
398protected void consume_bad(mapping entry_info) {
399 entry_info[P_HP] = 0;
400 entry_info[P_SP] = 0;
401 entry_info[H_EFFECTS] = ([P_POISON:1]);
402}
403
404// Stellt Mapping zum Konsumieren zusammen und konsumiert.
405// kann mit testonly=1 aufgerufen werden, um zu pruefen, ob konsumieren klappt
406// Gibt das Ergebnis von living->consume() zurueck:
407// >0 -> erfolgreich konsumiert
408// <0 -> nicht konsumiert (siehe Hilfe zu consume)
409protected varargs int try_consume(object consumer, int testonly) {
410 mapping entry_info = ([P_FOOD:QueryProp(P_FOOD),
411 P_DRINK:QueryProp(P_DRINK),
412 P_HP:QueryProp(P_HP),
413 P_SP:QueryProp(P_SP),
414 P_POISON:QueryProp(P_POISON),
415 P_ALCOHOL:QueryProp(P_ALCOHOL),
416 H_DISTRIBUTION:QueryProp(P_DISTRIBUTION)]);
417
418 if (is_bad()) consume_bad(entry_info);
419
420 int result = (int)consumer->consume(entry_info, testonly);
421 if (!result) {
422 tell_object(consumer,
423 "Da ist was schief gelaufen! Sprich mal mit einem Magier.\n");
424 raise_error("living->consume() mit falschen Parametern aufgerufen:\n"+
425 sprintf("%O\n",entry_info));
426 }
427
428 return result;
429}
430
431// Konsumieren war erfolgreich
432// Hier kann man beim Ueberschreiben noch zusaetzliche Sachen machen
433// P_PORTIONS ist bereits runtergezaehlt, Speise ist aber noch nicht leer!
434// make_empty() wird also eventuell noch danach aufgerufen
435// entspricht alter Func BeimEssen()
436protected void success_consume(object consumer) {
437 tell_room(environment(consumer),eval_property(P_CONSUME_MSG,consumer),({consumer}));
438 tell_object(consumer,eval_property(P_EATER_MSG,consumer));
439}
440
441// Konsumieren war nicht erfolgreich
442// Hier kann man beim Ueberschreiben noch zusaetzliche Sachen machen
443// in reason wird der Grund des Fehlschlagens uebergeben (siehe 'man consume')
444protected void failed_consume(object consumer, int reason) {
445 if (reason & HC_MAX_FOOD_REACHED)
446 tell_object(consumer,eval_property(P_FOOD_FULL_MSG,consumer));
447 else if (reason & HC_MAX_DRINK_REACHED)
448 tell_object(consumer,eval_property(P_DRINK_FULL_MSG,consumer));
449 else if (reason & HC_MAX_ALCOHOL_REACHED)
450 tell_object(consumer,eval_property(P_ALC_FULL_MSG,consumer));
451}
452
453// Konsumiert die Speise
454// Gibt das Ergebnis von living->consume() zurueck:
455// >0 -> erfolgreich konsumiert
456// <0 -> nicht konsumiert (siehe Hilfe zu consume)
457protected int consume(object consumer) {
458 if (!objectp(consumer) || !living(consumer)) {
459 raise_error("argument pl not a living:\n"+
460 sprintf("%O\n",consumer));
461 }
462 // damit abgelaufene Speisen auch wirklich abgelaufen sind
463 if (!safety_check()) return 0;
464
465 if (!is_not_empty()) {
466 notify_fail(eval_property(P_EMPTY_MSG,consumer));
467 return 0;
468 }
469 int result = try_consume(consumer);
470 if (result > 0) {
471 SetProp(P_PORTIONS,QueryProp(P_PORTIONS)-1);
472 success_consume(consumer);
473 if (!is_not_empty()) make_empty();
474 }
475 else if (result < 0) {
476 failed_consume(consumer,result);
477 }
478 return result;
479}
480
481// Futtern
482int cmd_eat(string str) {
483 notify_fail("WAS moechtest Du essen?\n");
484 if (!str || !id(str)) return 0;
485 object env = environment(this_object());
486 if (env != this_player() && QueryProp(P_ENV_MSG)) {
487 notify_fail(eval_property(P_ENV_MSG,env));
488 return 0;
489 }
490
491 if (!is_eatable() && !is_drinkable()) {
492 write("Mit diesem Futter stimmt was nicht!"
493 " Sprich mal mit einem Magier.\n");
494 raise_error("Food ohne Werte.\n");
495 return 0;
496 }
497
498 if (!is_eatable()) {
499 notify_fail(eval_property(P_NOFOOD_MSG,env));
500 return 0;
501 }
502
503 return consume(this_player());
504}
505
506// Trinken
507int cmd_drink(string str) {
508 notify_fail("WAS moechtest Du trinken?\n");
509 if (!str || !id(str)) return 0;
510 object env = environment(this_object());
511 if (env != this_player() && QueryProp(P_ENV_MSG)) {
512 notify_fail(eval_property(P_ENV_MSG,env));
513 return 0;
514 }
515
516 if (!is_eatable() && !is_drinkable()) {
517 write("Mit diesem Futter stimmt was nicht!"
518 " Sprich mal mit einem Magier.\n");
519 raise_error("Food ohne Werte.\n");
520 return 0;
521 }
522
523 if (!is_drinkable()) {
524 notify_fail(eval_property(P_NODRINK_MSG,env));
525 return 0;
526 }
527
528 return consume(this_player());
529}
530
531//============================================================================
532// Kompatibilitaetscode
533// um eventuell vergessenes Food oder Zugriff von aussen auf altes Food
534// mitzubekommen
535
536nosave deprecated int alc, alc_pp, food, food_pp, heal, p, soft, soft_pp, c;
537
538deprecated int eat_this( string str ) {
539 return cmd_eat(str);
540}
541
542deprecated int drink_this(string str) {
543 return cmd_drink(str);
544}
545
546deprecated void MakeDrink() {
547 SetProp(P_DRINK,1);
548 SetProp(P_FOOD,0);
549}
550
551deprecated mixed _query_old_is_food() {
552 return is_eatable();
553}
554
555deprecated void _set_old_is_food(mixed value) {
556 SetProp(P_DRINK,0);
557 SetProp(P_FOOD,value);
558}
559
560deprecated mixed _query_old_is_drink() {
561 return is_drinkable();
562}
563
564deprecated void _set_old_is_drink(mixed value) {
565 SetProp(P_DRINK,value);
566 SetProp(P_FOOD,0);
567}
568
569deprecated mixed _query_old_is_full() {
570 return is_not_empty();
571}
572
573deprecated void _set_old_is_full(mixed value) {
574 SetProp(P_PORTIONS,value);
575}
576
577deprecated mixed _query_old_alc() {
578 return QueryProp(P_ALCOHOL);
579}
580
581deprecated void _set_old_alc(mixed value) {
582 SetProp(P_ALCOHOL,value);
583}
584
585deprecated mixed _query_old_water() {
586 return QueryProp(P_DRINK);
587}
588
589deprecated void _set_old_water(mixed value) {
590 SetProp(P_DRINK,value);
591}
592
593deprecated mixed _query_old_food_size() {
594 return QueryProp(P_FOOD);
595}
596
597deprecated void _set_old_food_size(mixed value) {
598 SetProp(P_FOOD,value);
599}
600
601deprecated mixed _query_old_potion() {
602 return QueryProp(P_PORTIONS);
603}
604
605deprecated void _set_old_potion(mixed value) {
606 SetProp(P_PORTIONS,value);
607}
608
609deprecated mixed _query_old_heal_hp() {
610 return QueryProp(P_HP);
611}
612
613deprecated void _set_old_heal_hp(mixed value) {
614 SetProp(P_HP,value);
615}
616
617deprecated mixed _query_old_heal_sp() {
618 return QueryProp(P_SP);
619}
620
621deprecated void _set_old_heal_sp(mixed value) {
622 SetProp(P_SP,value);
623}
624
625deprecated mixed _query_old_bad() {
626 return is_bad();
627}
628
629deprecated void _set_old_bad(mixed value) {
630 return;
631}
632
633deprecated mixed _query_old_mess() {
634 return QueryProp(P_CONSUME_MSG);
635}
636
637deprecated void _set_old_mess(mixed value) {
638 SetProp(P_CONSUME_MSG,value);
639}
640
641deprecated mixed _query_old_eater() {
642 return QueryProp(P_EATER_MSG);
643}
644
645deprecated void _set_old_eater(mixed value) {
646 SetProp(P_EATER_MSG,value);
647}
648
649deprecated mixed _query_old_poison() {
650 return QueryProp(P_POISON);
651}
652
653deprecated void _set_old_poison(mixed value) {
654 SetProp(P_POISON,value);
655}
656
657// interne Methode
658private mixed get_old_empty(string prop) {
659 mixed props = QueryProp(P_EMPTY_PROPS);
660 if (mappingp(props)) return props[prop];
661 return 0;
662}
663// interne Methode
664private void set_old_empty(string prop, mixed value) {
665 mixed props = QueryProp(P_EMPTY_PROPS);
666 if (!mappingp(props)) props = ([prop:value]);
667 else props[prop] = value;
668 SetProp(P_EMPTY_PROPS,props);
669}
670
671deprecated mixed _query_old_empty_con() {
672 return get_old_empty(P_SHORT);
673}
674
675deprecated void _set_old_empty_con(mixed value) {
676 set_old_empty(P_SHORT,value);
677}
678
679deprecated mixed _query_old_empty_gender() {
680 return get_old_empty(P_GENDER);
681}
682
683deprecated void _set_old_empty_gender(mixed value) {
684 set_old_empty(P_GENDER,value);
685}
686
687deprecated mixed _query_old_empty_id() {
688 return get_old_empty(P_IDS);
689}
690
691deprecated void _set_old_empty_id(mixed value) {
692 set_old_empty(P_IDS,value);
693}
694
695deprecated mixed _query_old_empty_long() {
696 return get_old_empty(P_LONG);
697}
698
699deprecated void _set_old_empty_long(mixed value) {
700 set_old_empty(P_LONG,value);
701}
702
703deprecated mixed _query_old_no_con() {
704 return mappingp(QueryProp(P_EMPTY_PROPS));
705}
706
707deprecated void _set_old_no_con(mixed value) {
708 if (value) SetProp(P_EMPTY_PROPS,([]));
709 else SetProp(P_EMPTY_PROPS,0);
710}
711
712// Mupfel
713deprecated int Essbar() {
714 return 1;
715}
716
717deprecated mixed _query_food_info() {
718 return ([]);
719}
720
721deprecated void _set_food_info(mixed value) {
722 return;
723}
724
725// Troy
726deprecated void food_decay() {
727 return;
728}
729
730deprecated int eat_me(string str) {
731 return 0;
732}