Dokumentation zu: events(WL)

HR Image


KONZEPT
        Events (Ergeignisse) im Wunderland

AUTOR
        Holger@Wunderland

UEBERBLICK
        Objektorientierte Programmierung wie in unserer Mudlib schafft das
        Problem, dass relativ wenig ueber die Aktionen eines Objekts in
        Erfahrung gebracht werden kann. Es wurden bisher schon verschiedene
        Versuche gemacht, wenigstens ein paar Aktionen 'beobachten' zu 
        koennen. Zum Beispiel die Move-Hooks, um festzustellen, ob und wohin
        sich ein Objekt bewegt oder Comm-Hooks um Sachen wie den Chinesen-
        hut zu programmieren oder aber auch der Lib-Sensor von Bongo, der
        wenigstens ein paar Informationen ueber das 'Kommen und Gehen' von 
        Spielern oder deren 'Tod' etc. bereitstellt.

        Der Nachteil all dieser 'Kruecken' ist, dass die Bedienung unein-
        heitlich und unflexibel ist. Das Event-System stellt eine einheit-
        liche Schnittstelle zur Verfuegung fuer _alle_ Aktionen eines
        Objekts, die irgendwie fuer andere Objekte interessant sein koennen.

        Kern des ganzen ist der Event-Daemon, der alle Ereignisse empfaengt
        und an die weiterschickt, die etwas davon wissen wollen. Fuer den
        Magier, der ein Objekt scbreibt, wird es somit uninteressant, wer
        von den Aktionen seines Objekts etwas wissen will. Er sendet
        einfach einen Event, was das Objekt gerade macht, und um alles
        andere muss er sich nicht mehr kuemmern. Und wenn man ein Objekt 
        schreibt, was bestimmte Informationen braucht, muss man sich
        nur noch im Event-Daemon anmelden und bekommt von dort eine Benach-
        richtigung, wenn etwas passiert.

        Die Objekte, die sich im Event-Daemon anmelden, koennen den Event
        veraendern (beim reden aus 'r' ein 'l' machen), abbrechen (ein 
        Ausgang darf nicht durchschritten werden) oder darauf reagieren
        (Kerbholz bekommt eine Nachricht, wenn der Spieler ein Monster ge-
        toetet hat) oder auch neue Events in Gang setzen (Rekursionen).

ABLAUFDIAGRAMM
        Um den Ablauf eines 'normalen' Events zu verdeutlichen, habe ich mal
        eine Art Ablaufdiagramm angefertigt und einige Moeglichkeiten
        eingeplant. Ich hoffe das schafft ein wenig den Ueberblick. :-)

                       +-------------------------+
                       | Spieler/NPC interagiert | 
                       +-------------------------+ 
                                    |
                                    V 
                      +----------------------------+
   +----------------->| Objekt erzeugt einen Event |<-----------------------+
   |                  +----------------------------+                        |
   |                                |                                       |
   |                                V                                       |
   |             +-------------------------------------+                    |
   |             | EventDaemon sortiert die Empfaenger |                    |
   |             |       nach ihren Prioritaeten       |                    |
   |             +-------------------------------------+                    |
   |g                               |                                      g|
   |g                               |   +--------------------+             g|
   |f                               |   |                    |             f|
   |                                V   V                    |              |
   |R                    +-----------------------+     +-----------+       R|
   |e                    |   Aenderer-Objekte    |---->| Aenderung |       e|
   |k                    +-----------------------+     +-----------+       k|
   |u                           |                                          u|
   |r                           V                                          r|
   |s                 +-----------------+   +-------------+                s|
   |i                 |    Abbrecher    |-->|   Abbruch   |                i|
   |o                 +-----------------+   +-------------+                o|
   |n                        |                     |                       n|
   |                         |                    <+>                       |
   |                         |                     |                        |
   |          *=======================*  *========================*         |
   |          |     Kein Abbruch      |  |        Abbruch!        |         |
   |          | Ereignis findet statt |  |Ereignis findet n. statt|         |
   |          *=======================*  *========================*         |
   |                         |                     |                        |
   |                         V                     |                        |
   |    +--------+   +-------------+               |                        |
   +--<-| Aktion |<--|   Handler   |               |                        |
   |    +--------+   +-------------+               |                        |
   |                        |                      |                        |
   |                        V                      |                        |
   |    +--------+   +-------------+        +-------------+   +--------+    |
   +--<-| Aktion |<--| Std-Handler |        |  C-Handler  |-->|Reaktion|->--+
   |    +--------+   +-------------+        +-------------+   +--------+    |
   |                        |                      |                        |
   |                       <*>                     |                        |
   |                        |                      |                        |
   |                        V                      V                        |
   |    +--------+   +-------------+        +-------------+   +--------+    |
   +--<-|Reaktion|<--|  Reagierer  |        | C-Reagierer |-->|Reaktion|->--+
        +--------+   +-------------+        +-------------+   +--------+

	Wie man sieht duerfen Aenderer und Abbrecher weder eine Aktion
	starten noch einen rekursiven Event. Nach der Abarbeitung der
	Abbrecher teilen sich die Moeglichkeiten auf, je nachdem, ob
	ein Abbruch erfolgte oder nicht. Im Prinzip sind der rechte und
	der linke Zweig sehr aehnlich; um die Reagierer zu unterscheiden
	wurden sie 'Cancelled Reactors' genannt. Genauere Informationen
	zu den Prioritaeten findet man in der entsprechenden Hilfeseite.

        Es gibt jeweils nur genau einen Std-Handler und C-Handler. Der
        C-Handler wird festgelegt als das Objekt, welches den Abbruch
        ausloeste.

        An der Stelle <*> kann das Ereignis mittels EM_STOP_HANDLE
        kurzzeitig unterbrochen werden. Aehnlich ist es an der Stelle <+>
        und EM_STOP_CANCEL. Diese Moeglichkeiten werden nur fuer Lib
        benoetigt und sollten NIEMALS von normalen Dingen verwendet werden!

PROBLEME
        Einzige Probleme sind eine moeglichst 'effektive', das heisst
        schnelle Behandlung des Events im Event-Daemon, damit so ein System
        nicht zu Lag fuehrt und eine 'sinnvolle' Verteilung der Priori-
        taeten, damit ein Objekt nicht auf einen Event reagiert, den ein
        anderes Objekt vielleicht noch aendern oder abbrechen will.

SIEHE AUCH
        event_prioritaeten(WL), event_listeners(WL), event_senders(WL), 
        event_types(WL), events_fuer_alle(WL), listen_event(S), 
        unlisten_event(S), set_global_listener(S), cancel_event(S), 
        handle_event(S), send_event(S), event_daemon(WL)


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