Hier ist die deutschsprachige Doku einiger applied lfuns für die Enzy drin. /* FUNKTION: create DEKLARATION: void create() BESCHREIBUNG: Die Funktion create wird in einem Objekt aufgerufen, wenn das Objekt erschaffen wird. Daher gehört in diese Funktion alles hinein, was ein einziges mal beim Erschaffen des Objektes getan werden soll wie Aussehen, Geruch, Geräusch, Name, Geschlecht usw bei Gegenständen, Ausgänge und add_types bei Räumen und ähnliches. Werden globale Variablen nicht bereits in ihrer Deklaration initialisiert (mapping blubber = ([]);) so ist create der geeignete Ort, dies zu tun. Überlagert man diese Funktion, so sollte man dort die create()-Routinen der Inherits aufrufen mit: "*"::create(); Dies kann man auch tun, wenn man unsicher ist, ob ein Inherit überhaupt ein create() besitzt (oder vielleicht mal besitzen wird). Meist wird am Ende von create noch die Funktion reset aufgerufen, siehe dort. VERWEISE: reset, init, clonep GRUPPEN: applied, grundlegendes */ /* FUNKTION: reset DEKLARATION: void reset() BESCHREIBUNG: Die Funktion reset dient dazu, einen Raum, ein Monster, einen Gegenstand oder was auch immer "aufzuräumen" und in einen Ausgangszustand zurück zu versetzen. Dazu gehören beispielsweise: Erschaffen von Dingen / Monstern, die da sein sollen, falls sie nicht da sind; schließen von Türen, Truhen, Schränken; leeren von Muelleimern; führen von Waffen bei Monstern, falls ein Spieler das Monster dazu gebracht hat, die Waffe zu senken; nachwachsen gepflückter Blumen oder Früchte usw. Es ist meist sinnvoll, diese Funktion am Ende der Funktion create ebenfalls aufzurufen, um das Objekt in einen Startzustand zu versetzen; ansonsten wird sie automatisch ganz grob alle 40 Minuten aufgerufen, sofern mit dem Objekt seit dem letzten Aufruf irgendetwas gemacht wurde (sprich, in ihm eine Funktion aufgerufen wurde). VERWEISE: create, init GRUPPEN: applied, grundlegendes */ /* FUNKTION: init DEKLARATION: void init() BESCHREIBUNG: Wann wird "init" aufgerufen? ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Kurz gesagt wird init in einem Objekt immer dann aufgerufen, wenn das objekt und ein lebewesen das gleiche environment bekommen (egal, ob durch eine Bewegung des Lebewesens oder des Objektes), oder wenn das eine in das andere bewegt wird (egal, ob das Lebewesen in das Objekt oder das Objekt in das Lebewesen bewegt wird). Näheres siehe unten. Andere Formulierung: Was geschieht im "init"? ~~~~~~~~~~~~~~~~~~~~~~~~ In der Funktion init werden fast immer nur die add_actions eines Objektes angegeben, siehe dazu unter "add_action". Inheritet man dabei (moeglicherweise) etwas, das ebenfalls solche actions besitzt, so darf man "*"::init(); nicht vergessen. Dies kann man auch tun, wenn man unsicher ist, ob ein Inherit überhaupt ein init() besitzt (oder vielleicht mal besitzen wird). Die Funktion "init" kann auch dazu verwendet werden, zu erkennen, dass sich ein Spieler einem Monster nähert, welches dann beispielsweise "Huhu" sagt. Erläuternde Beispiele dafür, wann "init" aufgerufen wird: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Um dies zu verdeutlichen, die (hoffentlich) verständlicheren Erklärungen an Hand von Beispielen: - Ein Lebewesen betritt einen Raum, egal, auf welchem Weg. Dann wird für dieses Lebewesen in allen Objekten (egal, ob lebendig oder nicht), die sich direkt im Raum befinden (also nicht in einem Schrank oder einer Tasche oder innerhalb eines anderen Lebewesens) die Funktion init für dieses, den Raum betretende Lebewesen, aufgerufen. Im Raum selbst, welchen das Lebewesen betritt, wird ebenfalls die Funktion init aufgerufen. - Nimmt ein Spieler einen Gegenstand, egal, ob aus einer Tasche heraus oder aus einem Raum heraus, so wird in dem Gegenstand für den nehmenden Spieler die Funktion init aufgerufen. Trägt der Spieler zufälligerweise ein Lebewesen bei sich, so wird die Funktion init auch für dieses Lebewesen aufgerufen, und zwar im Gegenstand. - legt ein Spieler einen Gegenstand hin, so wird die Funktion init für den Spieler sowie für alle sich bei dem Spieler befindlichen Lebewesen im hingelegten Gegenstand aufgerufen. - legt ein Spieler einen Gegenstand in eine Tasche, so wird die Funktion init für alle sich in der Tasche befindlichen Lebewesen (sofern vorhanden) in dem Gegenstand aufgerufen. Wem das jetzt zu einfach war: - Nimmt ein Spieler ein Lebewesen auf, so wird die Funktion init aufgerufen: - in dem Spieler selbst, der das Lebewesen genommen hat, für das genommene Lebewesen, - in dem Lebewesen, das der Spieler genommen hat, für den Spieler, - in allen Objekten (egal, ob lebendig oder nicht), die der Spieler bei sich trägt, für das genommene Lebewesen. - Legt ein Spieler ein Lebewesen hin, so wird init aufgerufen: - in allen sich bei dem hingelegten Lebewesen befindlichen Objekten, egal, ob tot oder lebendig, für das hingelegte Lebewesen, - im hingelegten Lebewesen für alle sich jetzt bei dem hingelegten Lebewesen befindlichen Lebewesen (einschliesslich dem hinlegenden Spieler selbst). So, jetzt ein verzwickterer Fall, der sich bei genauerem Hinsehen als ganz einfach erweist: - ein Spieler X gibt einem Spieler Y ein Lebewesen Z. Dann wird init aufgerufen: - im Spieler Y für das Lebewesen Z, - im Lebewesen Z für den Spieler Y, - in allen sich im Spieler Y befindlichen Objekten, egal, ob lebendig oder nicht, für das Lebewesen Z. VERWEISE: create, reset, add_action, living, this_player GRUPPEN: applied, grundlegendes */ /* FUNKTION: virtual_compiler DEKLARATION: object virtual_compiler(string name, string path) BESCHREIBUNG: Wenn versucht wird, ein Objekt zu laden, für das es kein File gibt, wird in dem Verzeichnis ein Objekt namens 'virtual_compiler' gesucht und falls es ihn gibt, in ihm die Funktion virtual_compiler(name, path) aufgerufen. Liefert diese Funktion ein Objekt zurück, so wird dieses Objekt genommen. Das zurückgelieferte Objekt muss ein Clone sein. (Einzige Ausnahme: Das Objekt heißt genauso wie das gesuchte Objekt.) Beispiel: Jemand versucht das Objekt '/d/SuperGebiet/IrgendwoDarin/room_1' zu laden. Dieses (.c-) File gibt es aber nicht. Also wird ein Objekt namens '/d/SuperGebiet/IrgendwoDarin/virtual_compiler' gesucht. Wenn es dieses Objekt gibt, wird dort die Funktion virtual_compiler("room_1", "/d/SuperGebiet/IrgendwoDarin/") aufgerufen. Diese liefert den Objektpointer auf einen Raum, der erzeugt wurde. Danach gibt es dann einen Raum mit dem Objektnamen '/d/SuperGebiet/IrgendwoDarin/room_1'. Beispiel für einen Virtual_compiler: // Dieser einfache virtual_compiler erzeugt einen Raum, wenn der name // 'new_room' ist. // Das setzen der Eigenschaften eines Raumes geht wie beim MAP-System. void create() { seteuid(getuid()); } object virtual_compiler(string name, string path) { object ob; if (name=="new_room") { ob=clone_object("/obj/room"); ob->set_short("Ein Raum"); ob->set_long("Ein Testraum erzeugt vom virtual_compiler.\n"); return ob; } } VERWEISE: setup_renamed_object GRUPPEN: grundlegendes, virtual_compiler */ /* FUNKTION: heart_beat DEKLARATION: void heart_beat BESCHREIBUNG: Wenn der Herzschlag mittels set_heart_beat eingeschaltet wurde, so wird diese Funktion automatisch alle 2 Sekunden aufgerufen. Man sollte sparsam mit dieser Möglichkeit umgehen, da es viele Driverresourcen benötigt, wenn mehrere Objekte den Herzschlag rund um die Uhr anhaben. Tritt während der Ausführung dieser Funktion ein Fehler auf, so wird der Herzschlag automatisch abgeschaltet. Falls das Objekt, in welchem diese Funktion aufgerufen wurde, lebendig ist, so wird es von this_player() während der Ausführung geliefert, anderenfalls liefert this_player() 0. VERWEISE: set_heart_beat, enable_commands, set_turn_heart_beat_off, query_turn_heart_beat_off GRUPPEN: grundlegendes, monster */ /* FUNKTION: setup_renamed_object DEKLARATION: void setup_renamed_object(object vc, string old_name) BESCHREIBUNG: Dies wird nach der Umbenennung dieses Objektes des Virtual-Compilers vc im umbenannten Objekt aufgerufen. old_name ist der alte Name. Der neue Name ist object_name(this_object()). VERWEISE: virtual_compiler GRUPPEN: grundlegendes, virtual_compiler */ /* FUNKTION: setup_renamed_object DEKLARATION: void setup_renamed_object(object ob, string old_name) BESCHREIBUNG: Dies wird nach der Umbenennung des Objektes ob im Virtual-Compiler aufgerufen. old_name ist der alte Name. Der neue Name ist object_name(ob). VERWEISE: virtual_compiler GRUPPEN: grundlegendes, virtual_compiler */ /* FUNKTION: real_filename DEKLARATION: string real_filename(string name, string path) BESCHREIBUNG: Der Master fragt diese Funktion ab, wenn die Datei path+name geladen wird, um einen Hinweis zu erhalten, ob er woanders nach Include-Dateien oder Inherits suchen soll. (Dies ist für seltene Fälle, wo ein VC eine andere Datei zur gewünschten Stelle kopiert, um sie dort zu laden.) VERWEISE: virtual_compiler GRUPPEN: grundlegendes, virtual_compiler */