MG Mud User | 88f1247 | 2016-06-24 23:31:02 +0200 | [diff] [blame^] | 1 | // 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 | |
| 10 | inherit "/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 |
| 21 | private 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 |
| 25 | private 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 |
| 29 | private 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; |
| 33 | private nosave int start_life = 0; |
| 34 | |
| 35 | // Dauer des ersten Resets |
| 36 | private nosave int first_reset_length = 0; |
| 37 | |
| 38 | // Wertet Properties aus (Ersetzungen werden durchgefuehrt) |
| 39 | protected 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 :-/ |
| 50 | private 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 |
| 57 | protected 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 |
| 72 | public 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 |
| 78 | public int get_current_lifetime() { |
| 79 | if (!start_life) return 0; |
| 80 | return time() - start_life; |
| 81 | } |
| 82 | |
| 83 | // Berechnet den Wert der Speise korrekt |
| 84 | int _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 |
| 96 | int _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 |
| 106 | int _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 |
| 113 | protected 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 |
| 131 | void _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 |
| 144 | public int is_eatable() { |
| 145 | return QueryProp(P_FOOD) > 0; |
| 146 | } |
| 147 | |
| 148 | // Flag, ob Speise "trinkbar" ist |
| 149 | public int is_drinkable() { |
| 150 | return QueryProp(P_FOOD) == 0 && QueryProp(P_DRINK) > 0; |
| 151 | } |
| 152 | |
| 153 | // Flag, ob noch Portionen der Speise vorhanden sind |
| 154 | public 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 ...; |
| 166 | public 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 |
| 199 | public 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 ...; |
| 211 | public 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 |
| 223 | public 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. |
| 242 | void 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 | |
| 293 | private 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 |
| 317 | private 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. |
| 336 | void 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() |
| 343 | protected void NotifyMove(object dest, object oldenv, int method) { |
| 344 | ::NotifyMove(dest, oldenv, method); |
| 345 | check_start_timer(oldenv); |
| 346 | } |
| 347 | |
| 348 | void 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 |
| 398 | protected 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) |
| 409 | protected 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() |
| 436 | protected 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') |
| 444 | protected 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) |
| 457 | protected 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 |
| 482 | int 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 |
| 507 | int 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 | |
| 536 | nosave deprecated int alc, alc_pp, food, food_pp, heal, p, soft, soft_pp, c; |
| 537 | |
| 538 | deprecated int eat_this( string str ) { |
| 539 | return cmd_eat(str); |
| 540 | } |
| 541 | |
| 542 | deprecated int drink_this(string str) { |
| 543 | return cmd_drink(str); |
| 544 | } |
| 545 | |
| 546 | deprecated void MakeDrink() { |
| 547 | SetProp(P_DRINK,1); |
| 548 | SetProp(P_FOOD,0); |
| 549 | } |
| 550 | |
| 551 | deprecated mixed _query_old_is_food() { |
| 552 | return is_eatable(); |
| 553 | } |
| 554 | |
| 555 | deprecated void _set_old_is_food(mixed value) { |
| 556 | SetProp(P_DRINK,0); |
| 557 | SetProp(P_FOOD,value); |
| 558 | } |
| 559 | |
| 560 | deprecated mixed _query_old_is_drink() { |
| 561 | return is_drinkable(); |
| 562 | } |
| 563 | |
| 564 | deprecated void _set_old_is_drink(mixed value) { |
| 565 | SetProp(P_DRINK,value); |
| 566 | SetProp(P_FOOD,0); |
| 567 | } |
| 568 | |
| 569 | deprecated mixed _query_old_is_full() { |
| 570 | return is_not_empty(); |
| 571 | } |
| 572 | |
| 573 | deprecated void _set_old_is_full(mixed value) { |
| 574 | SetProp(P_PORTIONS,value); |
| 575 | } |
| 576 | |
| 577 | deprecated mixed _query_old_alc() { |
| 578 | return QueryProp(P_ALCOHOL); |
| 579 | } |
| 580 | |
| 581 | deprecated void _set_old_alc(mixed value) { |
| 582 | SetProp(P_ALCOHOL,value); |
| 583 | } |
| 584 | |
| 585 | deprecated mixed _query_old_water() { |
| 586 | return QueryProp(P_DRINK); |
| 587 | } |
| 588 | |
| 589 | deprecated void _set_old_water(mixed value) { |
| 590 | SetProp(P_DRINK,value); |
| 591 | } |
| 592 | |
| 593 | deprecated mixed _query_old_food_size() { |
| 594 | return QueryProp(P_FOOD); |
| 595 | } |
| 596 | |
| 597 | deprecated void _set_old_food_size(mixed value) { |
| 598 | SetProp(P_FOOD,value); |
| 599 | } |
| 600 | |
| 601 | deprecated mixed _query_old_potion() { |
| 602 | return QueryProp(P_PORTIONS); |
| 603 | } |
| 604 | |
| 605 | deprecated void _set_old_potion(mixed value) { |
| 606 | SetProp(P_PORTIONS,value); |
| 607 | } |
| 608 | |
| 609 | deprecated mixed _query_old_heal_hp() { |
| 610 | return QueryProp(P_HP); |
| 611 | } |
| 612 | |
| 613 | deprecated void _set_old_heal_hp(mixed value) { |
| 614 | SetProp(P_HP,value); |
| 615 | } |
| 616 | |
| 617 | deprecated mixed _query_old_heal_sp() { |
| 618 | return QueryProp(P_SP); |
| 619 | } |
| 620 | |
| 621 | deprecated void _set_old_heal_sp(mixed value) { |
| 622 | SetProp(P_SP,value); |
| 623 | } |
| 624 | |
| 625 | deprecated mixed _query_old_bad() { |
| 626 | return is_bad(); |
| 627 | } |
| 628 | |
| 629 | deprecated void _set_old_bad(mixed value) { |
| 630 | return; |
| 631 | } |
| 632 | |
| 633 | deprecated mixed _query_old_mess() { |
| 634 | return QueryProp(P_CONSUME_MSG); |
| 635 | } |
| 636 | |
| 637 | deprecated void _set_old_mess(mixed value) { |
| 638 | SetProp(P_CONSUME_MSG,value); |
| 639 | } |
| 640 | |
| 641 | deprecated mixed _query_old_eater() { |
| 642 | return QueryProp(P_EATER_MSG); |
| 643 | } |
| 644 | |
| 645 | deprecated void _set_old_eater(mixed value) { |
| 646 | SetProp(P_EATER_MSG,value); |
| 647 | } |
| 648 | |
| 649 | deprecated mixed _query_old_poison() { |
| 650 | return QueryProp(P_POISON); |
| 651 | } |
| 652 | |
| 653 | deprecated void _set_old_poison(mixed value) { |
| 654 | SetProp(P_POISON,value); |
| 655 | } |
| 656 | |
| 657 | // interne Methode |
| 658 | private 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 |
| 664 | private 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 | |
| 671 | deprecated mixed _query_old_empty_con() { |
| 672 | return get_old_empty(P_SHORT); |
| 673 | } |
| 674 | |
| 675 | deprecated void _set_old_empty_con(mixed value) { |
| 676 | set_old_empty(P_SHORT,value); |
| 677 | } |
| 678 | |
| 679 | deprecated mixed _query_old_empty_gender() { |
| 680 | return get_old_empty(P_GENDER); |
| 681 | } |
| 682 | |
| 683 | deprecated void _set_old_empty_gender(mixed value) { |
| 684 | set_old_empty(P_GENDER,value); |
| 685 | } |
| 686 | |
| 687 | deprecated mixed _query_old_empty_id() { |
| 688 | return get_old_empty(P_IDS); |
| 689 | } |
| 690 | |
| 691 | deprecated void _set_old_empty_id(mixed value) { |
| 692 | set_old_empty(P_IDS,value); |
| 693 | } |
| 694 | |
| 695 | deprecated mixed _query_old_empty_long() { |
| 696 | return get_old_empty(P_LONG); |
| 697 | } |
| 698 | |
| 699 | deprecated void _set_old_empty_long(mixed value) { |
| 700 | set_old_empty(P_LONG,value); |
| 701 | } |
| 702 | |
| 703 | deprecated mixed _query_old_no_con() { |
| 704 | return mappingp(QueryProp(P_EMPTY_PROPS)); |
| 705 | } |
| 706 | |
| 707 | deprecated 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 |
| 713 | deprecated int Essbar() { |
| 714 | return 1; |
| 715 | } |
| 716 | |
| 717 | deprecated mixed _query_food_info() { |
| 718 | return ([]); |
| 719 | } |
| 720 | |
| 721 | deprecated void _set_food_info(mixed value) { |
| 722 | return; |
| 723 | } |
| 724 | |
| 725 | // Troy |
| 726 | deprecated void food_decay() { |
| 727 | return; |
| 728 | } |
| 729 | |
| 730 | deprecated int eat_me(string str) { |
| 731 | return 0; |
| 732 | } |