Dokumentation zu: ET_GO(WL)

HR Image


EVENT-TYPEN
        ET_GO    - der 'Geh'-Event der Mudlib fuer Lebewesen.
        ET_TPORT - der 'Teleport'-Event der Mudlib fuer Lebewesen.

BEDEUTUNG
        Primaere Bewegungs-Events fuer Lebewesen. Aufgrund der Aehnlichkeit
        von ET_GO und ET_TPORT steht diese Manpage fuer beide Events.

DEFAULT HANDLER
        /global/handler/moving.c

EVENT DEFINES
        /sys/events.h
        /sys/moving.h

EVENT DATEN
        Das Event-Mapping enthaelt (prinzipiell) IMMER folgende Daten. Die
        Object-Pointer koennen jedoch 0 sein, wenn durch den Event etwas
        anderes passiert ist. Zum Beispiel ein MNPC durch den Begruessungs-
        schlag gestorben ist. Daher ist ein Test emfehlenswert.

        Key            | Inhalt
        ---------------+----------------------------------------------------
        Eintraege, die automatisch gesetzt werden (NICHT VERAENDERN!)
        E_SENDER       | (object) Event-Erzeuger. (Meist das Lebewesen)
        E_DESTINATIONS | (array) Objekte, an die der Event gesandt wird. (Im
                       | Normalfall der Start- und Zielraum)
        E_COMMAND      | (string) Das eingegebene Kommando. (Der Ausgang)
                       | Kann auch 0 sein! (siehe Manpage zu query_command()

        Moving-Daten, die veraendert werden duerfen:
        E_MOVE_OBJ     | (object) Das zu bewegende Lebewesen. (Daran sollte
                       | nicht OHNE ZWINGENDEN GRUND rumgespielt werden!)
        E_ACTOR        | Das agierende Lebewesen. In aller Regel das Objekt
                       | in E_MOVE_OBJ. Benutzung bitte unbedingt mit Holger
                       | oder Elric absprechen. Hat mehr Bedeutung bei dem 
                       | Put&Get-Events.
        E_MOVE_SOURCE  | (object) Dort ist das Lebwesen vor der Bewegung.
        E_MOVE_DEST    | (objekt) Dahin soll das Lebewesen bewegt werden.
        E_MOVE_METHOD  | (int) Wenn gesetzt, zusaetzliche Move-Methoden.
        E_MOVE_DIR     | (string oder 0) Bewegungsrichtung (-> "nach Osten")
        E_MOVE_MSGS    | Array (3 Elemente) aus Messages,die als 4. Argument
                       | move() uebergeben werden sollen (neues Format!).
                       | ({ Meldung an Lebewesen selbst, Meldung an ver-
                       | lassenen Raum, Meldung an betretenen Raum })
                       | Siehe Manpage zu move()

        Nach oder waehrend der Abarbeitung EVENTUELL enthalten:
        E_HANDLED      | (int) Wenn gesetzt, wurde der Event ausgefuehrt.
                       | Der Wert entspricht dem Returnwert von obj->move().
        E_HANDLER      | (object) Der ausfuehrende Handler.
        E_CANCELLED    | (mixed) Wenn gesetzt, wurde der Event abgebrochen.
                       | Der Inhalt sollte immer 1 sein.
        E_CANCELLER    | (object) Das abbrechende Object.
        E_MOVE_RVALUE  | (int) Enthaelt den Returnwert des move()-Aufrufs
                       | mit der Methode M_NOEVENT. Enthaelt oft nur einen
                       | Wert, wenn der Event nicht abgebrochen wurde!

EVENT-LAUSCHER
        Siehe allgemeine Syntaxen in event_listeners(WL).

EVENT-SENDER
        Siehe allgemeine Syntaxen in event_senders(WL). Gesendet werden
        muessen mindestens:
        E_MOVE_OBJ, E_ACTOR, E_MOVE_SOURCE, E_MOVE_DEST

        Zusaetzlich koennen folgende Eintraege gesendet werden:
        E_MOVE_DIR, E_MOVE_MSGS, E_MOVE_METHOD
        Werden sie nicht angegeben und/oder auf 0 gesetzt, werden die
        Default-Messages des Lebewesens aus P_MMSGIN, P_MMSGOUT, P_MSGIN
        und P_MSGOUT erzeugt. Zumindest E_MOVE_DIR sollte schon gesetzt
        werden, um 'XYZ geht.' als Meldung zu vermeiden...

        Automatisch werden immer gesetzt:
        E_SENDER, E_DESTINATION und E_COMMAND

        Ziel des Events sollte immer der Startraum und der Zielraum sein,
        bzw. deren aeusserstes Environment, falls sich ein Raum in einem
        anderen Raum befindet. (all_environment(raum)[<1])

BESCHREIBUNG
        Der ET_GO oder ET_TPORT Event wird normalerweise im move() des
        Livings erzeugt, wenn das Living mit einer Methode und NICHT mit 
        M_NOCHECK und/oder M_NOEVENT bewegt wird.

        Der Event geht mit Prioritaet EPRIO_DEF_HANDLE (0) an den Default-
        Handler (siehe oben). Dieser macht dann das eigentliche Moven, indem
        er wiederum das move() des Lebewesens, allerdings diesmal mit Methode
        M_NOEVENT aufruft, um Rekursion zu vermeiden. Der Returnwert dieses
        move() wird in E_MOVE_RVALUE gespeichert.

        Objekte die mit hoeherer Prioritaet lauschen (z.B.: EPRIO_MODIFY 
        (700) bzw. EPRIO_CANCEL (400)), koennen VOR dem Bewegen Modifizie-
        rungen vornehmen (Beinsteller) oder den Event ganz abbrechen 
        (Sperrmonster).

        Wird der Event abgebrochen, bevor der Handler ihn abarbeiten kann,
        ist E_MOVE_RVALUE nicht gesetzt! Der Abbrecher kann jedoch einen
        Fehlercode hier hinterlegen (bitte nur kleiner 0). Das Bewegen
        schlaegt dann mit diesem Wert fehl (move() == gesetzter Wert).
        Wird abgebrochen ohne hierin eine 'Begruendung' zu setzen, liefert
        das initiierende move() den Wert MOVE_EVENT_CANCELLED.

        Objekte die mit kleinerer Prioritaet (z.B.: EPRIO_REACT (-300)) 
        lauschen, koennen NACH dem Bewegen entsprechend auf die Bewegung
        reagieren. Abbrechen oder Modifizieren der Daten ist dann aber
        VERBOTEN.

        ACHTUNG! Abbruchmeldungen mit notify_fail werden _nicht_ ausgegeben!
		 Ebenso verhaelt es sich mit Abbruchmeldungen, die als
		 Argument an cancel_event() uebergeben werden.

VERALTETE FUNKTIONALITAETEN
        Der Go/Tport-Event soll, wenn immer es geht, statt folgendem ver-
        wendet werden:

        1. Die MOVE-HOOKS.
        2. Den Aufruf von environment(ob)->exit() bei Lebewesen.
        3. PreventInsert().

BEISPIEL
        Will man in einem Raum einem GO-Event lauschen, um dem Spieler mit
        10% Wahrscheinlichkeit ein Bein zu stellen, sieht das wie folgt aus:

        void bein_stellen(mapping data, string type, int prio); // Prototyp

        void create() {
            ...
            // fuer den reinen Abbruch
            listen_event(ET_GO, EPRIO_CANCEL, #'bein_stellen);
            // wenn der Abbruch erfolgreich war, reagieren wir darauf
            listen_event(ET_GO, EPRIO_C_HANDLE, #'bein_stellen);
            ...
        }

        void bein_stellen(mapping data, string type, int prio) {
            object opfer;

            if(!mappingp(data) || !living(opfer=data[E_MOVE_OBJ]))
                return;

            switch (prio)
            {
                // in der Abbruchphase nur den Event abbrechen
                // das koennten durchaus auch andere Objekte versuchen
                case EPRIO_CANCEL:
                    if(random(100)>9) return; // nur in 10% der Faelle
                    cancel_event();
                    break;
                // daher geben wir den Text erst aus, wenn wir auch 
                // wirklich der Abbrecher waren und lassen den Spieler 
                // hinfallen. ;-)
                // Den Event mit EPRIO_C_HANDLE bekommt man nur!, wenn
                // man selber der Abbrecher war (Unterschied dazu:
                // EPRIO_C_REACT)
                case EPRIO_C_HANDLE:
                    tell_object(opfer, "Du stolperst und faellst hin!\n");
                    opfer->reduce_hit_point(10); // Weh tun muss es B->
            }
            return;
        }

SIEHE AUCH
        move(L), events(WL), event_types(WL), event_prioritaeten(WL),
        listen_event(S)


Start » Magierhandbuch » Docu » Konzepte » ET_GO Letzte Generierung: 16.04.2009, 21:44
Email an: mud@wl.mud.de
Valid HTML 4.01!