FUNKTION
        varargs
        int listen_event(mixed type, mixed prio, mixed callback)

ARGUMENTE
        type     - ein Eventtyp als String oder mehrere als Array
        prio     - die Lausch-Prioritaet als Integer zwischen
                   -10999 und +999 oder mehrere als Array
        callback - (optional) Name der Callback-Funktion als
                   String oder lfun-Closure

RUECKGABE
         1 - Objekt auf den/die Typen angemeldet
         0 - Fehler in den Argumenten
        -1 - Ungueltiger Event-Typ
        -2 - Fehlende Berechtigung zum Lauschen fuer einen Typ

        Wenn mehrere Typen (oder mehrere Prioritaeten) angemeldet werden,
        dann wird nur 1 zurueck gegeben, wenn ALLE Anmeldungen erfolgreich
        waren. Schlaegt EINE der Anmeldungen fehl, wird der Fehlercode
        zurueckgegeben und alle anderen Anmeldungen werden auch nicht
        durchgefuehrt bzw. zurueckgerollt.

BESCHREIBUNG
        Meldet das Objekt als Lauscher fuer den Event 'type' oder alle Typen
        im Array 'type' an. Wird ein entsprechender Event in der Naehe 
        ausgloest, bekommt ihn das Objekt mit Prioritaet 'prio' oder allen
        Prioritaeten in 'prio' auf Funktion oder Closure 'callback' 
        mitgeteilt. Wird 'callback' nicht angegeben, wird der Event an
        'receive_event' im Objekt gesendet. Existiert keine Funktion dieses
        Namens im Objekt, wird das Objekt nicht angemeldet.

        Wird das Objekt aus irgend einem Grund mehrmals mit dem gleichen
        Argumenten angemeldet, wird nur die erste durchgefuehrt, alle
        Wiederholungen werdenh ignoriert.

        Die Callback-Funktion/Closure sollte einen der folgenden Prototypen
        haben (je nach Informationen, die man erhalten moechte):
        
        void receive_event(mapping data)
        void receive_event(mapping data, string type)
        void receive_event(mapping data, string type, int prio)
        void receive_event(mapping data, string type, int prio, int mode)

        data - das Event-Mapping (Aufbau abhaengig vom Typ)
        type - der Event-Typ
        prio - die aktuelle Prioritaet
        mode - der Sende-Modus (siehe send_event)

        Die Anmeldung kann fehlschlagen, wenn dem Objekt die Berechtigung
        fehlt auf einen der Typen zu lauschen. In dem Fall bitte einen
        Erzmagier fragen.

BEACHTE
        Ein Event kann nur in der 'Naehe' des Ausloesers empfangen werden.
        Wo genau, ist vom jeweiligen Event-Typ abhaengig.

BEISPIEL 1
        Melde das Objekt als Reagierer (EPRIO_REACT) auf ET_GO an.

        #include <events.h>
        #include <moving.h>

        void myfun(mapping data, string type, int prio);

        void create() {
          ...
          listen_event(ET_GO, EPRIO_REACT, #'myfun)
          ...
        }

        void myfun(mapping data, string type, int prio) {
          tell_object(this_player(),"ET_GO empfangen!\n");
        }

BEISPIEL 2
        Melde das Objekt als Reagierer auf ET_GO und ET_TPORT an.

        #include <events.h>
        #include <moving.h>

        void myfun(mapping data, string type, int prio);

        void create() {
          ...
          listen_event(({ET_GO,ET_TPORT}), EPRIO_REACT, #'myfun)
          ...
        }

        void myfun(mapping data, string type, int prio) {
          switch (type) {
            case ET_GO:
              tell_object(this_player(),"ET_GO empfangen!\n");
              break;
            case ET_TPORT:
              tell_object(this_player(),"ET_TPORT empfangen!\n");
              break;
            default:
              tell_object(this_player(),"??? empfangen!\n");
          }
        }

BEISPIEL 3
        Melde das Objekt als Abbrecher und Abbruch-Handler auf ET_DEATH an.

        #include <events.h>
        #include <death.h>

        void myfun(mapping data, string type, int prio);

        void create() {
          ...
          listen_event(ET_DEATH, ({EPRIO_CANCEL,EPRIO_C_HANDLE}), #'myfun)
          ...
        }

        void myfun(mapping data, string type, int prio) {
          switch (prio) {
            case EPRIO_CANCEL:
              // Event soll abgebrochen werden!
              cancel_event();
              break;
            case EPRIO_C_HANDLE:
              // Event wurde erfolgreich abgebrochen!
              tell_object(this_player(),"Nochmal Glueck gehabt!\n");
              break;
          }
        }

SIEHE AUCH
        unlisten_event(S), set_global_listener(S), send_event(S),
        cancel_event(S), handle_event(S), events(WL), event_listeners(WL),
        event_prioritaeten(WL), event_types(WL)