put_and_get.c-Dateireferenz

#include <language.h>
#include <thing/description.h>
#include <thing/properties.h>
#include <moving.h>
#include <container.h>
#include <defines.h>
#include <wizlevels.h>
Include-Abhängigkeitsdiagramm für put_and_get.c:

gehe zum Quellcode dieser Datei

Makrodefinitionen

#define NEED_PROTOTYPES
#define TME(str)
#define TOB(ob, str)   tell_object(ob, break_string(str, 78, 0, BS_LEAVE_MY_LFS))
#define SAY(str)
#define SAY2(obs, str)
#define NF(str)   _notify_fail(break_string(str, 78, 0, BS_LEAVE_MY_LFS))

Funktionen

private string put_or_get (object o, object dest)
varargs int drop (object o, mixed msg)
varargs int put (object o, object dest, mixed msg)
varargs int pick (object o, mixed msg)
varargs int give (object o, object dest, mixed msg)
varargs int show (object o, object whom, mixed msg)
private object * __find_objects (string *tokens, object env, int is_source)
object * find_objects (string what, object env, int is_source)
varargs int drop_objects (string str, mixed msg)
varargs int put_objects (string str, int casus, string verb, mixed msg)
varargs int pick_objects (string str, int flag, mixed msg)
varargs int give_objects (string str, mixed msg)
varargs int show_objects (string str, mixed msg)
object * moved_objects (void)
object moved_where (void)
static int fallenlassen (string str)
static int werfen (string str)
static int legen (string str)
static int stecken (string str)
static int holen (string str)
static int nehmen (string str)
static int geben (string str)
static int zeigen (string str)
protected void add_put_and_get_commands (void)
object * find_obs (string str, int meth)
int pick_obj (object ob)
int drop_obj (object ob)
int put_obj (object ob, object where)
int give_obj (object ob, object where)

Variablen

private nosave closure cl
private nosave string wen0
private nosave string wen1
private nosave string wer0
private nosave object * last_moved_objects
private nosave object last_moved_where

Makro-Dokumentation

#define NEED_PROTOTYPES

Definiert in Zeile 97 der Datei put_and_get.c.

#define NF ( str   )     _notify_fail(break_string(str, 78, 0, BS_LEAVE_MY_LFS))

Definiert in Zeile 116 der Datei put_and_get.c.

Wird benutzt von __find_objects(), give_objects(), pick_objects(), put_objects() und show_objects().

#define SAY ( str   ) 
Wert:
tell_room(environment(), \
    break_string(str, 78, 0, BS_LEAVE_MY_LFS), ({this_object()}))

Definiert in Zeile 112 der Datei put_and_get.c.

Wird benutzt von auswertung(), drop(), pick(), put() und show().

#define SAY2 ( obs,
str   ) 
Wert:
tell_room(environment(), \
    break_string(str, 78, 0, BS_LEAVE_MY_LFS), ({this_object()}) + obs)

Definiert in Zeile 114 der Datei put_and_get.c.

Wird benutzt von give() und show().

#define TME ( str   ) 
Wert:
tell_object(this_object(), \
    break_string(str, 78, 0, BS_LEAVE_MY_LFS))

Definiert in Zeile 109 der Datei put_and_get.c.

Wird benutzt von drop(), drop_objects(), give(), give_objects(), pick(), pick_objects(), put(), put_objects() und show().

#define TOB ( ob,
str   )     tell_object(ob, break_string(str, 78, 0, BS_LEAVE_MY_LFS))

Definiert in Zeile 111 der Datei put_and_get.c.

Wird benutzt von give() und show().

Dokumentation der Funktionen

private object* __find_objects ( string *  tokens,
object  env,
int  is_source 
)

Definiert in Zeile 571 der Datei put_and_get.c.

Benutzt i, NF, ob(), obs, P_CNT_STATUS, P_PREPOSITION, P_SOURCE_PREPOSITION, present_objects(), WEM und WER.

Wird benutzt von find_objects(), give_objects() und put_objects().

