Added public files
Roughly added all public files. Probably missed some, though.
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");
+}
+