diff --git a/doc/beispiele/misc/bspmon1.c b/doc/beispiele/misc/bspmon1.c
new file mode 100644
index 0000000..8ba85fc
--- /dev/null
+++ b/doc/beispiele/misc/bspmon1.c
@@ -0,0 +1,78 @@
+/*
+** Ein ganz normales Standard-monster ohne Besonderheiten
+** (von Boing)
+*/
+
+// Diese Pragmas sorgen dafuer, dass der Driver darauf achtet, dass bei
+// Funktionsargumenten, -Rueckgabewerten und teilweise bei Zuweisung von
+// Werten an Variablen der richtige Datentyp verwendet wird (z.b. kein string
+// anstelle eines int verwendet wird). Sollte in keinem Objekt fehlen.
+#pragma strong_types, save_types, rtt_checks
+
+// den Standard-NPC der Mudlib erben.
+inherit "/std/npc";
+
+#include <properties.h>
+#include <language.h>
+
+protected void create()
+{
+  ::create();    /* Nicht vergessen, ohne das geht nichts */
+
+/* Die Kurzbeschreibung wird zum Beispiel angezeigt wenn man in einen Raum
+   mit dem Monster reinlaeuft */
+  SetProp(P_SHORT, "Beispielmonster");
+
+/* Beim Anschauen des Monsters wird die long-description angezeigt */
+  SetProp(P_LONG, "Ein Beispielmonster ohne Besonderheiten.\n");
+
+/* Ein Name muss sein, da sonst z.B. im Todesfall 'Leiche von 0' daliegt */
+  SetProp(P_NAME, "Monster");
+
+/* Das Geschlecht des Monsters. Als Geschlechter sind */
+/* die in <language.h> definierten Symbole NEUTER, MALE   */
+/* und FEMALE zulaessig.                                  */
+  SetProp(P_GENDER, NEUTER);
+
+/* Ein Monster braucht mindestens eine ID, unter der man es ansprechen kann */
+/* Es kann aber auch mehrere verschiedene ID's haben.                       */
+  AddId("monster");
+  AddId("beispielmonster");
+
+/* Zuerst sollte man dem Monster einen Grundlevel geben. */
+/* Die Spellpunkte und die Lebenpunkte sowie die Attribute werden dann */
+/* automatisch angepasst. */
+  create_default_npc( 10 );
+
+/* Nun machen wir es etwas widerstandsfaehiger, indem wir P_BODY setzen.  */
+/* Nie P_TOTAL_AC oder P_AC setzen, P_TOTAL_AC wird automatisch berechnet */
+/* und P_AC ist nur fuer Ruestungen da.                                   */
+  SetProp(P_BODY, 55);
+
+/* Das Monster schlaegt mit blossen Haenden zu, also wird P_HANDS gesetzt.   */
+/* Auch hier weder P_TOTAL_WC noch P_WC setzen.                              */
+  SetProp(P_HANDS, ({" mit seinen Haenden", 55}));
+/*                  ^ dieses Leerzeichen ist wichtig                         */
+/* Beim Kampf erscheint nun: 'Das Monster greift Dich mit seinen Haenden an' */
+/* 55 entspricht der Waffenklasse                                            */
+
+/* Gesinnung des Monsters, 0 ist neutral, negativ boese und positiv gut */
+  SetProp(P_ALIGN, 100);  /* Einigermassen nett, aber nichts besonderes */
+
+/* Die Rasse des Monsters */
+  SetProp(P_RACE, "Irgendnerasse");
+
+/* Erfahrungspunkte des Monsters, beim Tod erhaelt der 'Killer' ein   */
+/* hundertstel dieses Wertes. Schon im Kampf erhaelt man bei jedem    */
+/* Schlag weapon_class*schaden/10 punkte (weapon_class hier 55), also */
+/* insgesamt weapon_class*hit_points/10.                              */
+  SetProp(P_XP, 10000);
+
+/* Die Groesse des Monsters in cm. Dies wird bei einigen Kampfbefehlen */
+/* ausgewertet, sowie bei einigen Identifikationsspruechen von Gilden  */
+  SetProp(P_SIZE,180);
+
+/* Weitere Werte: P_(MAX)_FOOD, P_(MAX)_DRINK, P_(MAX)_ALCOHOL,       */
+/* P_MSGIN, P_MSGOUT, P_MMSGIN, P_MMSGOUT, P_MAX_HANDS, P_USED_HANDS  */
+
+}
diff --git a/doc/beispiele/misc/bspmon2.c b/doc/beispiele/misc/bspmon2.c
new file mode 100644
index 0000000..95f3909
--- /dev/null
+++ b/doc/beispiele/misc/bspmon2.c
@@ -0,0 +1,199 @@
+/*
+** Ein Beispielmonster mit div Extras (von Boing, aktualisiert von Wim+Zesstra)
+*/
+
+// Diese Pragmas sorgen dafuer, dass der Driver darauf achtet, dass bei
+// Funktionsargumenten, -Rueckgabewerten und teilweise bei Zuweisung von
+// Werten an Variablen der richtige Datentyp verwendet wird (z.b. kein string
+// anstelle eines int verwendet wird). Sollte in keinem Objekt fehlen.
+#pragma strong_types, save_types, rtt_checks
+
+inherit "/std/npc";
+
+#include <properties.h>
+#include <language.h>
+#include <combat.h>    // fuer die damage types
+#include <moving.h>    // fuer REJECT_KEEP   
+#include <class.h>     // fuer AddClass 
+#include <new_skills.h> // fuer SP_* bei AddSpell
+
+protected void create()
+{
+  ::create();       /* WICHTIG!!! */
+
+/* Standard-Knofiguration (Erlaeuterungen siehe bspmon1.c): */
+  SetProp(P_SHORT, "Ein Zauberer");
+  SetProp(P_LONG, "Dieser Zauberer zaubert wie wild und schwingt dabei "
+    "seinen langen Bart.\n");
+  SetProp(P_NAME, "Zauberer");
+  SetProp(P_GENDER, MALE);
+  AddId("zauberer");
+  create_default_npc(18);
+  SetProp(P_ALIGN, -700);   /* Brrr, ist der boese .... */
+  SetProp(P_BODY, 125);
+  SetProp(P_HANDS, ({" mit seinem langen Bart", 185}) );
+  SetProp(P_SIZE,180);
+  SetProp(P_MAX_HANDS, 2);  /* Anzahl der Haende (default ist 2) */
+  // set_living_name() setzt einen Namen, mit der der Zauberer z.B. mit einem
+  // 'finde' gefunden werden kann. Fuer die meisten NPC ist dies nicht noetig.
+  // Speziell sollte man keine generischen Bezeichnungen hier anmelden, wenn
+  // schon, dann individuelle Namen.
+  /* set_living_name("zauberer"); */
+
+/* Mit AddClass() und P_RACE wird festgelegt, in welche Gruppe von Lebe-  */
+/* wesen der NPC gehoert, welche mit is_class_member(mixed str) abgefragt */
+/* werden kann. Im Minimalfall ist der NPC von der Klasse, die bei P_RACE */
+/* eingetragen ist. Mit AddClass() koennen aber noch weitere Eigen-       */
+/* schaften hinzugefuegt werden.                                          */
+
+  SetProp(P_RACE,"Superduperzauberer");
+  AddClass( ({ CL_HUMAN, CL_MAMMAL }) );
+
+/* Mit P_RESISTANCE und P_VULNERABILITY werden fixe Werte (50%) fuer      */
+/* Resistenzen respektive Anfaelligkeiten gesetzt                         */
+/* Die Liste der moeglichen Schadensarten ist in /sys/combat.h definiert. */  
+/* z.B.  SetProp(P_RESISTANCE, ({ DT_MAGIC }));                           */
+/*       SetProp(P_VULNERABILITY, ({ DT_COLD }))                          */
+/*                                                                        */
+/* Mit P_RESISTANCE_STRENGTHS koennen Resistenzen und Anfaelligkeit       */
+/* konfiguriert werden. Diese Property enthaelt ein Mapping von           */
+/* von Schadensarten enthaelt. Negative Faktoren bis maximal -1.0         */ 
+/* (=Immunitaet) geben Resistenzen, positive Werte Anfaelligkeiten an.    */
+
+  SetProp(P_RESISTANCE_STRENGTHS, ([ DT_MAGIC: -0.5, DT_COLD: 2.0]) );					      
+
+/* Durch diesen Befehl wird eine Waffe geclont, sofern sie nicht im Raum  */
+/* herumliegt (in dem Fall wird sie vom NPC aufgehoben), und gezueckt     */ 
+/* (definiert in /std/npc/items.c resp. /sys/npc.h)                       */
+
+  AddItem("/doc/beispiele/misc/bspwaffe1", CLONE_WIELD);
+/* Und noch eine Ruestung clonen und anziehen.                            */  
+  AddItem("/doc/beispiele/misc/bspruest1", CLONE_WEAR);
+
+/* Jetzt wird gezaubert ....     */
+
+/* SetProp(P_SPELLRATE,) legt die Wahrscheinlichkeit fest, mit der ein   */
+/* Zauberspruch durchgefuehrt wird, hier 40%                            */
+  SetProp(P_SPELLRATE,40);
+
+/* Mit AddSpell() wird ein Zauberspruch hinzugefuegt. Das erste Argument  */
+/* ist so etwas wie die relative Wahrscheinlichkeit des Spruchs im        */
+/* Vergleich zu den anderen, hier beim ersten spruch 1 beim zweiten 2,    */
+/* das heisst in 20% der Faelle wird der erste Zauberspruch genommen und  */
+/* in 40% der zweite und in 60% der dritte.                               */
+/* Das zweite Argument ist der maximale Schaden, entsprechend der WC      */
+/* einer Waffe oder P_HANDS beim waffenlosen Kampf.                       */
+/* Die zwei weiteren Argumente sind die Meldungen die der angegriffene    */
+/* Spieler selbst und eventuelle Zuschauer erhalten. Hierbei stehen @WER, */
+/* @WEN, @WEM und @WESSEN fuer den Namen des Opfers im entsprechenden     */
+/* Fall.                                                                  */
+/* Das 5. Argument ist optional und gibt den Schadenstyp an, fehlt er     */
+/* wird DT_MAGIC angenommen.                                              */  
+/* Im 6. Arugument kann eine Funktion stehen, die bei dem Spruch ausge-   */
+/* fuehrt werden soll,                                                    */
+/* Das siebte uebergibt die Spell Parameter, hier ist wichtig, dass bei   */
+/* physikalischen Schaeden auch SP_PHYSICAL_ATTACK gesetzt wird, da sonst */
+/* einige Gilden den "Zauberspruch" abwehren koennen (siehe SpellDefend)  */
+
+  AddSpell(20,60, 
+	   "  Der Zauberer wirft einen Feuerball nach Dir.\n",
+	   "  Der Zauberer wirft einen Feuerball nach @WEM.\n",
+	   ({ DT_FIRE }) );
+  AddSpell(40,95,
+	   "  Der Zauberer beschwoert einen Sturm ueber deinem Kopf hervor.\n",
+	   "  Der Zauberer beschwoert einen Sturm ueber @WESSEN Kopf hervor.\n",
+	   ({ DT_AIR, DT_LIGHTNING }) );  
+  AddSpell(60,50,
+           "  Der Zauberer tritt Dich hinterlistig.\n",
+	   "  Der Zauberer tritt nach @WEM.\n",
+	   ({ DT_BLUDGEON }), 0,
+	   ([SP_SHOW_DAMAGE:1, SP_PHYSICAL_ATTACK:1]) );  	   
+
+
+/* Reden kann der Zauberer auch von alleine, hier kommen die chats:     */
+
+/* Das erste Argument ist die Wahrscheinlichkeit, mit der das Monster
+ * einen Spruch bringt (weniger ist mehr!). Das zweite Argument ist die Liste
+ * der Sprueche (oder Aktionen).
+ */
+
+  SetChats(2, ({
+  "Der Zauberer laeuft im Kreis herum.\n",
+  "Der Zauberer stolpert ueber seinen Bart.\n",
+  "Der Zauberer sagt: Heh Du! Was machst Du da?\n",
+  "Der Zauberer murmelt ein paar seltsame Worte in seinen Bart.\n",
+  "Der Zauberer bricht in unkontrolliertes Gelaechter aus.\n",
+  "Der Zauberer sagt: Hast mir mal ne Mark, ey?\n",
+  "Der Zauberer sagt: Wenn ich diesen Olpp erwische ...\n",
+  "Der Zauberer zaubert ein Kaninchen aus seinem Hut.\n"
+  }) );
+
+/* Das selbe fuer Sprueche die waehrend eines Kampfes kommen sollen    */
+
+  SetAttackChats(20, ({
+  "Der Zauberer macht: Buh!\n",
+  "Der Zauberer wirft mit weissen Maeusen nach Dir.\n",
+  "Der Zauberer sagt: Das war ein grosser Fehler!\n",
+  "Der Zauberer beisst Dich in den Arm.\n",
+  "Der Zauberer zaubert gruene Punkte auf deine Wange.\n",
+  "Der Zauberer verwandelt sich in eine Kroete.\n",
+  "Der Zauberer verschwindet und taucht hinter Dir wieder auf.\n"
+  }) );
+
+/* Wenn er stirbt soll eine besondere Meldung erscheinen. */
+  SetProp( P_DIE_MSG, " loest sich in Luft auf.\n" );
+/* Dann soll natuerlich auch kein Leichnam rumliegen */
+  SetProp( P_NOCORPSE, 1 );
+ 
+/* Nun wollen wir den Zauberer noch auf ein paar Fragen antworten lassen    */
+/* AddInfo(DEFAULT_INFO,) setzt die Antwort auf alle Fragen, wo der         */
+/* Schluessel nicht bekannt ist. Der Name des Zauberers wird immer vor den  */
+/* String gesetzt. (SetProp(P_DEFAULT_INFO, ist obsolet und sollte nicht    */
+/* mehr angewendet werden.)                                                 */ 
+
+  AddInfo(DEFAULT_INFO,"sagt: Keine Ahnung, von was Du redest.\n",0,
+                       "sagt zu @WEM: Keine Ahnung, von was Du redest.\n");
+
+/* Die bekannten Schluessel werden mit AddInfo dazugefuegt, das erste       */
+/* Argument ist das Wort (oder die Liste von Woertern), zu der der Zauberer */
+/* befragt werden kann, das zweite Argument ist die entsprechende Antwort.  */
+/* ist das dritte Argument gesetzt, so wird die Antwort automatisch umge-   */
+/* brochen und bekommt den Text des Arguments vor jede Zeile gestellt.      */
+/* Das vierte, ebenfalls optionale, Argument wird sofern gesetzt an die     */
+/* umstehenden Personen ausgegeben, dadurch laesst sich ein Fluestern oder  */
+/* eine spielerabhaengige Antwort realisieren.                              */
+
+  AddInfo("kaninchen",
+  "sagt: Die hol ich immer aus meinem Hut.\n");
+  AddInfo("zauberei",
+  "sagt: Ich bin ein Meister der Zauberei.\n");
+  AddInfo(({"maus", "maeuse"}),
+  "sagt: Maeuse sind meine Lieblingstiere.\n"); 
+  
+  AddInfo( ({"tier","tiere"}), 
+          "Oh, hauptsaechlich beschaeftige ich mich mit Kaninchen und Maeusen.",
+          "fluestert Dir zu: ",
+          "fluestert mit @WEM.\n");
+
+/* Normalerweile nehmen Monster alles was man ihnen gibt, ohne einen Ton */
+/* zu sagen. Will man dort ein anderes Verhalten, so tut man das so:     */
+/* Moeglich sind auch REJECT_GIVE (= zurueckgeben) REJECT_DROP (=fallen  */
+/* lassen. */
+  SetProp( P_REJECT, ({ REJECT_KEEP, "Der Zauberer sagt: Dankeschoen.\n" }) );
+
+/* Der Zauberer kann auch zusaetzliche Verben haben, die nur er selber
+ * benutzen kann, kein anderes Living. Diese koennen mit add_action() im
+ * create eines NPC angemeldet werden (und idR NUR in dieser Funktion und NUR
+ * in Lebewesen, nicht in sonstigen Objekten! */
+  add_action("nasebohren", "bohreinnase");
+
+/* Verben, die Spieler in Gegenwart des Zauberers koennen sollen, werden     */
+/* mit AddCmd angemeldet. */
+}
+
+int nasebohren( string str ) // str ist das, was hinter dem verb eingegeben wurde.
+{
+   say( "Der Zauberer bohrt mit dem Stab in seiner Nase.\n" );
+   return 1; // Verb war erfolgreich.
+}
+
diff --git a/doc/beispiele/misc/bspraum1.c b/doc/beispiele/misc/bspraum1.c
new file mode 100644
index 0000000..3483095
--- /dev/null
+++ b/doc/beispiele/misc/bspraum1.c
@@ -0,0 +1,78 @@
+/* /doc/beispiele/misc/bspraum1.c von Rumata */
+
+// Diese Pragmas sorgen dafuer, dass der Driver darauf achtet, dass bei
+// Funktionsargumenten, -Rueckgabewerten und teilweise bei Zuweisung von
+// Werten an Variablen der richtige Datentyp verwendet wird (z.b. kein string
+// anstelle eines int verwendet wird). Sollte in keinem Objekt fehlen.
+#pragma strong_types, save_types, rtt_checks
+
+inherit "/std/room";
+
+#include <properties.h>
+#include <language.h>
+
+protected void create()
+{
+    ::create();
+
+    SetProp( P_INT_SHORT, "Ein kleines Schreibzimmer" );
+    SetProp( P_INT_LONG,
+        "Du stehst in einem kleinen Schreibzimmer.\n"
+         "Es gehoerte wohl irgendwann einmal einem Magier, aber nun\n"
+         "ist dieser Raum verwaist und rottet vor sich hin.\n"
+         "Ein grosser Schreibtisch in der Mitte des Raumes scheint\n"
+         "noch einigermassen gut erhalten zu sein. Durch die Tuer\n"
+         "im Norden faellt etwas Licht hinein.\n"
+    );
+    SetProp( P_LIGHT, 1 );
+    SetProp( P_INDOORS, 1 );
+
+    AddDetail( ({ "schreibtisch", "tisch" }),
+        "Auf dem Tisch liegt eine dicke Staubschicht.\n"
+        "Eine Schublade findest Du ebenfalls.\n"
+    );
+    AddDetail( ({ "staub", "staubschicht", "schicht" }),
+        "Du malst gelangweilt einige Kreise in den Staub.\n"
+    );
+    AddDetail( "schublade",
+        "So sehr Du Dich anstrengst; Du kannst sie nicht bewegen.\n"
+    );
+    AddDetail( "tuer" ,
+        "Sie steht seit Jahren offen und ist in dieser Lage\n"
+        "hoffnungslos festgerostet.\n"
+    );
+
+    AddCmd( ({ "schliesse", "oeffne", "bewege", "schliess", "beweg" }), 
+            "beweg_etwas" );
+    AddExit( "norden", "players/rumata/workroom" );
+}
+
+public int beweg_etwas( string str )
+{
+    notify_fail( "Was willst Du denn bewegen ?" );
+    if( str == "tuer" )
+    {
+        write( "Die Tuer ist hoffnungslos festgerostet.\n" );
+        return 1;
+    }
+    if ( str == "lade" || str == "schublade" )
+    {
+        write( "Die Schublade klemmt einfach nur.\n" );
+        return 1;
+    }
+    if ( query_verb() == "bewege" &&
+        ( str == "tisch" || str == "schreibtisch" ) )
+    {
+        tell_object(this_player(),
+            "Der Tisch scheint am Boden festgeschraubt zu sein.\n"
+        );
+        tell_room(this_object(),
+            this_player()->name(WER,2)+" zerrt am Schreibtisch.\n"
+        );
+        return 1;
+    }
+ // offenbar passte nix, Kommando nicht erfolgreich abgearbeitet. Ggf. weitere
+ // versuchen und/oder die notify_fail-Meldung ausgeben.
+    return 0;
+}
+
diff --git a/doc/beispiele/misc/bspruest1.c b/doc/beispiele/misc/bspruest1.c
new file mode 100644
index 0000000..10e3b0e
--- /dev/null
+++ b/doc/beispiele/misc/bspruest1.c
@@ -0,0 +1,38 @@
+/*
+** Eine Beispielruestung
+** (von Boing)
+*/
+
+// Diese Pragmas sorgen dafuer, dass der Driver darauf achtet, dass bei
+// Funktionsargumenten, -Rueckgabewerten und teilweise bei Zuweisung von
+// Werten an Variablen der richtige Datentyp verwendet wird (z.b. kein string
+// anstelle eines int verwendet wird). Sollte in keinem Objekt fehlen.
+#pragma strong_types, save_types, rtt_checks
+
+inherit "/std/armour";
+
+#include <properties.h>
+#include <combat.h>
+#include <language.h>
+
+protected void create()
+{
+  ::create();   /* WICHTIG!!! */
+
+/* Standardkonfiguration, genaueres siehe /doc/beispiele/bspwaffe1.c    */
+  SetProp(P_SHORT, "Ein grauer Umhang");
+  SetProp(P_LONG, "Es ist ein langer grauer Umhang aus einem feinen Material.\n");
+  SetProp(P_NAME, "Umhang");
+  SetProp(P_GENDER, MALE);
+  AddId("umhang");
+  SetProp(P_WEIGHT, 250);
+  SetProp(P_VALUE, 200);
+
+/* Zur Waffe fehlt nicht mehr viel, nur noch die Ruestungsklasse (AC)    */
+/* setzen und einen Ruestungstyp setzen. Die Typen sind in sys/combat.h  */
+/* definiert. Richtlinien zu Ruestungsklassen der verschiedenen Typen    */
+/* stehen momentan in /players/boing/waffen.                             */
+
+  SetProp(P_ARMOUR_TYPE, AT_CLOAK);
+  SetProp(P_AC, 8);
+}
diff --git a/doc/beispiele/misc/bsptransporter1.c b/doc/beispiele/misc/bsptransporter1.c
new file mode 100644
index 0000000..3e26020
--- /dev/null
+++ b/doc/beispiele/misc/bsptransporter1.c
@@ -0,0 +1,132 @@
+inherit "std/transport";
+
+/* wolke.c Ein Beispiel zur Programmierung eines Transporters */
+/* von Rumata (mit kleinen Bugfixes von Wargon ;) */
+
+#include <properties.h>
+#include <language.h>
+
+create()
+{
+  ::create();
+  SetProp( P_NAME, "Woelkchen" );
+  AddId( ({ "wolke", "woelkchen" }) );
+  SetProp( P_GENDER, NEUTER );
+  SetProp( P_INT_SHORT, "Auf einer kleinen Wolke" );
+  SetProp( P_INT_LONG,
+	  "Du sitzt auf einer kleinen Wolke, die zwischen Jofs und Rumatas\n"
+	  +	"Arbeitszimmer hin- und herpendelt. Wenn sie niedrig fliegt, kannst\n"
+	  +	"Du bestimmt von ihr heruntersteigen.\n"
+	  );
+  SetProp( P_SHORT, "Eine kleine Wolke" );
+  SetProp( P_LONG,
+	  "Diese suesse kleine Cumuluswolke schwebt zwischen Jofs und Rumatas\n"
+	  +	"Arbeitszimmer hin und her. Vielleicht kannst Du auf sie draufsteigen.\n"
+	  );
+  SetProp(P_LIGHT, 1 );
+  SetProp(P_TRANSPARENT,1);
+  // Man soll auf(in) die Wolke und von ihr herunter schauen koennen.
+    
+  /*** Meldungen, die Transporter geben koennen ***/
+  
+  SetProp( P_DEPARTMSG, ({
+    "Die Wolke steigt in die Luft.\n", 
+    "Die Wolke fliegt davon.\n"
+  }) );
+  // Die erste Meldung ist fuer Leute auf der Wolke.
+  // Die zweite fuer Leute in dem Raum, in dem die Wolke ankommt.
+      
+  SetProp( P_ARRIVEMSG, ({
+    "Die Wolke naehert sich dem Boden von @@QueryArrived@@.\n",
+    "Eine kleine Wolke schwebt herab.\n"
+  }) );
+  // Die erste Meldung ist fuer Leute auf der Wolke.
+  // Die zweite fuer Leute in dem Raum, aus dem die Wolke abreist.
+    
+  SetProp( P_ENTERMSG, ({
+    "steigt auf die Wolke",
+    "kommt auf die Wolke"
+  }) );
+  // Die erste Meldung ist fuer den Raum, aus dem der Spieler kommt.
+  // (=Raum). Die zweite Meldung ist fuer Spieler in dem Raum, in
+  // den der Spieler geht (=Transporter).
+	
+  SetProp( P_LEAVEMSG, ({
+    "steigt von der Wolke",
+    "steigt von der Wolke"
+  }) );
+  // Die erste Meldung ist fuer den Raum, aus dem der Spieler kommt.
+  // (=Transporter). Die zweite Meldung ist fuer Spieler in dem Raum,
+  // in den der Spieler geht (=Raum).
+      
+  SetProp( P_LEAVEFAIL, "Die Wolke schwebt viel zu hoch" );
+  // Meldung, die kommt, wenn ein Spieler den Transporter verlassen
+  // will, aber dieser an keinem Raum angelegt hat.
+  // Ist der Parameter ein String (so wie hier), so bekommt nur
+  // der betreffende Spieler die Meldung, wenn sie ein Array aus
+  // 2 Elementen ist, bekommt der Spieler die erste und alle
+  // anderen Spieler im Transporter die zweite (mit dem Namen
+  // des Spielers davor).
+  // Moeglich waere also auch:
+  /*
+     SetProp( P_LEAVEFAIL, ({
+     "Die Wolke schwebt viel zu hoch zum Herunterspringen",
+     "faellt fast von der Wolke"
+     }) );
+  */
+
+  SetProp( P_ENTERFAIL, "Es passen nur 5 Passagiere auf die Wolke.\n" );
+  // Diese Meldung bekommt der Spieler, wenn er versucht, einen
+  // vollen Transporter zu betreten. Hier ist nur eine Meldung
+  // (an den Spieler) vorgesehen.
+
+  SetProp( P_MAX_PASSENGERS, 5 );
+  // Maximale Anzahl der Spieler, die sich im Transporter befinden
+  // koennen. Fuer Gegenstaende gibt es keine Beschraenkung.
+
+  /* Verben */
+  AddCmd( ({ "steig", "steige", "spring", "springe" }), "steige" );
+
+  /* Kurs */
+  AddRoute( "players/rumata/workroom", 30, 20, "Rumatas Arbeitszimmer" );
+  // Hier wird der Raum /players/rumata/workroom als Anlegeplatz
+  // in den Kurs eingefuegt. Der Transporter verweilt 30sek in diesem
+  // Raum und faeht dann 20sek lang, bis er den naechten Punkt
+  // erreicht. Danach kann man noch den Code angeben, der bei
+  // QueryArrived zurueckgegeben wird, setzen. Wird kein Code
+  // gesetzt, wo wird dort ein Leerstring zurueckgegeben. 0 wird
+  // dann zurueckgegeben, wenn der Transporter an keinem Raum angelegt
+  // hat.
+
+  AddMsg( "Die Wolke treibt nun im Wind Richtung Jofs Arbeitszimmer.\n", 30 );
+  // Hier wird eine Meldung ausgegeben, und der Transporter reist 30sek lang
+  // weiter.
+
+  AddMsg( "Die Wolke beginnt zu sinken.\n", 10 );
+  AddRoute( "players/jof/workroom", 30, 20, "Jofs Arbeitszimmer" );
+  AddMsg( "Die Wolke treibt nun im Wind Richtung Rumatas Arbietszimmer.\n", 30 );
+  AddMsg( "Die Wolke beginnt zu sinken.\n", 10 );
+  // Nach dem Letzten Haltepunkt wird der Kurs wieder von vorn
+  // befahren.
+ 	
+  Start();
+  // Lasse den Transporter am ersten dieser Haltepunkte starten.
+}
+
+steige(str)
+{
+  string arg, arg2;
+  
+  if (sscanf( str, "auf %s", arg ) > 0 && id(old_explode(arg," ")[0]))
+    return Enter();
+  // Wenn sicher ist, dass der Spieler die Wolke BEsteigen will,
+  // kann man mit return Enter() alle weiteren Tests durchfuehren.
+
+  if (sscanf( str, "von %s", arg ) > 0 && id(old_explode(arg, " ")[0]))
+    return Leave();
+  // Das selbe gilt fuer das ABsteigen und Leave().
+  // Verben sollten nach Enter() oder Leave() keine weiteren Befehle
+  // enthalten.
+}
+
+
diff --git a/doc/beispiele/misc/bspwaffe1.c b/doc/beispiele/misc/bspwaffe1.c
new file mode 100644
index 0000000..259ae2a
--- /dev/null
+++ b/doc/beispiele/misc/bspwaffe1.c
@@ -0,0 +1,56 @@
+/*
+** Eine Beispielwaffe
+** (von Boing)
+*/
+
+// Diese Pragmas sorgen dafuer, dass der Driver darauf achtet, dass bei
+// Funktionsargumenten, -Rueckgabewerten und teilweise bei Zuweisung von
+// Werten an Variablen der richtige Datentyp verwendet wird (z.b. kein string
+// anstelle eines int verwendet wird). Sollte in keinem Objekt fehlen.
+#pragma strong_types, save_types, rtt_checks
+
+inherit "/std/weapon";
+
+#include <properties.h>     /* Definition der Properties */
+#include <combat.h>         /* Definition der kampfspezifischen Konstanten */
+#include <language.h>       /* Definition von MALE, FEMALE, WER, ... */
+
+protected void create()
+{
+  ::create();   /* WICHTIG!!! */
+
+/* Kurzbeschreibung fuer Darstellung in inventories */
+  SetProp(P_SHORT, "Ein Knueppel");
+
+/* Beschreibung des Knueppels */
+  SetProp(P_LONG, 
+  "Dieser Knueppel ist ziemlich normal, er ist aus festem Holz gefertigt und\n"+
+	  "man kann ihn als Waffe benutzen.\n");
+
+/* Name und Geschlecht sind wichtig, jedes Objekt braucht das */
+  SetProp(P_NAME, "Knueppel");
+  SetProp(P_GENDER, MALE);
+
+/* Jedes Objekt braucht eine oder mehrere Id's */
+  AddId("knueppel");
+
+/* Wert und Gewicht */
+  SetProp(P_VALUE, 300);
+  SetProp(P_WEIGHT, 1250);   /* in Gramm */
+
+/* Nun die wirklich Waffenspezifischen Dinge:                   */
+/* Waffen- und Schadensarten sind in /sys/combat.h definiert    */
+  SetProp(P_WEAPON_TYPE, WT_CLUB);
+  SetProp(P_DAM_TYPE, DT_BLUDGEON);
+
+/* Die Waffenklasse muss im Bereich zwischen 1 und 200 liegen   */
+  SetProp(P_WC, 125);
+  
+/* Anzahl der benoetigten Haende, um die Waffe zu zuecken.      */
+/* Waffen mit einer WC groesser 150, sollten auf jeden Fall     */
+/* Zweihaender sein, bei Sonderfaellen bitte an den Erzmagier   */
+/* fuer Waffen wenden. Wenn nichts gesetzt wird, ist die Waffe  */
+/* ein Zweihaender.                                             */
+  SetProp(P_NR_HANDS, 1);
+}
+
diff --git a/doc/beispiele/misc/krankheit.c b/doc/beispiele/misc/krankheit.c
new file mode 100644
index 0000000..c5816a3
--- /dev/null
+++ b/doc/beispiele/misc/krankheit.c
@@ -0,0 +1,66 @@
+/*  Paracelsus: Eine Krankheit
+**
+**      Beispiel fuer die Verwendung von P_X_ATTR_MOD und P_X_HEALTH_MOD
+**
+**      Diese Krankheit setzt alle Attribute herab und erniedrigt
+**      zusaetzlich P_MAX_HP und P_MAX_SP um jew. 20 (zusaetzlich zu den
+**      Auswirkungen der Attributsenkungen).
+**      Gestartet wird die Krankheit, indem sie einfach in das Opfer
+**      bewegt wird.
+**      Man beachte, dass im remove() die P_X_*-Properties ein leeres
+**      Mapping zugewiesen bekommen und keine 0. Nur so werden die
+**      Krankheitsfolgen rueckgaengig gemacht.
+*/
+
+// Diese Pragmas sorgen dafuer, dass der Driver darauf achtet, dass bei
+// Funktionsargumenten, -Rueckgabewerten und teilweise bei Zuweisung von
+// Werten an Variablen der richtige Datentyp verwendet wird (z.b. kein string
+// anstelle eines int verwendet wird). Sollte in keinem Objekt fehlen.
+#pragma strong_types, save_types, rtt_checks
+
+inherit "/std/thing";
+
+#include <properties.h>
+#include <moving.h>
+#include <language.h>
+#include <class.h>
+
+protected void create()
+{
+    ::create();
+
+    // ausnahmsweise darf dieses Objekt mal kein P_SHORT+P_LONG haben...
+    SetProp(P_SHORT,0);
+    SetProp(P_LONG, 0);
+    SetProp(P_INVIS, 1); // unsichtbar machen.
+    SetProp(P_NAME,"Krankheit");
+    SetProp(P_GENDER,FEMALE);
+    // wichtig, sonst wiegt die Krankheit 1kg (Standardgewicht fuer thing) 
+    SetProp(P_WEIGHT,0);
+    SetProp(P_VALUE,0);
+    SetProp(P_MATERIAL,MAT_MISC_MAGIC);
+    SetProp(P_NODROP,1); // Nicht wegwerfbar.
+
+// ----> Dieser Abschnitt sorgt fuer fiese Statabzuege
+
+    SetProp(P_X_HEALTH_MOD,
+    ([
+        P_HP : -20,   // Max. Lebenspunkte um 20 runter
+        P_SP : -20    // Max. Konzentrationspunkte um 20 runter
+    ]) );
+    SetProp(P_X_ATTR_MOD,
+    ([
+        A_CON : -1,   // Ausdauer um 1 runter, reduziert auch max. LP!
+        A_DEX : -1,   // Geschicklichkeit um 1 runter
+        A_INT : -2,   // Intelligenz um 2 runter, reduziert auch max. KP!
+        A_STR : -4,   // Staerke um 4 runter
+    ]) );
+
+// <----
+
+    AddId( ({"PARA\nSICK\nEXAMPLE"}) );
+
+    AddClass(CL_DISEASE); // Damit Kleriker helfen koennen.
+    SetProp(P_LEVEL,15);  // Aber nicht ganz so einfach zu entfernen
+}
+
diff --git a/doc/beispiele/misc/lebensring.c b/doc/beispiele/misc/lebensring.c
new file mode 100644
index 0000000..f82ea5e
--- /dev/null
+++ b/doc/beispiele/misc/lebensring.c
@@ -0,0 +1,56 @@
+/* Paracelsus: Lebensring
+**
+**    Ein Beispiel fuer die Anwendung von P_M_HEALTH_MOD
+**
+**    Zieht ein Spieler diesen Ring an, so erhoehen sich seine maximalen
+**    Lebenspunkte dabei um 10, waehrend seine max. Konzentrationspunkte
+**    um 5 erniedrigt werden.
+*/
+
+// Diese Pragmas sorgen dafuer, dass der Driver darauf achtet, dass bei
+// Funktionsargumenten, -Rueckgabewerten und teilweise bei Zuweisung von
+// Werten an Variablen der richtige Datentyp verwendet wird (z.b. kein string
+// anstelle eines int verwendet wird). Sollte in keinem Objekt fehlen.
+#pragma strong_types, save_types, rtt_checks
+
+inherit "/std/armour";
+
+#include <properties.h>
+#include <armour.h>
+#include <language.h>
+#include <combat.h>
+
+protected void create()
+{
+    ::create();
+
+    SetProp(P_SHORT,"Ein Lebensring");
+    SetProp(P_LONG,
+        "Ein kleiner Ring aus einem seltsamen, gruenen Material.\n");
+    SetProp(P_INFO,
+        "Dieser Ring unterstuetzt die Gesundheit.\n"+
+        "Dabei schwaecht er leider den Geist.\n");
+    SetProp(P_NAME,"Lebensring");
+    SetProp(P_GENDER,MALE);
+    SetProp(P_WEIGHT,80);
+    SetProp(P_VALUE,2000+random(501));
+    SetProp(P_ARMOUR_TYPE,AT_RING);
+    SetProp(P_AC,0); // keine Schutzwirkung im Kampf
+    SetProp(P_MATERIAL,MAT_MISC_MAGIC);
+
+// ---->
+
+    SetProp(P_M_HEALTH_MOD,
+    ([
+        P_HP : 10,      // Max. LP um 10 erhoehen
+        P_SP : -5       // Max. KP um 5 verringern
+    ]) );
+
+// <----
+
+    AddId( ({"ring","lebensring"}) );
+
+    AddDetail( "material",
+        "Es ist gruen.\n");
+}
+
diff --git a/doc/beispiele/misc/seherhaus.c b/doc/beispiele/misc/seherhaus.c
new file mode 100644
index 0000000..ea127e4
--- /dev/null
+++ b/doc/beispiele/misc/seherhaus.c
@@ -0,0 +1,136 @@
+/*
+Kurze Uebersicht der Termini:
+
+P_HAUS_ERLAUBT     Propertie, die das Bauen eines Hauses im Raum er-
+                   laubt oder verbietet. Default auf 0
+                   Syntax: xcall $h->SetProp(P_HAUS_ERLAUBT,x)
+                   
+Save()             Muss nach Aenderungen am Haus aufgerufen werden.
+                   Syntax: xcall /d/seher/haeuser/tillyhaus->Save()
+
+Okay, also ein Seher moechte, dass sein Haus 1) unsichtbar ist, 2) mit
+einem anderen Kommando betreten werden soll und 3) nicht auf die id 
+<haus> hoert sondern auf eine andere:
+
+Zu 1): Ganz einfach, man tippe 
+
+       'xcall /d/seher/haeuser/tillyhaus->SetProp(P_SHORT,0)' und
+       'xcall /d/seher/haeuser/tillyhaus->Save()'
+
+Zu 2) und 3): Das ist nicht so einfach, sondern muss ueber den Raum, in 
+              dem das Haus steht, gemacht werden. Deswegen folgend nun 
+              ein Beispiel zu Funktionen in so einem Raum.
+
+
+Folgende Dinge stehen natuerlich schon im Raum, sonst liesse er sich
+nicht laden :-)              
+*/
+
+#pragma strong_types, save_types, rtt_checks
+
+inherit "/std/room";
+
+#include <properties.h>
+#include <language.h>
+#include <moving.h>
+
+/*
+   Fuer properties und sonstige Definitionen zum Seherhaus.
+*/
+#include "/d/seher/haeuser/haus.h"
+
+/*
+   Aus Gruenden der Uebersichtlichkeit ziehen viele Magier vor, den Hauskrams
+   in eine separate Funktion zusammenzufassen.
+*/
+private void haus_create();
+
+/*
+Es folgt nun das normale create() eines Raumes
+*/
+void create(){
+  ::create();
+  /* ... div. Konfiguration des Raum ... */
+
+  /*
+  Das extra-create() muss natuerlich aufgerufen werden
+  */  
+  haus_create();
+}      
+
+/*
+Hier kommen wir nun zu der Fkt, die alles am Seherhaus verwaltet
+*/
+private void haus_create()
+{
+  object ob = find_object(HAUSNAME("tilly")); // findet Haus von Tilly
+
+  /*
+  Wenn das Haus im Raum steht. Hat den Vorteil, dass bei einem Verlegen
+  des Hauses, Cmd's usw nicht mehr verfuegbar sind -> Keine evtl Bugs :)
+  */
+  if(objectp(ob))
+  {
+    /*
+    Der Spieler wollte es ja nicht anders
+    */
+    ob->RemoveCmd(({"betret","betritt","betrete"}));
+    ob->RemoveId("haus");
+    ob->RemoveId("haus von tilly");
+    ob->AddId("steinhaufen");
+    
+    AddDetail(({"haufen","steinhaufen"}),"Da ist doch ein kleiner Spalt? "
+     +"Vielleicht kannst Du auf den Steinhaufen klettern?\n");
+
+    AddCmd(({"kletter","klettere"}),"kletter_cmd");
+  }
+}
+
+public int kletter_cmd(string str)
+{
+  object ob = find_object(HAUSNAME("tilly"));
+
+  _notify_fail("Wo moechtest Du hinklettern?\n");
+
+  if(!str) return 0;
+
+  if(str=="auf haufen" || str=="auf steinhaufen")
+  {
+    if(objectp(ob))
+    {
+      /*
+      Das ist die Meldung, die ein Spieler bekommt, wenn das Seherhaus
+      abgeschlossen ist und er versucht, es zu 'betreten'.
+      */
+      notify_fail("Du kletterst auf den Haufen, doch der Spalt ist zu "
+       "schmal fuer Dich.\n");
+       
+      if(!(ob->QueryProp(H_DOORSTAT) & D_CLOSED))
+      {
+        tell_object(this_player(),
+            "Du kletterst auf den Steinhaufen, rutschst den Spalt runter "
+             "und findest Dich urploetzlich in einer schummrigen Hoehle.\n");
+        tell_room(this_object(),this_player()->name()+" klettert auf einen "
+          "Steinhaufen und ist ploetzlich verschwunden.",({this_player()}));
+        tell_room(RAUMNAME("tilly",0),this_player()->name()+
+          " faellt fluchend herein.\n");
+        this_player()->move(RAUMNAME("tilly",0),M_GO|M_SILENT,0);
+        return 1;
+      }
+    }
+  }
+  return 0;
+}
+  
+/*
+Natuerlich gibt es noch viel mehr Moeglichkeiten rund um Seherhaeuser, 
+doch sollte dies erstmal reichen. Zu beachten ist bei solcher Vorgehens-
+weise, dass ein 'schliesse|oeffne haus' evtl zu Fehlermeldungen fuehrt.
+Dem Spieler sei nahegelegt, es doch mit 'oeffne haustuer' zu versuchen.
+
+HAUSNAME und RAUMNAME (u.a.) sind Defines aus dem haus.h. Man sollte sich
+dieses File anschauen und die dortigen Defines uebernehmen. Dann bugt auch 
+nichts, falls mal etwas an den Haeusern umgestellt wird.
+
+Tilly, 20. Mai 2001, 00:10:24h
+*/
diff --git a/doc/beispiele/misc/statkrallen.c b/doc/beispiele/misc/statkrallen.c
new file mode 100644
index 0000000..a0ae4c3
--- /dev/null
+++ b/doc/beispiele/misc/statkrallen.c
@@ -0,0 +1,61 @@
+/* Paracelsus: Statkrallen
+**
+**     Beispiel fuer die Verwendung von P_M_ATTR_MOD
+**
+**     Zieht ein Spieler diese Krallen an, so erhoeht sich seine Staerke
+**     um 2. Gleichzeitig wird das Erhoehen seiner Geschicklichkeit durch
+**     andere Ruestungen/Waffen blockiert. 
+**     Die Krallen koennen nur angezogen werden, wenn weder A_STR noch
+**     A_DEX durch eine andere Ruestung/Waffe blockiert wird.
+*/
+
+// Diese Pragmas sorgen dafuer, dass der Driver darauf achtet, dass bei
+// Funktionsargumenten, -Rueckgabewerten und teilweise bei Zuweisung von
+// Werten an Variablen der richtige Datentyp verwendet wird (z.b. kein string
+// anstelle eines int verwendet wird). Sollte in keinem Objekt fehlen.
+#pragma strong_types, save_types, rtt_checks
+
+#include <properties.h>
+#include <language.h>
+#include <combat.h>
+
+inherit "/std/armour";
+
+protected void create()
+{
+    ::create();
+
+    SetProp(P_SHORT,"Statkrallen");
+    SetProp(P_LONG,
+        "Diese krallenbewehrten Handschuhe schimmern blaeulich.\n");
+    SetProp(P_NAME,"Statkrallen");
+    SetProp(P_INFO,"Die Krallen machen staerker.\n");
+    SetProp(P_GENDER,FEMALE);
+    SetProp(P_NOBUY,1); // wird bei Verkauf im laden zerstoert.
+    SetProp(P_WEIGHT,800);
+    SetProp(P_VALUE,5000+random(2000));
+    SetProp(P_ARMOUR_TYPE,AT_GLOVE);
+    SetProp(P_AC,2);
+    SetProp(P_EFFECTIVE_WC,15);
+    SetProp(P_MATERIAL,
+    ([
+        MAT_LEATHER    : 60,
+        MAT_MISC_METAL : 40
+    ]) );
+
+// ---->
+
+    SetProp(P_M_ATTR_MOD,
+    ([
+        A_STR : 2,  // Staerke um 2 erhoehen
+        A_DEX : 0   // Geschicklichkeit blockieren
+    ]) );
+
+// <----
+
+    AddId( ({"handschuhe","krallen"}) );
+
+    AddDetail( "schimmer",
+        "Ein blaeulicher Schimmer liegt auf den Krallen.\n");
+}
+