00572 {
00573     object ob, *obs;
00574 
00575     // is_source == 0: Objekt soll nicht bewegt werden ("topf auf herd")
00576     //              1: Objekt soll bewegt werden ("topf von herd")
00577     //              2: intern
00578 
00579     if (!env && sizeof(tokens) > 1 && tokens[<1] == "hier") {
00580         tokens = tokens[..<2];
00581         env = environment();
00582     } else if (!env && sizeof(tokens) > 2 && tokens[<2] == "in")
00583         if (tokens[<1] == "mir" ||
00584             tokens[<1] == "dir") {
00585             tokens = tokens[..<3];
00586             env = this_object();
00587         } else if (tokens[<1] == "raum") {
00588             tokens = tokens[..<3];
00589             env = environment();
00590         }
00591 
00592     for (int i = sizeof(tokens)-1; i > 1; i--) {
00593         if (env)
00594             ob = present(implode(tokens[i..], " "), env);
00595         else
00596             ob = present(implode(tokens[i..], " "), environment()) ||
00597                  present(implode(tokens[i..], " "), this_object());
00598 
00599         if (!ob)
00600             continue;
00601 
00602         if (living(ob)) {
00603             NF("Aber " + ob->name(WER, 1) + " lebt doch!");
00604             continue;
00605         }
00606 
00607         if (ob->QueryProp(P_CNT_STATUS)) {
00608             NF("Aber " + ob->name(WER, 1) + " ist doch geschlossen!");
00609             continue;
00610         }
00611 
00612         if (is_source != 0 &&
00613             tokens[i-1] == ob->QueryProp(P_SOURCE_PREPOSITION))
00614             return ob->present_objects(implode(tokens[..i-2], " "));
00615 
00616         if (tokens[i-1] == ob->QueryProp(P_PREPOSITION))
00617             return __find_objects(tokens[..i-2], ob, is_source ? 2 : 0);
00618 
00619         NF("Du kannst nichts " + tokens[i-1] + " " +
00620            ob->name(WEM, 1) + " nehmen.");
00621     }
00622 
00623     if (is_source == 2)
00624         return ({});
00625 
00626     if (env)
00627         return env->present_objects(implode(tokens, " "));
00628 
00629     if (environment() &&
00630                 sizeof(obs = environment()->present_objects(implode(tokens, " "))))
00631         return obs;
00632 
00633     return present_objects(implode(tokens, " "));
00634 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

protected void add_put_and_get_commands ( void   ) 

Definiert in Zeile 1060 der Datei put_and_get.c.

Wird benutzt von create().

01061 {
01062     add_action("fallenlassen", "lass");
01063     add_action("fallenlassen", "lasse");
01064     add_action("werfen",       "wirf");
01065     add_action("werfen",       "werf");
01066     add_action("werfen",       "werfe");
01067     add_action("legen",        "leg");
01068     add_action("legen",        "lege");
01069     add_action("stecken",      "steck");
01070     add_action("stecken",      "stecke");
01071     add_action("holen",        "hol");
01072     add_action("holen",        "hole");
01073     add_action("nehmen",       "nimm");
01074     add_action("nehmen",       "nehm");
01075     add_action("nehmen",       "nehme");
01076     add_action("geben",        "gebe");
01077     add_action("geben",        "gib");
01078     add_action("zeigen",       "zeig");
01079     add_action("zeigen",       "zeige");
01080 }

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

varargs int drop ( object  o,
mixed  msg 
)

Definiert in Zeile 299 der Datei put_and_get.c.

Benutzt cl, Name(), P_DROP_MSG, put_or_get(), replace_personal(), SAY, TME, WEN, wen0, wen1, WER und wer0.

Wird benutzt von drop_objects().

00300 {
00301     string str;
00302 
00303     // vorher speichern, falls das Objekt zerstoert wird
00304     cl = symbol_function("name", o);
00305     wen0 = funcall(cl, WEN, 0);
00306     wen1 = funcall(cl, WEN, 1);
00307     wer0 = 0;
00308 
00309     if (!msg)
00310         msg = o->QueryProp(P_DROP_MSG);
00311 
00312     if (str = put_or_get(o, environment())) {
00313         TME(str);
00314         return 0;
00315     }
00316 
00317     if (!msg) {
00318         TME("Du laesst " + wen1 + " fallen.");
00319         SAY(Name(WER,1) + " laesst " + wen0 + " fallen.");
00320     } else if (pointerp(msg))
00321         switch (sizeof(msg)) {
00322           // Wenn es zwei Strings gibt, geht die 2. ans Environment
00323           case 2:
00324             SAY(replace_personal(msg[1], ({this_object(), o||wen0}), 1));
00325           case 1:
00326             TME(replace_personal(msg[0], ({this_object(), o||wen1}), 1));
00327             break;
00328           default:
00329             raise_error(sprintf(
00330                 "Falsches Format fuer P_DROP_MSG: %O\n", o||wen1));
00331         }
00332 
00333     return 1;
00334 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

int drop_obj ( object  ob  ) 

Definiert in Zeile 1185 der Datei put_and_get.c.

Wird benutzt von give_notify().

01186 {
01187   if (!ob || ob==this_object() || environment(ob)!=this_object()) return 0;
01188   (void) drop(ob);
01189   return 1;
01190 }

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

varargs int drop_objects ( string  str,
mixed  msg 
)

Definiert in Zeile 660 der Datei put_and_get.c.

Benutzt drop(), find_objects(), last_moved_objects, last_moved_where, obs und TME.

00661 {
00662     object *obs;
00663 
00664     if (!sizeof(obs = find_objects(str, this_object(), 1)))
00665         return 0;
00666 
00667     foreach (object o: obs) {
00668         if (objectp(o))
00669             drop(o, msg);
00670 
00671         if (get_eval_cost() < 100000) {
00672             TME("Den Rest behaeltst Du erst mal.");
00673             last_moved_objects = obs[..member(obs, o)];
00674             last_moved_where = 0;
00675             return 1;
00676         }
00677     }
00678 
00679     last_moved_objects = obs;
00680     last_moved_where = 0;
00681     return 1;
00682 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

static int fallenlassen ( string  str  )  [static]

Definiert in Zeile 947 der Datei put_and_get.c.

00948 {
00949     if (QueryProp(P_GHOST)) {
00950         _notify_fail("Als Geist kannst Du nichts fallenlassen.\n");
00951         return 0;
00952     }
00953 
00954     if (!str || str[<7..] != " fallen") {
00955         _notify_fail("Lass etwas FALLEN, oder was meinst Du?\n");
00956         return 0;
00957     }
00958 
00959     _notify_fail("WAS moechtest Du fallenlassen?\n");
00960     return drop_objects(str[0..<8]);
00961 }

object* find_objects ( string  what,
object  env,
int  is_source 
)

Definiert in Zeile 636 der Datei put_and_get.c.

Benutzt __find_objects().

Wird benutzt von drop_objects(), give_objects() und pick_objects().

00637 {
00638   if (!stringp(what) || !strlen(what))
00639     return ({});
00640   return __find_objects(explode(what, " "), env, is_source);
00641 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

object* find_obs ( string  str,
int  meth 
)

Definiert in Zeile 1085 der Datei put_and_get.c.

Wird benutzt von _destruct(), _process_command() und look_into().

01087 {
01088    object inv;
01089    if (!str) return 0;
01090    if (str[<7..]==" in mir") {
01091      inv=ME;
01092      str=str[0..<8];
01093    }
01094    else if (str[<8..]==" in raum") {
01095      if (meth & PUT_GET_DROP) { // man kann nichts aus dem Raum wegwerfen
01096        _notify_fail("Du kannst nichts wegwerfen, das Du gar nicht hast.\n");
01097        return 0;
01098      }
01099      inv=environment();
01100      str=str[0..<9];
01101    }
01102    else if (meth & PUT_GET_DROP) inv=ME; // Raum bei drop uninteressant
01103    // else kein besonderes inv ausgewaehlt also inv=0
01104    if (!strlen(str))
01105      return 0; // hier passt die bereits gesetzte _notify_fail
01106    else {
01107      object *obs;
01108      string con;
01109      if (sscanf(str, "%s aus %s", str, con)==2 ||
01110          sscanf(str, "%s in %s", str, con)==2 ||
01111          sscanf(str, "%s von %s", str, con)==2 ||
01112          sscanf(str, "%s vom %s", str, con)==2) {
01113        if (!inv) {
01114          if (!environment() || !(inv=present(con, environment())))
01115             inv=present(con, ME); // sowohl im env als auch im inv suchen
01116        }
01117        else inv=present(con, inv); // nur in ausgewaehltem inv suchen
01118        if (inv==ME) inv=0;
01119        if (!inv || !(inv->short())) {
01120          _notify_fail(break_string("Du hast hier aber kein '"+capitalize(con)
01121                                  +"'.",78));
01122          return 0;
01123        }
01124        if (living(inv)) {
01125          _notify_fail(break_string("Aber "+inv->name(WER,1)+" lebt doch!",78));
01126          return 0;
01127        }
01128        // wieso man aus Objekten die von std/tray abgeleitet werden etwas
01129        // nehmen koennen soll, versteh ich zwar nicht so ganz...
01130        if (!(inv->QueryProp(P_CONTAINER)) && !(inv->QueryProp(P_TRAY))) {
01131          _notify_fail(break_string("Du kannst nichts aus "+inv->name(WEM,1)
01132                                  +" nehmen.",78));
01133          return 0;
01134        }
01135        if (inv->QueryProp(P_CNT_STATUS)) { // Container ist geschlossen
01136          _notify_fail(break_string("Aber "+inv->name(WER,1)
01137                                  +" ist doch geschlossen.", 78));
01138          return 0;
01139        }
01140      }
01141      else if (inv==ME && (meth & PUT_GET_TAKE)) { // nichts aus sich nehmen
01142        _notify_fail("Du kannst nichts nehmen, "
01143                     "was Du schon bei Dir traegst.\n");
01144        return 0;
01145      }
01146      if (!inv && (meth & PUT_GET_TAKE))
01147        inv=environment(); // nichts nehmen was man schon hat
01148 
01149      if (!inv) {
01150        if (environment()) {
01151          obs=(environment()->present_objects(str)||({}));
01152          if (!sizeof(obs)) obs+=(ME->present_objects(str)||({}));
01153        }
01154        else obs=(ME->present_objects(str) || ({}));
01155      }
01156      else obs=(inv->present_objects(str) || ({}));
01157      return obs-({ ME });
01158    }
01159    return(0);
01160 }

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

static int geben ( string  str  )  [static]

Definiert in Zeile 1038 der Datei put_and_get.c.

01039 {
01040     if (QueryProp(P_GHOST)) {
01041         _notify_fail("Als Geist kannst Du nichts weggeben.\n");
01042         return 0;
01043     }
01044 
01045     _notify_fail("WEM moechtest Du WAS geben?\n");
01046     return give_objects(str);
01047 }

varargs int give ( object  o,
object  dest,
mixed  msg 
)

Definiert in Zeile 420 der Datei put_and_get.c.

Benutzt cl, gname, Name(), P_GIVE_MSG, put_or_get(), replace_personal(), SAY2, TME, TOB, WEM, WEN, wen0, wen1, WER und wer0.

Wird benutzt von give_objects().

00421 {
00422     string zname, gname;
00423     string str;
00424 
00425     // Falls das jemand von aussen ruft und Schrott uebergibt...
00426     if (!living(dest))
00427         raise_error(sprintf("Totes Ziel fuer give(): %O\n", dest));
00428 
00429     zname = dest->name(WEM, 1);
00430     gname = Name(WER, 1);
00431 
00432     // vorher speichern, falls das Objekt zerstoert wird
00433     cl = symbol_function("name", o);
00434     wen0 = funcall(cl, WEN, 0);
00435     wen1 = funcall(cl, WEN, 1);
00436     wer0 = 0;
00437 
00438     if (!msg)
00439         msg = o->QueryProp(P_GIVE_MSG);
00440 
00441     if (str = put_or_get(o, dest)) {
00442         TME(str);
00443         return 0;
00444     }
00445 
00446     if (!msg) {
00447         TME("Du gibst " + zname + " " + wen1 + ".");
00448         TOB(dest, gname + " gibt Dir " + wen0 + ".");
00449         SAY2(({dest}), gname + " gibt " + zname + " " + wen0 + ".");
00450     } else if (pointerp(msg))
00451         switch (sizeof(msg)) {
00452           case 3:
00453             TOB(dest, replace_personal(
00454                 msg[2], ({this_object(), o||wen0, dest||zname}), 1));
00455           case 2:
00456             SAY2(({dest, this_object()}), replace_personal(
00457                  msg[1], ({this_object(), o||wen0, dest||zname}), 1));
00458           case 1:
00459             TME(replace_personal(
00460                 msg[0], ({this_object(), o||wen1, dest||zname}), 1));
00461             break;
00462           default:
00463             raise_error(sprintf(
00464                 "Falsches Format fuer P_GIVE_MSG: %O\n", o||wen1));
00465         }
00466 
00467     if (!query_once_interactive(dest))
00468         dest->give_notify(o);
00469 
00470     return 1;
00471 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

int give_obj ( object  ob,
object  where 
)

Definiert in Zeile 1214 der Datei put_and_get.c.

Wird benutzt von give_notify().

01215 {
01216   object env;
01217 
01218   if (environment(ob)!=this_object()) {
01219     TME("Das solltest Du erstmal nehmen.");
01220     return 1;
01221   }
01222   if (!ob || ob == this_object() || ob == where ||
01223       environment(where)!=environment())
01224     return 0;
01225   if (environment(ob) == where) {
01226     _notify_fail("Das Ziel ist in dem zu gebenden Object enthalten!\n");
01227     return 0;
01228   }
01229   if (environment(ob)!=this_object()) {
01230     TME("Das hast Du nicht.");
01231     return 1;
01232   }
01233   (void) give(ob, where);
01234   return 1;
01235 }

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

varargs int give_objects ( string  str,
mixed  msg 
)

Definiert in Zeile 802 der Datei put_and_get.c.

Benutzt __find_objects(), dest(), find_objects(), give(), i, last_moved_objects, last_moved_where, NF, obs, P_MAX_HANDS, QueryProp(), TME, tokens, WEM und WER.

00803 {
00804     object *obs, dest;
00805     
00806     if (!stringp(str) || !strlen(str)) return 0;
00807 
00808     string *tokens = explode(str, " ");
00809 
00810     if (((int)QueryProp(P_MAX_HANDS)) < 1){
00811         NF("Ohne Haende kannst Du nichts weggeben.");
00812         return 0;
00813     }
00814 
00815     for (int i = 0; i < sizeof(tokens)-1; i++) {
00816         if (!(dest = present(implode(tokens[..i], " "), environment())))
00817             continue;
00818 
00819         if (!living(dest)) {
00820             NF("Aber " + dest->name(WER, 1) + " lebt doch gar nicht!");
00821             dest = 0;
00822             continue;
00823         }
00824 
00825         if (!sizeof(obs = __find_objects(tokens[i+1..], 0, 1))) {
00826             NF("WAS moechtest Du " + dest->name(WEM, 1)+" geben?");
00827             dest = 0;
00828         } else
00829             break;
00830     }
00831 
00832     if (!dest) {
00833         int pos;
00834 
00835         if ((pos = strrstr(str, " an ")) >= 0) {
00836             dest = present(str[pos+4..], environment());
00837             obs = find_objects(str[..pos-1], this_object(), 1);
00838         }
00839     }
00840 
00841     if (!dest || !living(dest) || !sizeof(obs))
00842         return 0;
00843 
00844     foreach (object o: obs) {
00845         if (objectp(o))
00846             give(o, dest, msg);
00847 
00848         if (get_eval_cost() < 100000) {
00849             TME("Den Rest behaeltst Du erst mal.");
00850             last_moved_objects = obs[..member(obs, o)];
00851             last_moved_where = dest;
00852             return 1;
00853         }
00854     }
00855 
00856     last_moved_objects = obs;
00857     last_moved_where = dest;
00858     return 1;
00859 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

static int holen ( string  str  )  [static]

Definiert in Zeile 1016 der Datei put_and_get.c.

01017 {
01018     if (QueryProp(P_GHOST)) {
01019         _notify_fail("Als Geist kannst Du nichts nehmen.\n");
01020         return 0;
01021     }
01022 
01023     _notify_fail("WAS moechtest Du aus WAS holen?\n");
01024     return pick_objects(str, 1);
01025 }

static int legen ( string  str  )  [static]

Definiert in Zeile 979 der Datei put_and_get.c.

00980 {
00981     if (QueryProp(P_GHOST)) {
00982         _notify_fail("Als Geist kannst Du nichts weglegen.\n");
00983         return 0;
00984     }
00985 
00986     if (!str) {
00987         _notify_fail("Lege etwas AB, oder was meinst Du?\n");
00988         return 0;
00989     }
00990 
00991     if (str[<3..] == " ab") {
00992         _notify_fail("WAS moechtest Du ablegen?\n");
00993         return drop_objects(str[0..<4]);
00994     }
00995 
00996     if (str[<4..] == " weg") {
00997         _notify_fail("WAS moechtest Du weglegen?\n");
00998         return drop_objects(str[0..<5]);
00999     }
01000 
01001     _notify_fail("WAS moechtest Du WOHIN legen?\n");
01002     return put_objects(str, WEN, "legen");
01003 }

object* moved_objects ( void   ) 

Definiert in Zeile 920 der Datei put_and_get.c.

00921 {
00922     return last_moved_objects;
00923 }

object moved_where ( void   ) 

Definiert in Zeile 925 der Datei put_and_get.c.

00926 {
00927     return last_moved_where;
00928 }

static int nehmen ( string  str  )  [static]

Definiert in Zeile 1027 der Datei put_and_get.c.

01028 {
01029     if (QueryProp(P_GHOST)) {
01030         _notify_fail("Als Geist kannst Du nichts nehmen.\n");
01031         return 0;
01032     }
01033 
01034     _notify_fail("WAS moechtest Du nehmen?\n");
01035     return pick_objects(str, 0);
01036 }

varargs int pick ( object  o,
mixed  msg 
)

Definiert in Zeile 384 der Datei put_and_get.c.

Benutzt cl, Name(), P_PICK_MSG, put_or_get(), replace_personal(), SAY, TME, WEN, wen0, wen1, WER und wer0.

00385 {
00386     string str;
00387 
00388     // vorher speichern, falls das Objekt zerstoert wird
00389     cl = symbol_function("name", o);
00390     wen0 = 0;
00391     wen1 = funcall(cl, WEN, 1);
00392     wer0 = 0;
00393 
00394     if (!msg)
00395         msg = o->QueryProp(P_PICK_MSG);
00396 
00397     if (str = put_or_get(o, this_object())) {
00398         TME(str);
00399         return 0;
00400     }
00401 
00402     if (!msg) {
00403         TME("Du nimmst " + wen1 + ".");
00404         SAY(Name(WER, 1) + " nimmt " + wen1 + ".");
00405     } else if (pointerp(msg))
00406         switch (sizeof(msg)) {
00407           case 2:
00408             SAY(replace_personal(msg[1], ({this_object(), o||wen1}), 1));
00409           case 1:
00410             TME(replace_personal(msg[0], ({this_object(), o||wen1}), 1));
00411             break;
00412           default:
00413             raise_error(sprintf(
00414                 "Falsches Format fuer P_PICK_MSG: %O\n", o||wen1));
00415         }
00416 
00417     return 1;
00418 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

int pick_obj ( object  ob  ) 

Definiert in Zeile 1162 der Datei put_and_get.c.

01163 {
01164   object env;
01165 
01166   if (!ob || ob == this_object() || environment(ob) == this_object()) return 0;
01167   if ((env=environment(ob)) != environment()) {
01168     if (!env->QueryProp(P_CONTAINER) && !env->QueryProp(P_TRAY)) {
01169       TME("Du kannst nichts aus " + env->name(WEM,1) + " nehmen.");
01170       return 1;
01171     }
01172     else if (env->QueryProp(P_CNT_STATUS)) {  // Container ist geschlossen
01173       TME("Aber " + env->name(WER, 1) + " ist doch geschlossen.");
01174       return 1;
01175     }
01176   }
01177   if (ob->IsUnit() && ob->QueryProp(P_AMOUNT)<0) {
01178     TME("Du kannst nicht mehr nehmen als da ist.");
01179     return 1;
01180   }
01181   (void) pick(ob);
01182   return 1;
01183 }

varargs int pick_objects ( string  str,
int  flag,
mixed  msg 
)

Definiert in Zeile 772 der Datei put_and_get.c.

Benutzt find_objects(), last_moved_objects, last_moved_where, NF, obs, P_MAX_HANDS, pick(), QueryProp() und TME.

00773 {
00774     object *obs;
00775 
00776     if (((int)QueryProp(P_MAX_HANDS)) < 1){
00777         NF("Ohne Haende kannst Du nichts nehmen.");
00778         return 0;
00779     }
00780 
00781     if (!sizeof(obs = find_objects(str, 0, 1) - all_inventory()
00782                   - (flag ? all_inventory(environment()) : ({}))))
00783         return 0;
00784 
00785     foreach (object o: obs) {
00786         if (objectp(o))
00787             pick(o, msg);
00788 
00789         if (get_eval_cost() < 100000) {
00790             TME("Den Rest laesst Du erst mal liegen.");
00791             last_moved_objects = obs[..member(obs, o)];
00792             last_moved_where = 0;
00793             return 1;
00794         }
00795     }
00796 
00797     last_moved_objects = obs;
00798     last_moved_where = 0;
00799     return 1;
00800 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

varargs int put ( object  o,
object  dest,
mixed  msg 
)

Definiert in Zeile 336 der Datei put_and_get.c.

Benutzt cl, Name(), P_PUT_MSG, put_or_get(), replace_personal(), SAY, TME, WEN, wen0, wen1, WER und wer0.

00337 {
00338     string str;
00339 
00340     // Falls das jemand von aussen ruft und Schrott uebergibt...
00341     //if (living(dest))
00342     //    raise_error(sprintf("Lebendes Ziel fuer put(): %O\n", dest));
00343     if (dest == environment())
00344         raise_error("Ziel fuer put() ist Umgebung des Spielers\n");
00345 
00346     // vorher speichern, falls das Objekt zerstoert wird
00347     cl = symbol_function("name", o);
00348     wen0 = funcall(cl, WEN, 0);
00349     wen1 = funcall(cl, WEN, 1);
00350     wer0 = funcall(cl, WER, 0);
00351 
00352     if (!msg)
00353         msg = o->QueryProp(P_PUT_MSG);
00354 
00355     if (str = put_or_get(o, dest)) {
00356         TME(str);
00357         return 0;
00358     }
00359 
00360   
00361     if (!msg) {
00362         TME("Du steckst " + wen1 + " in " + dest->name(WEN, 1) + ".");
00363         if (environment())
00364                   SAY(Name(WER, 1) + " steckt " + wen0 +
00365                       " in " + dest->name(WEN, 0) + ".");
00366     }
00367     else if (pointerp(msg)) {
00368         switch (sizeof(msg)) {
00369           case 2:
00370             if (environment())
00371                       SAY(replace_personal(msg[1], ({this_object(), o||wen0, dest}), 1));
00372           case 1:
00373             TME(replace_personal(msg[0], ({this_object(), o||wen1, dest}), 1));
00374             break;
00375           default:
00376             raise_error(sprintf(
00377                 "Falsches Format fuer P_PUT_MSG: %O\n",o||wen1));
00378         }
00379     }
00380 
00381     return 1;
00382 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

int put_obj ( object  ob,
object  where 
)

Definiert in Zeile 1192 der Datei put_and_get.c.

01193 {
01194   object env;
01195 
01196   if (ob == this_object() || ob == where || environment(ob) == where) return 0;
01197   env=environment(ob);
01198   if (!where->QueryProp(P_CONTAINER)) {
01199     TME("Du kannst in " + where->name(WEN,1) + " nix reinstecken.");
01200     return 1;
01201   }
01202   if (where->QueryProp(P_CNT_STATUS)) {  // Container ist geschlossen
01203     TME("Aber " + where->name(WER, 1) + " ist doch geschlossen.");
01204     return 1;
01205   }
01206   if (env!=environment(this_object()) && env!=this_object()) {
01207     _notify_fail("Da kommst du so nicht ran.\n");
01208     return 0;
01209   }
01210   (void) put(ob, where);
01211   return 1;
01212 }

varargs int put_objects ( string  str,
int  casus,
string  verb,
mixed  msg 
)

Definiert in Zeile 684 der Datei put_and_get.c.

Benutzt __find_objects(), CountUp(), dest(), i, last_moved_objects, last_moved_where, NF, obs, P_CNT_STATUS, P_CONTAINER, P_DEST_PREPOSITION, put(), TME, tokens, WEM, WEN und WER.

00685 {
00686     object *obs, dest, *no_move;
00687     
00688     if (!stringp(str) || !strlen(str)) return 0;
00689 
00690     string *tokens = explode(str, " ");
00691     int allow_room = 1;
00692     int allow_me = 1;
00693 
00694     if (sizeof(tokens) > 1 && tokens[<1] == "hier") {
00695         tokens = tokens[..<2];
00696         allow_me = 0;
00697     } else if (sizeof(tokens) > 2 && tokens[<2] == "in")
00698         if (tokens[<1] == "mir" ||
00699             tokens[<1] == "dir") {
00700             tokens = tokens[..<3];
00701             allow_room = 0;
00702         } else if (tokens[<1] == "raum") {
00703             tokens = tokens[..<3];
00704             allow_me = 0;
00705         }
00706 
00707     for (int i = sizeof(tokens)-1; i > 1; i--) {
00708         if (!(dest = allow_room && present(implode(tokens[i..], " "),
00709                                            environment())) &&
00710             !(dest = allow_me && present(implode(tokens[i..], " "),
00711                                          this_object())))
00712             continue;
00713 
00714         if (living(dest)) {
00715             NF("Aber " + dest->name(WER, 1) + " lebt doch!");
00716             continue;
00717         }
00718 /*
00719         if (verb == "legen" && !dest->QueryProp(P_TRAY)) {
00720             NF("Du kannst nichts auf " + dest->name(WEN, 1) + " legen.");
00721             continue;
00722         }
00723 */
00724         if (verb == "stecken" && !dest->QueryProp(P_CONTAINER)) {
00725             NF("Du kannst in " + dest->name(WEN, 1) + " nichts reinstecken.");
00726             continue;
00727         }
00728 
00729         if (dest->QueryProp(P_CNT_STATUS)) {
00730             NF("Aber " + dest->name(WER, 1) + " ist doch geschlossen!");
00731             continue;
00732         }
00733 
00734         if (tokens[i-1] != dest->QueryProp(P_DEST_PREPOSITION)) {
00735             NF("Du kannst nichts " + tokens[i-1] + " " +
00736                dest->name(casus, 1) + " " + verb + ".");
00737             continue;
00738         }
00739 
00740         if (!sizeof(obs = __find_objects(tokens[..i-2], 0, 1) - ({ dest }))) {
00741             NF("WAS moechtest Du " + tokens[i-1] + " " +
00742                dest->name(casus, 1) + " " + verb + "?");
00743             return 0;
00744         }
00745 
00746         if (sizeof(no_move = obs & all_inventory(dest))) {
00747             TME(capitalize(CountUp(map_objects(no_move, "name", WER, 1))) +
00748                 (sizeof(no_move) == 1 ? " ist" : " sind") +
00749                 " doch bereits in " + dest->name(WEM,1) + ".");
00750             if (!sizeof(obs -= no_move))
00751                 return 0;
00752         }
00753 
00754         foreach (object o: obs) {
00755             if (objectp(o))
00756                 put(o, dest, msg);
00757 
00758             if (get_eval_cost() < 100000) {
00759                 TME("Den Rest laesst Du erst mal, wo er ist.");
00760                 last_moved_objects = obs[..member(obs, o)];
00761                 last_moved_where = dest;
00762                 return 1;
00763             }
00764         }
00765 
00766         last_moved_objects = obs;
00767         last_moved_where = dest;
00768         return 1;
00769     }
00770 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

private string put_or_get ( object  o,
object  dest 
)

Definiert in Zeile 126 der Datei put_and_get.c.

Benutzt M_GET, M_GIVE, M_PUT, ME_CANT_BE_DROPPED, ME_CANT_BE_INSERTED, ME_CANT_BE_TAKEN, ME_CANT_LEAVE_ENV, ME_TOO_HEAVY, ME_TOO_HEAVY_FOR_ENV, Name(), P_ENV_TOO_HEAVY_MSG, P_GHOST, P_NODROP, P_NOGET, P_NOINSERT_MSG, P_NOLEAVE_MSG, P_TOO_HEAVY_MSG, P_TOO_MANY_MSG, QueryProp(), replace_personal(), TOO_MANY_OBJECTS, WEM, WEN, wen0, wen1, WER und wer0.

Wird benutzt von drop(), give(), pick() und put().

00134 {
00135     int method, ret;
00136     string str;
00137 
00138     //if (living(o))
00139     //    raise_error(sprintf("Lebendes Argument fuer put_or_get: %O\n", o));
00140 
00141     if (dest == this_object())          /* pick */
00142         method = M_GET;
00143     else if (dest == environment())     /* drop */
00144         method = M_PUT;
00145     else if (living(dest))              /* give */
00146         method = M_GIVE;
00147     else {                              /* put */
00148         method = M_PUT | M_GET;
00149         if (first_inventory(o))
00150             return o->Name(WER, 1) + " ist nicht leer!";
00151     }
00152 
00153     if ((ret = o->move(dest, method)) > 0)
00154         return 0;
00155 
00156     switch (ret) {
00157         case ME_TOO_HEAVY:
00158             if (dest == this_object())
00159                 if (QueryProp(P_GHOST))
00160                     return "Als Geist kannst Du nichts mitnehmen.";
00161                 else
00162                     return "Du kannst " + wen1 + " nicht mehr tragen.";
00163 
00164             if (stringp(str = dest->QueryProp(P_TOO_HEAVY_MSG)))
00165                 return capitalize(replace_personal(str, ({o, dest}), 1));
00166 
00167             if (living(dest)) {
00168                 if (dest->QueryProp(P_GHOST))
00169                     return "Als Geist kann " + dest->name(WER, 1) +
00170                            " nichts mitnehmen.";
00171                 else
00172                     return dest->Name(WER, 1) + " kann " +
00173                            wen0 + " nicht mehr tragen.";
00174             }
00175 
00176             if (dest == environment())
00177                 return (stringp(str = dest->Name(WER, 1)) && strlen(str) ?
00178                         str : "Der Raum") + " wuerde dann zu schwer werden.";
00179 
00180             return capitalize(wer0 + " passt in " + dest->name(WEN, 1) +
00181                               " nicht mehr rein.");
00182 
00183         case ME_CANT_BE_DROPPED:
00184             if (o && stringp(str = o->QueryProp(P_NODROP)))
00185                 return str;
00186 
00187             if (dest == environment())
00188                 return "Du kannst " + wen1 + " nicht wegwerfen!";
00189 
00190             if (living(dest))
00191                 return "Du kannst " + wen1 + " nicht weggeben.";
00192 
00193             return "So wirst Du " + wen1 + " nicht los...";
00194 
00195         case ME_CANT_BE_TAKEN:
00196             if (o && stringp(str = o->QueryProp(P_NOGET)))
00197                 return str;
00198 
00199             if (stringp(str = environment(o)->QueryProp(P_NOLEAVE_MSG)))
00200                 return capitalize(
00201                     replace_personal(str, ({o, environment(o)}), 1));
00202 
00203             //if (dest != environment())
00204             //    return "Du kannst " + wen1 + " nicht einmal nehmen.";
00205 
00206             return "Du kannst " + wen1 + " nicht nehmen.";
00207 
00208         case ME_CANT_BE_INSERTED:
00209             if (stringp(str = dest->QueryProp(P_NOINSERT_MSG)))
00210                 return capitalize(replace_personal(str, ({o, dest}), 1));
00211 
00212             if (dest == environment())
00213                 return "Das darfst Du hier nicht ablegen.";
00214 
00215             if (dest == this_object())
00216                 return "Du kannst " + wen1 + " nicht nehmen.";
00217 
00218             if (living(dest))
00219                 return "Das kannst Du " + dest->name(WEM, 1) + " nicht geben.";
00220 
00221             return capitalize(wen0 + " kannst Du dort nicht hineinstecken.");
00222 
00223         case ME_CANT_LEAVE_ENV:
00224             // ME_CANT_LEAVE_ENV kann nur auftreten, wenn o ein Environment
00225             // hat, deshalb kein Check dadrauf
00226             if (stringp(str = environment(o)->QueryProp(P_NOLEAVE_MSG)))
00227                 return capitalize(
00228                     replace_personal(str, ({o, environment(o)}), 1));
00229 
00230             if (environment(o) != this_object())
00231                 return "Du kannst " + wen1 + " nicht nehmen.";
00232 
00233             if (dest == environment())
00234                 return "Du kannst " + wen1 + " nicht wegwerfen!";
00235 
00236             if (living(dest))
00237                 return "Du kannst " + wen1 + " nicht weggeben.";
00238 
00239             return "So wirst Du " + wen1 + " nicht los...";
00240 
00241         case ME_TOO_HEAVY_FOR_ENV:
00242             if (stringp(str = dest->QueryProp(P_ENV_TOO_HEAVY_MSG)))
00243                 return capitalize(replace_personal(str, ({o, dest}), 1));
00244 
00245             if (environment(dest) == this_object())
00246                 return dest->Name(WER, 1) +
00247                        " wuerde Dir dann zu schwer werden.";
00248 
00249             return (stringp(str = environment(dest)->Name(WER, 1))
00250                         && strlen(str) ? str : "Der Raum") +
00251                     " wuerde dann zu schwer werden.";
00252 
00253         case TOO_MANY_OBJECTS:
00254             if (stringp(str = dest->QueryProp(P_TOO_MANY_MSG)))
00255                 return capitalize(replace_personal(str, ({o, dest}), 1));
00256 
00257             if (dest == this_object())
00258                 return "Soviele Gegenstaende kannst Du unmoeglich tragen!";
00259 
00260             if (dest == environment())
00261                 return "Dafuer ist hier nicht mehr genug Platz.";
00262 
00263             if (living(dest))
00264                 return dest->Name(WER, 1) + " kann "  + wen0 +
00265                        " nicht mehr tragen.";
00266 
00267             return "Dafuer ist nicht mehr genug Platz in " +
00268                    dest->name(WEM, 1) + ".";
00269 
00270         default:
00271             if (dest == this_object())
00272                 return "Du kannst " + wen1 + " nicht nehmen.";
00273 
00274             if (dest == environment())
00275                 return "Du kannst " + wen1 + " nicht wegwerfen!";
00276 
00277             if (living(dest))
00278                 return "Du kannst " + wen1 + " nicht weggeben.";
00279 
00280             return capitalize(wen0 + " kannst Du dort nicht hineinstecken.");
00281     }
00282 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

Hier ist ein Graph der zeigt, wo diese Funktion aufgerufen wird:

varargs int show ( object  o,
object  whom,
mixed  msg 
)

Definiert in Zeile 473 der Datei put_and_get.c.

Benutzt FEMALE, gname, long(), MALE, Name(), P_AMOUNT, P_ARTICLE, P_GENDER, P_SHOW_MSG, PLURAL, QueryPossPronoun(), replace_personal(), SAY, SAY2, SINGULAR, TME, TOB, WEM, WEN, wen0 und WER.

00474 {
00475     string zname, gname;
00476     string wen0, wen2, long;
00477 
00478     zname = whom ? whom->name(WEM, 1) : "allen";
00479     gname = Name(WER, 1);
00480 
00481     if (!msg)
00482         msg = o->QueryProp(P_SHOW_MSG);
00483 
00484     if (environment(o) == this_object() ||
00485         environment(environment(o)) == this_object()) {
00486         wen0 = o->name(WEN, 0);
00487 
00488         /* Der Akkusativ muss mit dem unbestimmten Artikel gebildet werden,
00489          * damit eventuelle Adjektive die richtige Endung besitzen.
00490          * (ein kleines Schwert -> kleines Schwert -> Dein kleines Schwert)
00491          */
00492 
00493         if (o->QueryProp(P_ARTICLE) && member(wen0, ' ') >= 0) {
00494             int obgender = o->QueryProp(P_GENDER);
00495             int obnum = o->QueryProp(P_AMOUNT) > 1 ? PLURAL : SINGULAR;
00496 
00497             // Wichtig: P_AMOUNT ist 0 fuer Objekte, die nicht von unit erben.
00498             // Da unit.c kein P_AMOUNT==0 zulaesst, nehmen wir diesen Fall als
00499             // singular an. *Rumata
00500 
00501             wen2 = wen0[member(wen0, ' ')..];
00502             wen0 = QueryPossPronoun(o, WEN, obnum) + wen2;
00503 
00504             if (obnum == PLURAL || obgender == FEMALE)
00505                 wen2 = "Deine" + wen2;
00506             else if (obgender == MALE)
00507                 wen2 = "Deinen" + wen2;
00508             else
00509                 wen2 = "Dein" + wen2;
00510         } else
00511             wen2 = wen0;
00512     } else
00513         wen2 = wen0 = o->name(WEN, 1);
00514 
00515     // vorher speichern, falls das Objekt im catch_tell() zerstoert wird
00516     long = o->long(4);
00517 
00518     if (!msg) {
00519         TME("Du zeigst " + zname + " " + wen2 + ".");
00520         if (!whom)
00521             SAY(gname + " zeigt Dir " + wen0 + ".");
00522         else {
00523             TOB(whom, gname + " zeigt Dir " + wen0 + ".");
00524             SAY2(({whom}), gname + " zeigt " + zname + " " + wen0 + ".");
00525         }
00526     } else if (pointerp(msg))
00527         switch (sizeof(msg)) {
00528           case 3:
00529             if (whom)
00530                 TOB(whom, replace_personal(
00531                     msg[2], ({this_object(), o||wen0, whom||zname}), 1));
00532             else
00533                 SAY(replace_personal(
00534                     msg[2], ({this_object(), o||wen0, whom||zname}), 1));
00535           case 2:
00536             if (whom)
00537                 SAY2(({whom, this_object()}), replace_personal(
00538                      msg[1], ({this_object(), o||wen0, whom||zname}), 1));
00539           case 1:
00540             TME(replace_personal(
00541                 msg[0], ({this_object(), o||wen2, whom||zname}), 1));
00542             break;
00543           default:
00544             raise_error(sprintf(
00545                 "Falsches Format fuer P_SHOW_MSG: %O\n", o||wen0));
00546         }
00547 
00548     if (!whom)
00549         SAY(long);
00550     else {
00551         TOB(whom, long);
00552         if (!query_once_interactive(whom))
00553             whom->show_notify(o);
00554     }
00555 
00556     return 1;
00557 }

Hier ist ein Graph der zeigt, was diese Funktion aufruft:

varargs int show_objects ( string  str,
mixed  msg 
)

Definiert in Zeile 861 der Datei put_and_get.c.

Benutzt i, NF, obs, tokens und WER.

00862 {
00863     object *obs, whom;
00864     
00865     if (!stringp(str) || !strlen(str))
00866       return 0;
00867 
00868     string *tokens = explode(str, " ");
00869 
00870     for (int i = 0; i < sizeof(tokens)-1; i++) {
00871         if (whom = present(implode(tokens[..i], " "), environment())) {
00872             if (!living(whom)) {
00873                 NF("Aber " + whom->name(WER, 1) + " lebt doch gar nicht!");
00874                 continue;
00875             }
00876         } else {
00877             if (i != 0 || tokens[0] != "allen")
00878                 continue;
00879 
00880             if (!sizeof(filter(all_inventory(environment()) -
00881                     ({ this_object() }), #'living))) {
00882                 NF("Hier ist niemand, dem Du etwas zeigen koenntest!");
00883                 continue;
00884             }
00885         }
00886 
00887         if (whom == this_object()) {
00888             NF("Dazu solltest Du dann besser 'schau' benutzen!\n");
00889             continue;
00890         }
00891 
00892         if (!sizeof(obs = __find_objects(tokens[i+1..], this_object(), 0)) &&
00893             !sizeof(obs = __find_objects(tokens[i+1..], 0, 0)
00894                             - ({ this_object(), whom }))) {
00895             NF("WAS moechtest Du " + (whom ? whom->name(WEM, 1) : "allen") +
00896                " zeigen?");
00897             continue;
00898         }
00899 
00900         foreach (object o: obs) {
00901             if (objectp(o))
00902                 show(o, whom, msg);
00903 
00904             if (get_eval_cost() < 100000) {
00905                 TME("Das reicht erst mal.");
00906                 last_moved_objects = obs[..member(obs, o)];
00907                 last_moved_where = whom;
00908                 return 1;
00909             }
00910         }
00911 
00912         last_moved_objects = obs;
00913         last_moved_where = whom;
00914         return 1;
00915     }
00916 
00917     return 0;
00918 }

static int stecken ( string  str  )  [static]

Definiert in Zeile 1005 der Datei put_and_get.c.

01006 {
01007     if (QueryProp(P_GHOST)) {
01008         _notify_fail("Das kannst Du in Deinem immateriellen Zustand nicht.\n");
01009         return 0;
01010     }
01011 
01012     _notify_fail("WAS moechtest Du WOHIN stecken?\n");
01013     return put_objects(str, WEN, "stecken");
01014 }

static int werfen ( string  str  )  [static]

Definiert in Zeile 963 der Datei put_and_get.c.

00964 {
00965     if (QueryProp(P_GHOST)) {
00966         _notify_fail("Als Geist kannst Du nichts wegwerfen.\n");
00967         return 0;
00968     }
00969 
00970     if (!str || str[<4..] != " weg") {
00971         _notify_fail("Wirf etwas WEG, oder was meinst Du?\n");
00972         return 0;
00973     }
00974 
00975     _notify_fail("WAS moechtest Du loswerden?\n");
00976     return drop_objects(str[0..<5]);
00977 }

static int zeigen ( string  str  )  [static]

Definiert in Zeile 1049 der Datei put_and_get.c.

01050 {
01051     if (QueryProp(P_GHOST)) {
01052         _notify_fail("Als Geist kannst Du niemandem etwas zeigen.\n");
01053         return 0;
01054     }
01055 
01056     _notify_fail("WEM moechtest Du WAS zeigen?\n");
01057     return show_objects(str);
01058 }

Variablen-Dokumentation

private nosave closure cl

Definiert in Zeile 118 der Datei put_and_get.c.

Wird benutzt von AddCmd(), AddSpecialInfo(), Attack(), check_restrictions(), DoAddMember(), DoUnwield(), DoWield(), drop(), get_uids(), give(), heart_beat(), Identify(), pick(), put(), QuerySkillAttribute(), RegisterEvent() und setup().

private nosave object* last_moved_objects

Definiert in Zeile 120 der Datei put_and_get.c.

Wird benutzt von drop_objects(), give_objects(), pick_objects() und put_objects().

private nosave object last_moved_where

Definiert in Zeile 121 der Datei put_and_get.c.

Wird benutzt von drop_objects(), give_objects(), pick_objects() und put_objects().

private nosave string wen0

Definiert in Zeile 119 der Datei put_and_get.c.

Wird benutzt von drop(), give(), pick(), put(), put_or_get() und show().

private nosave string wen1

Definiert in Zeile 119 der Datei put_and_get.c.

Wird benutzt von drop(), give(), pick(), put() und put_or_get().

private nosave string wer0

Definiert in Zeile 119 der Datei put_and_get.c.

Wird benutzt von drop(), give(), pick(), put() und put_or_get().

Erzeugt am Thu Jun 3 14:42:33 2010 für MorgenGrauen Mudlib von  doxygen 1.6.3