Lpc Manpages

                             Der Virtual Compiler
                                       
Allgemeines

  Wozu ueberhaupt einen Virtual Compiler?
  
   Der Virtual Compiler ist ein Hilfmittel fuer den Programmierer, mit
   dessen Hilfe man sehr leicht eine ganze Reihe von Objekten erzeugen
   kann, die einander recht aehnlich sind. Dabei werden diese Objekte
   lediglich im Speicher des MUDs erzeugt, ohne jemals wirklich als File
   vorhanden gewesen zu sein. Da sich die mit dem Virtual Compiler
   erzeugten Objekte jeweils untereinander sehr aehnlich sind, fuehrt dies
   insbesondere bei der Erzeugung von Raeumen sehr haeufig zu eintoenigen
   Landschaften.
   
  Wie wird der Virtual Compiler aufgrufen?
  
   Wann immer der Game Driver auf ein Objekt zugreifen will, geschieht
   der Reihe nach folgendes:
     * in einer internen Liste, in der alle geladenen Objekte verzeichnet
       sind, wird geprueft, ob ein Objekt mit diesem Namen bereits
       vorhanden ist. Ist es vorhanden, wird darauf zugegriffen,
       ansonsten
     * versucht er das Objekt anhand des Dateinamens zu laden und zu
       kompilieren. Kann er keine Datei mit dem entsprechenden Namen
       finden, dann
     * uebergibt er die Anfrage nach dem File an das Master Objekt
       /secure/master.c. Das Master Objekt sucht nun im angegebenen
       Verzeichnis nach einer Datei namens virtual_compiler.c und ruft
       dort die Funktion object compile_object(string filename) auf.
       Der Virtual Compiler hat nun die Moeglichkeit zu pruefen, ob er sich
       fuer ein Objekt mit dem Namen filename zustaendig fuehlt und muss
       gegebenenfalls ein geeignetes Objekt zurueckliefern, ansonsten
     * erscheint die allseits beliebte Fehlermeldung Failed to load File.
       
  v_compiler.c

   Praktischerweise muss sich nicht jeder seinen eigenen Virtual Compiler
   schreiben, sondern es gibt bereits ein fertiges Objekt auf das man als
   Magier zurueckgreifen kann /std/virtual/v_compiler.c. Zusaetzlich zur
   Funktion compile_object() definiert v_compiler.c noch eine Reihe
   weiterer Funktion und Properties, die nun vorgestellt werden:
   
  P_STD_OBJECT
  
   Diese Property zeigt auf das Basisobjekt von dem wir spaeter unsere
   virtuellen Objekte ableiten wollen. Bei Raeumen wird dies in der Regel
   ein von uns modifizierter Nachkomme von /std/room.c sein. Aber
   grundsaetzlich lassen sich alle Arten von Objekten mit dem Virtual
   Compiler erzeugen.
   
  Validate

   Der Funktion string Validate(string file) wird ein Filename uebergeben.
   Das Standard Validate() gibt prinzipiell den uebergebenen String file
   zurueck, schneidet dabei jedoch ein eventuell vorhandenes .c ab. Mit
   diesem Verhalten, fuehlt sich der Virtual Compiler zunaechst fuer alles
   zustaendig. Bei Dateinamen fuer die der Virtual Compiler sich nicht
   zustaendig fuehlen soll, muss 0 zurueckgegeben werden. Die Funktion muss
   deshalb ueberschrieben werden.
     _________________________________________________________________
   
   Beispiel
   Dieser Virtual Compiler fuehlt sich fuer alles zustaendig was den
   Dateinamen fackel#name_eines_eingeloggten_spielers traegt

 inherit "/std/virtual/v_compiler.c";

 #include <v_compiler.h>

 void create() 
 {
   ::create();
   SetProp(P_STD_OBJECT, "/obj/fackel"); // das Objekt das immer geclont wird
 }

 string Validate(string file) 
 {
   string name;

   if (!file = ::Validate(file)) return 0; // _immer_ wichtig !!!
 
   if (sscanf(file, "fackel#%s", name) == 1) && find_player(name))
     return file;
   return 0;
 }
     _________________________________________________________________
   
   Beispiel
   Dieser Virtual Compiler verwaltet drei Kellerraeume

 string Validate(string file) 
 {
   if (!file = ::Validate(file)) return 0; // _immer_ wichtig !!!

   switch(file) 
   {
     case "keller0":
     case "keller1":
     case "keller2": return file;
     default:        return 0;
   }
 }
     _________________________________________________________________
     
   CustomizeObject
   
   Die Funktion mixed CustomizeObject() wird benoetigt, wenn der Virtual
   Compiler nicht nur identische Standardobjekte erzeugen soll, sondern
   diese Objekte jeweils speziell angepasst werden sollen. Das zu
   modifizierende Standardobject (aus P_STD_OBJECT) laesst sich innerhalb
   von CustomizeObject jeweils mit previous_object() ansprechen.
   Saemtliche eFuns und lFuns koennen dabei verwendet werden.
     _________________________________________________________________
   
   Beispiel
   Die Kurzbeschreibung der Fackel soll auch noch den Namen des Spielers
   enthalten

 mixed CustomizeObject() 
 {
   string file, name;

   file = ::CustomizeObject();

   sscanf(file, "fackel#%s", name);
   name = find_player(name)->name(WESSEN);

   previous_object()->SetProp(P_SHORT, name+" Fackel");
 }
     _________________________________________________________________
   
  P_COMPILER_PATH
  
   Die Property P_COMPILER_PATH enthaelt den kompletten Pfad zum
   Verzeichnis in dem der Virtual Compiler liegt ohne abschliessenden /.
   Sie wird automatisch durch den Aufruf von ::create() gesetzt, kann
   jedoch ueberschreiben werden. Sie kann zum Beispiel in Gegenden die aus
   virtuellen Raeumen bestehen benutzt werden um in den Ausgaengen den
   vollstaendigen Pfad korrekt zu setzen.
     _________________________________________________________________
   
   Beispiel
   Die Kellerraeume bekommen auch Ausgaenge

 mixed CustomizeObject() 
 {
   string file, path;

   if (!file = ::CustomizeObject()) return;
   path = QueryProp(P_COMPILER_PATH) + "/";

   switch (file) 
   {
     case "keller0":
       previous_object()->AddExit("osten", path + "keller1");
       break;
     case "keller1":
       previous_object()->AddExit("westen", path + "keller0");
       previous_object()->AddExit("osten", path + "keller2");
       break;
     case "keller2":
       previous_object()->AddExit("westen", path + "keller1");
       break;
     default:
      // no default
   }
 }
     _________________________________________________________________
     
   Hinweise

   Durch mischen der Beispiele von Fackeln und Raeumen lassen sich auch
   Gegenden erschaffen in denen jeder Spieler seine eigenen Raeume hat.
   Hier gibt es aber eine Falle bei AddExit die zu beachten ist. Ein
   AddExit("westen", path+"raum1#hadra") fuehrt zu der zunaechst
   verwirrenden Fehlermeldung Failed to load File. Grund hierfuer ist die
   besondere Bedeutung des # innerhalb von AddExit.
   
   Dieses Problem laesst sich nur dadurch loesen, dass die lange
   Schreibweise in der Form AddExit("westen", ([EX_DEST:
   path+"raum1#hadra"])) gewaehlt wird.
   
   Trotzdem ist es mit Hinblick auf die Vergabe von Forscherpunkten
   sinnvoll, bei individuellen Raeumen das # als Trennzeichen zu
   verwenden.
   
 Das Standardobjekt

   Im Standardobjekt (definiert in P_STD_OBJECT) muss vor allen Dingen am
   Ende des create() der Aufruf previous_object()->CustomizeObject();
   stehen, damit eventuelle Anpassungen die der Virtual Compiler am
   Standardobjekt durchfuehren moechte auch tatsaechlich ausgefuehrt werden.
   
   Da alle virtuellen Objekte Clones des Standardobjekts sind, darf das
   create() auch keine Zeile der From if (is_clone(this_object()))
   return; enthalten.
   
   Alle Funktionen, die spaeter zum Beispiel fuer AddCmd oder
   AddSpecialDetail benoetigt werden, muessen bereits im Standardobjekt
   definiert werden.
   
 Der Virtual Room Compiler

   Der Virtual Room Compiler /obj/virtual/vr_compiler.c bietet alle
   Basisfunktionen, die benoetigt werden um schnell und einfach
   quadratische Gegenden, die auf dem Virtual Compiler beruhen und
   Standardausgaenge nach Norden, Sueden, Osten und Westen haben zu
   erzeugen. Alle Objekte haben Namen der Form name[x,y].
   
   Dazu definiert der Virtual Room Compiler eine Reihe zusaetzlicher
   Properties.
   
  P_VALID_NAME
  
   Hier wird der Standardname festgelegt, den alle vom Vritual Room
   Compiler erzeugten Objekte haben sollen, zum Beispiel wueste.
   
  P_MIN_X, P_MAX_X, P_MIN_Y, P_MAX_Y
  
   Mit diesen Properties werden die maximalen und minimalen zulaessigen X-
   und Y-Koordinaten der erzeugten Objekte festgelegt. Nur Objekte deren
   Name mit P_VALID_NAME beginnt und die sich innerhalb der Koordinaten
   befinden, werden tatsaechlich erzeugt. Um abwechslungsreiche Gegenden
   zu erzeigen, sollte auf alle Faelle CustomizeObject() ueberschrieben
   werden.
     _________________________________________________________________
   
   Beispiel
   Eine Gegend der Groesse 10 mal 10 (wueste[0,0] bis wueste[9,9])

 inherit "/obj/virtual/vr_compiler";
 #include <v_compiler.h>
 #include "/obj/virtual/vr_compiler.h";

 void create() 
 {
   ::create();
   SetProp(P_STD_OBJ, "/irgend/ein/nachfolger/von/std/room");
   SetProp(P_NAME, "wueste");
   SetProp(P_MIN_X, 0);
   SetProp(P_MAX_X, 9);
   SetProp(P_MIN_Y, 0);
   SetProp(P_MAX_Y, 9);
}