Added public files
Roughly added all public files. Probably missed some, though.
diff --git a/std/player/shadows/ark_hunger_shadow.c b/std/player/shadows/ark_hunger_shadow.c
new file mode 100644
index 0000000..42d6dff
--- /dev/null
+++ b/std/player/shadows/ark_hunger_shadow.c
@@ -0,0 +1,54 @@
+/* Der Shadow fuer den Hungerfluch */
+/* /d/ebene/ark/wolf/obj/hunger.c */
+/* Shadow: /std/player/shadows/ark_hunger_shadow.c */
+/* Original: /d/ebene/ark/wolf/obj/hunger_obj.c */
+
+#pragma strong_types,save_types
+
+#include <defines.h>
+#include <properties.h>
+
+#define BS break_string
+
+object spieler;
+
+void Setzen(object sp)
+{
+ if (!objectp(sp) || !interactive(sp)) return destruct(this_object());
+ spieler=sp;
+ if (!shadow(sp,1)) destruct(this_object());
+}
+
+int _query_food() { return 0; }
+
+int _query_max_food() { return 0; }
+
+int eat_food(int strength, int testonly)
+{
+ if (strength==0) return 1;
+ if (strength>0)
+ {
+ strength=0;
+ if (spieler)
+ {
+ tell_object(spieler, BS("Du hast zwar einen tierischen Hunger, doch irgendwas sagt Dir, dass Du das, was "+
+ "Du gerade essen willst, nicht mehr in Deinen Magen bekommst. Das ist ziemlich "+
+ "gefaehrlich, hoffentlich verhungerst Du nicht !", 78));
+ return 0;
+ }
+ }
+ else
+ {
+ if (spieler)
+ {
+ tell_object(spieler, BS("Dein Hunger vertieft sich so nur, Du leidest Hoellenqualen.", 78));
+ spieler->reduce_hit_points(strength);
+ }
+ return 0;
+ }
+}
+
+void Loeschen() {
+ unshadow();
+ destruct(this_object());
+}
diff --git a/std/player/shadows/block_shadow.c b/std/player/shadows/block_shadow.c
new file mode 100644
index 0000000..f7a4333
--- /dev/null
+++ b/std/player/shadows/block_shadow.c
@@ -0,0 +1,47 @@
+#pragma strong_types,save_types
+
+#include <defines.h>
+#include <moving.h>
+#include <properties.h>
+#include <language.h>
+
+private nosave object pl;
+
+void create()
+{
+ if( IS_BLUE(ME) ) return;
+ shadow( PL, 1);
+ pl = PL;
+}
+
+int
+AddExp(int ep)
+{
+ object block;
+ int diff, lim;
+
+ block = present("\n block", pl);
+ lim = 30 + random(10);
+
+ if ( ep > lim && // Mindestwert
+ previous_object() &&
+ ( previous_object() == pl || // zB. GiveQuest()
+ ( living(previous_object()) && // Oder NPCs
+ !query_once_interactive(previous_object())
+ )
+ )
+ )
+ {
+ diff = block->Gutschreiben(ep-lim);
+ return pl->AddExp(lim+diff);
+ }
+ return pl->AddExp(ep);
+}
+
+void
+SeherHatGenug()
+{
+ unshadow();
+ destruct(this_object());
+}
+
diff --git a/std/player/shadows/morph_shadow.c b/std/player/shadows/morph_shadow.c
new file mode 100644
index 0000000..afc97c4
--- /dev/null
+++ b/std/player/shadows/morph_shadow.c
@@ -0,0 +1,598 @@
+/* -*- lpc -*- */
+//--------------------------------------------------------------------------
+//
+// morph.c
+//
+// (c) Troy (troy@mg.mud.de)
+// Kopieren, Veraendern oder Weitergabe: na klar, immer zu, je schlimmer
+// um so besser
+//
+// Objekt erstellt: 14.08.01, Troy
+//
+// Dieser shadow implementiert generische Verwandlungen. Im Gegensatz oder
+// in Ergänzung zum Tarnhelm sind diese nicht auf die Beschreibung
+// beschränkt, sondern schlagen sich auch in anderen Properties nieder.
+//
+//--------------------------------------------------------------------------
+
+#include <moving.h>
+#include <properties.h>
+#include <wizlevels.h>
+
+//--------------------------------------------------------------------------
+
+#pragma strong_types,save_types
+
+//--------------------------------------------------------------------------
+
+varargs int remove( int silent );
+
+//--------------------------------------------------------------------------
+//
+// Property-Einstellungen je nach Rasse
+//
+//--------------------------------------------------------------------------
+
+private mapping morph_properties;
+
+private object pl; // der schattierte Spieler
+
+//--------------------------------------------------------------------------
+//
+// start_shadow( Spieler, Properties )
+//
+// Startet das Shadowing von Spieler. Properties ist ein Mapping mit
+// den zu ändernden Properties. Dort nicht vorhandene Properties werden
+// zum Spieler durchgereicht. Es werden dort entweder einzelne Werte
+// erwartet (Beispiel: ([ P_GENDER: MALE ])), die dann für alle Rassen
+// gelten, oder closures, die dann ausgeführt werden unter Übergabe der
+// Spielerrasse als Parameter oder aber Mappings mit den Rassennamen
+// (Beispiel: ([ P_GENDER: ([ "Mensch": NEUTER, "Elf": FEMALE,
+// "Zwerg": MALE, ... ]) ])). Ist eine Rasse in dem Rassenmapping nicht
+// vorhanden, so wird das Property zum Spieler durchgereicht. Speziell
+// behandelt werden P_IDS (siehe _query_ids()) und P_NAME (siehe
+// _query_name()).
+//
+//--------------------------------------------------------------------------
+int start_shadow( object _pl, mapping preset )
+{
+ if ( !clonep( this_object() ) )
+ return 1;
+ if ( !_pl || !query_once_interactive( _pl ) )
+ return remove();
+ pl = _pl;
+ morph_properties = deep_copy( preset );
+ shadow( pl, 1 );
+ return 1;
+}
+
+//--------------------------------------------------------------------------
+//
+// stop_shadow()
+//
+// Beendet das Shadowing und zerstört dieses Objekt
+//
+//--------------------------------------------------------------------------
+int stop_shadow( /* void */ )
+{
+ if ( !clonep( this_object() ) )
+ return 0;
+ unshadow();
+ return remove();
+}
+
+//--------------------------------------------------------------------------
+//
+// _query_property( Property )
+//
+// Generische Property-Maskierung. liefert aus morph_properties den zur
+// Rasse des Trägers passenden Eintrag.
+//
+//--------------------------------------------------------------------------
+nomask static mixed _query_property( string prop )
+{
+ string race;
+
+ // Rasse holen.
+ if ( IS_LEARNER(pl) )
+ race = "Magier";
+ else // _query_race() ist notwendig, um closures zu umgehen.
+ race = pl->_query_race();
+
+ if ( member( morph_properties, prop ) == 0 )
+ return pl->Query( prop );
+ if ( closurep( morph_properties[ prop ] ) )
+ return funcall( morph_properties[ prop ], race );
+ if ( mappingp( morph_properties[ prop ] ) )
+ {
+ if ( member( morph_properties[ prop ], race ) == 0 )
+ return pl->Query( prop );
+ if ( closurep( morph_properties[ prop ][ race ] ) )
+ return funcall( morph_properties[ prop ][ race ] );
+
+ return morph_properties[ prop ][ race ];
+ }
+ return morph_properties[ prop ];
+}
+
+//--------------------------------------------------------------------------
+//
+// _query_article()
+//
+// Property-Maskierung für P_ARTICLE
+//
+//--------------------------------------------------------------------------
+int _query_article( /* void */ )
+{
+ return (int)_query_property( P_ARTICLE );
+}
+
+//--------------------------------------------------------------------------
+//
+// _query_average_size()
+//
+// Property-Maskierung für P_AVERAGE_SIZE
+//
+//--------------------------------------------------------------------------
+int _query_average_size( /* void */ )
+{
+ return (int)_query_property( P_AVERAGE_SIZE );
+}
+
+//--------------------------------------------------------------------------
+//
+// _query_average_weight()
+//
+// Property-Maskierung für P_AVERAGE_WEIGHT
+//
+//--------------------------------------------------------------------------
+int _query_average_weight( /* void */ )
+{
+ return (int)_query_property( P_AVERAGE_WEIGHT );
+}
+
+//--------------------------------------------------------------------------
+//
+// _query_body()
+//
+// Property-Maskierung für P_BODY
+//
+//--------------------------------------------------------------------------
+int _query_body( /* void */ )
+{
+ return (int)_query_property( P_BODY );
+}
+
+//--------------------------------------------------------------------------
+//
+// _query_gender()
+//
+// Property-Maskierung für P_GENDER
+//
+//--------------------------------------------------------------------------
+int _query_gender( /* void */ )
+{
+ return (int)_query_property( P_GENDER );
+}
+
+//--------------------------------------------------------------------------
+//
+// _query_hands()
+//
+// Property-Maskierung für P_HANDS
+//
+//--------------------------------------------------------------------------
+mixed _query_hands( /* void */ )
+{
+ return _query_property( P_HANDS );
+}
+
+//--------------------------------------------------------------------------
+//
+// _query_ids()
+//
+// Property-Maskierung für P_IDS - Nicht-Standard, da je nach Ursprungs-
+// geschlecht des Spielers zusätzliche ids fällig werden. Ablauf: Es gibt
+// 5 Schritte, bei deren jeweiligem Versagen die ids des Spielers durch-
+// gereicht werden:
+// 1. P_IDS ist im property-mapping vorhanden
+// 2. a) es ist ein string oder ein array: es wird an die ids des Spielers
+// angehängt und zurückgegeben.
+// b) es ist eine closure. Diese wird ausgeführt unter Übergabe der
+// Spieler-ids, der Rasse des Spielers und der Geschlechter
+// (dieses Objekts und des Spielers). Der Ergebniswert der closure
+// wird direkt zurückgegeben.
+// c) es ist ein mapping. Hier nehmen wir nun das übliche Rassennamen-
+// mapping an -> 3.)
+// 3. Für die Rasse des Spielers wird ein Eintrag gesucht
+// a) er ist ein string oder ein array: er wird an die ids des Spielers
+// angehängt und zurückgegeben.
+// b) er ist eine closure. Diese wird ausgeführt unter Übergabe der
+// Spieler-ids, der Rasse des Spielers und der Geschlechter
+// (dieses Objekts und des Spielers). Der Ergebniswert der closure
+// wird direkt zurückgegeben.
+// c) er ist ein mapping. Es wird angenommen, dass je Geschlecht DIESES
+// Objekts ein Eintrag vorhanden ist. -> 4.)
+// 4. Für das Geschlecht dieses Objekts wird ein Eintrag gesucht
+// a) er ist ein string oder ein array: er wird an die ids des Spielers
+// angehängt und zurückgegeben.
+// b) er ist eine closure. Diese wird ausgeführt unter Übergabe der
+// Spieler-ids, der Rasse des Spielers und der Geschlechter
+// (dieses Objekts und des Spielers). Der Ergebniswert der closure
+// wird direkt zurückgegeben.
+// c) er ist ein mapping. Es wird angenommen, dass je Geschlecht DES
+// Spielers ein Eintrag vorhanden ist. -> 5.)
+// 5. Für das Geschlecht des Spielers wird ein Eintrag gesucht
+// a) er ist ein string oder ein array: er wird an die ids des Spielers
+// angehängt und zurückgegeben.
+// b) er ist eine closure. Diese wird ausgeführt unter Übergabe der
+// Spieler-ids, der Rasse des Spielers und der Geschlechter
+// (dieses Objekts und des Spielers). Der Ergebniswert der closure
+// wird direkt zurückgegeben.
+//
+//--------------------------------------------------------------------------
+mixed _query_ids( /* void */ )
+{
+ string race;
+ mixed ids;
+ int gender, sgender;
+
+ // Test 1.
+ ids = pl->Query( P_IDS );
+ if ( member( morph_properties, P_IDS ) == 0 )
+ return ids;
+
+ // Rasse holen.
+ if ( IS_LEARNER(pl) )
+ race = "Magier";
+ else // _query_race() ist notwendig, um closures zu umgehen.
+ race = pl->_query_race();
+
+ // Geschlechter holen
+ gender = _query_gender();
+ sgender = pl->Query( P_GENDER );
+
+ // Test 2.
+ // string? Dann einfach den normalen ids dazu, genauso mit array
+ if ( stringp( morph_properties[ P_IDS ] ) )
+ return ids + ({ morph_properties[ P_IDS ] });
+ if ( pointerp( morph_properties[ P_IDS ] ) )
+ return ids + morph_properties[ P_IDS ];
+ if ( closurep( morph_properties[ P_IDS ] ) )
+ return funcall( morph_properties[ P_IDS ], ids, race, gender, sgender );
+ // falls kein mapping, dann raus
+ if ( !mappingp( morph_properties[ P_IDS ] ) )
+ return ids;
+
+ // Test 3.
+ if ( member( morph_properties[ P_IDS ], race ) == 0 )
+ return ids;
+ if ( stringp( morph_properties[ P_IDS ][ race ] ) )
+ return ids + ({ morph_properties[ P_IDS ][ race ] });
+ if ( pointerp( morph_properties[ P_IDS ][ race ] ) )
+ return ids + morph_properties[ P_IDS ][ race ];
+ if ( closurep( morph_properties[ P_IDS ][ race ] ) )
+ return funcall( morph_properties[ P_IDS ][ race ], ids, race, gender, sgender );
+ // falls kein mapping, dann raus
+ if ( !mappingp( morph_properties[ P_IDS ][ race ] ) )
+ return ids;
+
+ // Test 4.
+ if ( member( morph_properties[ P_IDS ][ race ], gender ) == 0 )
+ return ids;
+ if ( stringp( morph_properties[ P_IDS ][ race ][ gender ] ) )
+ return ids + ({ morph_properties[ P_IDS ][ race ][ gender ] });
+ if ( pointerp( morph_properties[ P_IDS ][ race ][ gender ] ) )
+ return ids + morph_properties[ P_IDS ][ race ][ gender ];
+ if ( closurep( morph_properties[ P_IDS ][ race ][ gender ] ) )
+ return funcall( morph_properties[ P_IDS ][ race ][ gender ],
+ ids, race, gender, sgender );
+ // falls kein mapping, dann raus
+ if ( !mappingp( morph_properties[ P_IDS ][ race ][ gender ] ) )
+ return ids;
+
+ // Test 5.
+ if ( member( morph_properties[ P_IDS ][ race ][ gender ], sgender ) == 0 )
+ return ids;
+ if ( stringp( morph_properties[ P_IDS ][ race ][ gender ][ sgender ] ) )
+ return ids + ({ morph_properties[ P_IDS ][ race ][ gender ][ sgender ] });
+ if ( pointerp( morph_properties[ P_IDS ][ race ][ gender ][ sgender ] ) )
+ return ids + morph_properties[ P_IDS ][ race ][ gender ][ sgender ];
+ if ( closurep( morph_properties[ P_IDS ][ race ][ gender ][ sgender ] ) )
+ return funcall( morph_properties[ P_IDS ][ race ][ gender ][ sgender ],
+ ids, race, gender, sgender );
+
+ return ids;
+}
+
+//--------------------------------------------------------------------------
+//
+// _query_is_morphed()
+//
+// Property-Methode für "is_morphed"
+//
+//--------------------------------------------------------------------------
+int _query_is_morphed( /* void */ )
+{
+ return 1;
+}
+
+//--------------------------------------------------------------------------
+//
+// _query_max_hands()
+//
+// Property-Maskierung für P_MAX_HANDS
+//
+//--------------------------------------------------------------------------
+int _query_max_hands( /* void */ )
+{
+ return (int)_query_property( P_MAX_HANDS );
+}
+
+//--------------------------------------------------------------------------
+//
+// _query_mmsgin()
+//
+// Property-Maskierung für P_MMSGIN
+//
+//--------------------------------------------------------------------------
+string _query_mmsgin( /* void */ )
+{
+ return (string)(_query_property( P_MMSGIN ) || "");
+}
+
+//--------------------------------------------------------------------------
+//
+// _query_mmsgout()
+//
+// Property-Maskierung für P_MMSGOUT
+//
+//--------------------------------------------------------------------------
+string _query_mmsgout( /* void */ )
+{
+ return (string)(_query_property( P_MMSGOUT ) || "");
+}
+
+//--------------------------------------------------------------------------
+//
+// _query_msgin()
+//
+// Property-Maskierung für P_MSGIN
+//
+//--------------------------------------------------------------------------
+string _query_msgin( /* void */ )
+{
+ return (string)(_query_property( P_MSGIN ) || "");
+}
+
+//--------------------------------------------------------------------------
+//
+// _query_msgout()
+//
+// Property-Maskierung für P_MSGOUT
+//
+//--------------------------------------------------------------------------
+string _query_msgout( /* void */ )
+{
+ return (string)(_query_property( P_MSGOUT ) || "");
+}
+
+//--------------------------------------------------------------------------
+//
+// _query_name()
+//
+// Property-Methode für P_NAME. Leider ist die player-shell so grottig,
+// dass überall angenommen wird, QueryProp(P_NAME) liefere einen String :-|
+// Vollständiges Property daher unter _query_name_full().
+//
+//--------------------------------------------------------------------------
+string _query_name( /* void */ )
+{
+ mixed prop;
+ prop = _query_property( P_NAME );
+ if ( stringp( prop ) )
+ return sprintf( prop, pl->Query( P_NAME ) );
+ if ( pointerp( prop ) )
+ return map( prop,
+ lambda( ({ 'el, 's }),
+ ({#'sprintf, 'el, 's}) ),
+ pl->Query( P_NAME ) )[ WER ];
+ return pl->Query( P_NAME );
+}
+
+//--------------------------------------------------------------------------
+//
+// _query_name_full()
+//
+// Property-Methode für "name_full".
+//
+//--------------------------------------------------------------------------
+mixed _query_name_full( /* void */ )
+{
+ mixed prop;
+ prop = _query_property( P_NAME );
+ if ( stringp( prop ) )
+ return sprintf( prop, pl->Query( P_NAME ) );
+ if ( pointerp( prop ) )
+ return map( prop,
+ lambda( ({ 'el, 's }),
+ ({#'sprintf, 'el, 's}) ),
+ pl->Query( P_NAME ) );
+ return pl->Query( P_NAME );
+}
+
+//--------------------------------------------------------------------------
+//
+// _query_presay()
+//
+// Property-Maskierung für P_PRESAY
+//
+//--------------------------------------------------------------------------
+string _query_presay( /* void */ )
+{
+ return (string)(_query_property( P_PRESAY ) || "");
+}
+
+//--------------------------------------------------------------------------
+//
+// _query_race()
+//
+// Property-Maskierung für P_RACE
+//
+//--------------------------------------------------------------------------
+string _query_race( /* void */ )
+{
+ return (string)(_query_property( P_RACE ) || "");
+}
+
+//--------------------------------------------------------------------------
+//
+// _query_racestring()
+//
+// Property-Maskierung für P_RACESTRING
+//
+//--------------------------------------------------------------------------
+string* _query_racestring( /* void */ )
+{
+ return (string*)_query_property( P_RACESTRING );
+}
+
+//--------------------------------------------------------------------------
+//
+// _query_size()
+//
+// Property-Maskierung für P_SIZE
+//
+//--------------------------------------------------------------------------
+int _query_size( /* void */ )
+{
+ return (int)_query_property( P_SIZE );
+}
+
+//--------------------------------------------------------------------------
+//
+// _query_title()
+//
+// Property-Maskierung für P_TITLE
+//
+//--------------------------------------------------------------------------
+string _query_title( /* void */ )
+{
+ return (string)(_query_property( P_TITLE ) || "");
+}
+
+//--------------------------------------------------------------------------
+//
+// _query_weight()
+//
+// Property-Maskierung für P_WEIGHT
+//
+//--------------------------------------------------------------------------
+int _query_weight( /* void */ )
+{
+ return (int)(_query_property( P_WEIGHT ) || "");
+}
+
+//--------------------------------------------------------------------------
+//
+// id( Text, Level)
+//
+// Die Identifizierung spinnt mit P_NAME-Arrays
+//
+//--------------------------------------------------------------------------
+varargs int id( string str, int lvl )
+{
+ string plname;
+
+ if ( pl->QueryProp( P_GHOST ) )
+ if ( str == "geist" )
+ return 1;
+ else if ( ( sscanf( str, "geist von %s", plname ) == 1 ) &&
+ pl->id( plname ) )
+ return 1;
+ else if ( ( sscanf( str, "geist %s", plname ) == 1 ) &&
+ pl->id( plname ) )
+ return 1;
+
+ return pl->id( str, lvl );
+}
+
+//--------------------------------------------------------------------------
+//
+// long()
+//
+// Die Langbeschreibung im Spieler hadert mit dem Geschlecht NEUTER...
+//
+//--------------------------------------------------------------------------
+varargs string long( /* void */ )
+{
+ string slong;
+ slong = pl->long();
+
+ if ( _query_gender() == NEUTER )
+ {
+ string *along;
+ int i;
+
+ // alle Er-s und er-s suchen...
+ along = regexplode( slong, "\\<[Ee]r\\>" );
+ // ... und das r durch ein s ersetzen.
+ for ( i = 1 ; i < sizeof( along ) ; i += 2 )
+ along[ i ][ 1 ] = 's';
+ slong = implode( along, "" );
+ }
+
+ return slong;
+}
+
+//--------------------------------------------------------------------------
+//
+// short()
+//
+// Die Kurzbeschreibung im Spieler hat ein Problem mit P_NAME-Arrays
+//
+//--------------------------------------------------------------------------
+string short( /* void */ )
+{
+ mixed names;
+ string answer;
+ string title;
+
+ if ( pl->QueryProp( P_INVIS ) )
+ if ( interactive( previous_object() ) &&
+ IS_LEARNING( previous_object() ) )
+ return "(" + pl->Query( P_NAME ) + ") \n";
+ else
+ return (string)0;
+
+ names = _query_name_full();
+ if ( stringp( names ) )
+ names = ({ names, names, names, names });
+
+ if ( pl->QueryProp( P_GHOST ) )
+ answer = "Der Geist " + pl->QueryArticle( WESSEN, 0 ) + names[ WESSEN ];
+ else
+ answer = pl->QueryArticle( WER, 0 ) + names[ WER ];
+ if ( ( title = pl->QueryProp( P_TITLE ) ) &&
+ ( title != "" ) )
+ answer += " " + title;
+ if ( !interactive( pl ) )
+ answer += " (netztot)";
+ return capitalize( answer ) + ".\n";
+}
+
+//--------------------------------------------------------------------------
+//
+// remove( Schnauze )
+//
+// aufräumen
+//
+//--------------------------------------------------------------------------
+varargs int remove( int silent )
+{
+ destruct( this_object() );
+ return 1;
+}
+
+//--------------------------------------------------------------------------
+// -- ENDE --
diff --git a/std/player/shadows/pony.c b/std/player/shadows/pony.c
new file mode 100644
index 0000000..8d3de8d
--- /dev/null
+++ b/std/player/shadows/pony.c
@@ -0,0 +1,59 @@
+#pragma strong_types,save_types
+
+#include <defines.h>
+#include <moving.h>
+#include <properties.h>
+#include <language.h>
+
+//
+// Da der Shadow sich nicht im Player befindet, wird ein
+// Zusatzobjekt benoetigt.
+// 7.10.97 - Die Hook sollte in den Verzeichnissen der Benniequest
+// zu finden sein. - Rumata
+
+#define HOOK "d/wald/kassandra/bennie/obj/pony_hook"
+
+static object pl;
+
+void create()
+{
+ if( IS_BLUE(ME) ) return;
+ shadow( PL, 1);
+ pl=PL;
+ //tell_object(this_player(),"Du besteigst das Pony samt Schatten.\n");
+ clone_object( HOOK ); // Steuerung des shadows ueber die hook
+}
+
+string _query_title()
+{
+ if( pl->QueryProp(P_GENDER) == FEMALE )
+ return "die Ponyreiterin";
+ return "der Ponyreiter";
+}
+
+string _query_msgin() { return "reitet herein"; }
+string _query_msgout() { return "reitet"; }
+
+varargs int move(mixed dest, int method, string dir, string textout,string textin)
+{
+ if( !(method & M_NOCHECK) && dest->QueryProp(P_INDOORS) )
+ {
+ write( "Das Pony weigert sich, dorthin zu traben.\n" );
+ return 1;
+ }
+ return pl->move( dest, method, dir, textout, textin );
+}
+
+int _inventory(string str)
+{
+ if( !environment() || set_light(0)>0 )
+ write( "Du sitzt auf einem Pony.\n" );
+ return pl->_inventory(str);
+}
+
+void absteigen() {
+ unshadow();
+ destruct(ME);
+}
+
+int QueryReiter() { return 1; }
diff --git a/std/player/shadows/sizetest.c b/std/player/shadows/sizetest.c
new file mode 100644
index 0000000..1268911
--- /dev/null
+++ b/std/player/shadows/sizetest.c
@@ -0,0 +1,57 @@
+#include <defines.h>
+#include <moving.h>
+#include <properties.h>
+#include <language.h>
+
+#define SPIELER "nefis"
+#define DEBUG(x) if (find_player("zesstra"))\
+ tell_object(find_player("zesstra"),\
+ "Nefis P_SIZE: "+x+"\n")
+#define LOG(x) log_file("zesstra/P_SIZE.log", x)
+
+private nosave object pl;
+
+void create()
+{
+ if (!clonep() ) return;
+ pl = find_player(SPIELER) || find_netdead(SPIELER);
+ if (!objectp(pl)) {
+ DEBUG("Playerobjekt nicht gefunden.");
+ destruct(ME);
+ return;
+ }
+ shadow( pl, 1);
+ DEBUG(sprintf("%O shadowed by: %O\n", pl, shadow(pl, 0)));
+}
+
+int _set_size(int sz) {
+ LOG(sprintf("[%s] Aenderung von P_SIZE in %O auf %O,\nCallerstack: %O\n\n",
+ strftime("%c",time()), pl, sz, caller_stack()));
+ return pl->Set(P_SIZE, sz, F_VALUE);
+}
+
+public varargs mixed Set( string name, mixed Value, int Type, int extern ) {
+ if (name == P_SIZE) {
+ LOG(sprintf("[%s] Aenderung von P_SIZE in %O auf %O (Typ: %O) [Set()!]"
+ ",\nCallerstack: %O\n\n",
+ strftime("%c",time()), pl, Value, Type, caller_stack()));
+ }
+ return pl->Set(name, Value, Type, extern);
+}
+
+int stop() {
+ unshadow();
+ destruct(ME);
+ return 1;
+}
+
+void reset() {
+ if (!objectp(pl))
+ stop();
+}
+
+int remove() {
+ stop();
+ return 1;
+}
+
diff --git a/std/player/shadows/tarnhelm_shadow.c b/std/player/shadows/tarnhelm_shadow.c
new file mode 100644
index 0000000..63ea744
--- /dev/null
+++ b/std/player/shadows/tarnhelm_shadow.c
@@ -0,0 +1,140 @@
+#pragma strong_types,save_types
+
+#include <defines.h>
+#include <properties.h>
+
+#define WEG() destruct(this_object())
+
+object player;
+int gender;
+string desc;
+
+void _tarn_turn_on(object pl,string txt,int gen)
+{
+ if (!objectp(pl)||!interactive(pl)) return WEG();
+ if (!stringp(txt)||txt=="") return WEG();
+ if (gen<0||gen>2) return WEG();
+ player=pl;
+ desc=capitalize(txt);
+ gender=gen;
+ shadow(pl,1);
+}
+
+int special_verb()
+{
+ string verb;
+
+ verb=query_verb();
+ if (!verb||verb=="") return 0;
+ if (verb[0]=='-') return 1;
+ if (verb=="ruf"||verb=="rufe"||verb=="teile"||verb=="teil"||verb=="mruf"||
+ verb=="mrufe"||verb=="erzaehl"||verb=="erzaehle") return 1;
+ return(0); // non-void funktion, Zesstra
+}
+
+int _query_gender()
+{
+ return gender;
+}
+
+string _query_name()
+{
+ if (!special_verb())
+ return capitalize(desc);
+ return player->Query(P_NAME);
+}
+
+string _query_short()
+{
+ return capitalize(player->name());
+}
+
+string _query_long()
+{
+ string str;
+
+ str=player->name();
+ return capitalize(str)+" ist "+str+" ist "+str+".\n";
+}
+
+string* _query_ids()
+{
+ return player->Query("ids")+({lower_case(desc)});
+}
+
+string _query_race()
+{
+ return desc;
+}
+
+void _tarn_turn_off()
+{
+ unshadow();
+ destruct(this_object());
+}
+
+int _query_article()
+{
+ if (!special_verb())
+ return 1;
+ return(0); // non-void funktion, Zesstra
+}
+
+string _query_presay()
+{
+ return "";
+}
+
+string _query_title()
+{
+ return "";
+}
+
+void Defend(int dam,mixed dam_type,mixed spell,object enemy)
+{
+ object o;
+
+ if (!query_once_interactive(previous_object()))
+ player->Defend(dam, dam_type, spell, enemy);
+ else
+ previous_object()->StopHuntFor(player);
+ if ((o=present("\ntarnhelm",player)))
+ o->DoUnwear();
+ if (this_object()) destruct(this_object());
+}
+
+int Kill(object ob)
+{
+ object o;
+
+ if ((o=present("\ntarnhelm",player)))
+ o->DoUnwear();
+ if (this_object()) destruct(this_object());
+ return(0); // non-void funktion, Zesstra
+}
+
+int InsertEnemy(object ob)
+{
+ object o;
+
+ if (!query_once_interactive(ob))
+ player->InsertEnemy(ob);
+ else
+ ob->StopHuntFor(player);
+ if ((o=present("\ntarnhelm",player)))
+ o->DoUnwear();
+ if (this_object()) destruct(this_object());
+ return 0;
+}
+
+string short()
+{
+ if (old_explode(object_name(previous_object()),"#")[0]=="/obj/werliste")
+ return capitalize(geteuid(player)+" verkleidet als "+player->short());
+ return player->short();
+}
+
+string QueryDisguise()
+{
+ return desc;
+}
diff --git a/std/player/shadows/zaubersh.c b/std/player/shadows/zaubersh.c
new file mode 100644
index 0000000..a19cecc
--- /dev/null
+++ b/std/player/shadows/zaubersh.c
@@ -0,0 +1,220 @@
+#pragma strong_types,save_types
+
+#include <properties.h>
+
+object caster;
+string*ids,name;
+int gender,article,plural;
+string lgdesc;
+string min,mout,mmin,mmout;
+mixed hands;
+
+void Initialize(object _caster,
+ string*_ids,
+ string _name,
+ int _gender,
+ int _article,
+ int _plural)
+{ if(!objectp(_caster) ||
+ !interactive(_caster)||
+ !stringp(_name) ||
+ _name=="" ||
+ _gender<0 ||
+ _gender>2)
+ { destruct(this_object());
+ return;
+ }
+ caster=_caster;
+ ids=_ids;
+ name=_name;
+ gender=_gender;
+ article=_article;
+ plural=_plural;
+ lgdesc=0;
+ shadow(caster,1);
+}
+
+void SetLongDesc(string txt)
+{ if(!stringp(txt)||txt=="")
+ return;
+ lgdesc=txt;
+}
+
+string* _query_ids()
+{ return caster->Query(P_IDS)+ids;
+}
+
+// nicht alle Verben mit veraendertem Aussehen
+int special_verb()
+{ string verb;
+ verb=query_verb();
+ if(!stringp(verb)||verb=="")
+ return 0;
+ if(verb[0]=='-')
+ return 1;
+ if(member(({"ruf","rufe","mruf","mrufe",
+ "teil","teile","erzaehl","erzaehle"}),verb)!=-1)
+ return 1;
+ return 0;
+}
+
+string _query_name()
+{ if(!special_verb())
+ return name;
+ return capitalize(caster->Query(P_NAME));
+}
+
+string _query_short()
+{ if(!special_verb())
+ return caster->Name();
+ return caster->Query(P_SHORT);
+}
+
+string _query_long()
+{ if(!special_verb())
+ { string str;
+ if(lgdesc)
+ return lgdesc;
+ str=caster->name();
+ return break_string(capitalize(str)+" ist "+str+" ist "+str+".",78);
+ }
+ return caster->Query(P_LONG);
+}
+
+int _query_gender()
+{ if(!special_verb())
+ return gender;
+ return caster->Query(P_GENDER);
+}
+
+int _query_article()
+{ if(!special_verb())
+ return article;
+ return caster->Query(P_ARTICLE);
+}
+
+int _query_plural()
+{ if(!special_verb())
+ return plural;
+ return caster->Query(P_PLURAL);
+}
+
+string _query_race()
+{ if(!special_verb())
+ return name;
+ return caster->Query(P_RACE);
+}
+
+varargs int remove(int silent) {
+ unshadow();
+ destruct(this_object());
+ return 1;
+}
+
+void stop_shadow()
+{
+ remove();
+}
+
+string _query_presay()
+{ return"";
+}
+
+string _query_title()
+{ return"";
+}
+
+string _set_msgin(string val)
+{ return min=val;
+}
+
+string _query_msgin()
+{ return min;
+}
+
+string _set_msgout(string val)
+{ return mout=val;
+}
+
+string _query_msgout()
+{ return mout;
+}
+
+string _set_mmsgin(string val)
+{ return mmin=val;
+}
+
+string _query_mmsgin()
+{ return mmin;
+}
+
+string _set_mmsgout(string val)
+{ return mmout=val;
+}
+
+string _query_mmsgout()
+{ return mmout;
+}
+
+mixed _set_hands(mixed val)
+{ return hands=val;
+}
+
+mixed _query_hands()
+{ return hands;
+}
+
+varargs int Defend(int dam,mixed dam_type,mixed spell,object enemy)
+{ object ob;
+ if(!enemy || // Silvana 26.1.2002
+ (!query_once_interactive(previous_object())&&
+ !query_once_interactive(enemy)))
+ return caster->Defend(dam,dam_type,spell,enemy);
+ else
+ { enemy->StopHuntFor(caster);
+ caster->StopHuntFor(enemy);
+ }
+ if(objectp(ob=present("zauberer\nshadow",caster)))
+ ob->remove();
+ if(this_object())
+ remove();
+ return 0;
+}
+
+int Kill(object enemy)
+{ object ob;
+ if(!query_once_interactive(enemy))
+ return caster->Kill(enemy);
+ if(objectp(ob=present("zauberer\nshadow",caster)))
+ ob->remove();
+ if(this_object())
+ remove();
+ return 0;
+}
+
+int InsertEnemy(object enemy)
+{ object ob;
+ if(!query_once_interactive(enemy))
+ return caster->InsertEnemy(enemy);
+ else {
+ enemy->StopHuntFor(caster);
+ caster->StopHuntFor(enemy);
+ }
+ if(objectp(ob=present("zauberer\nshadow",caster)))
+ ob->remove();
+ if(this_object())
+ remove();
+ return 0;
+}
+
+string short()
+{ if(load_name(previous_object()) == "/obj/werliste")
+ return capitalize(geteuid(caster))+" verkleidet als "+caster->short();
+ return caster->short();
+}
+
+varargs string long()
+{ if(lgdesc)
+ return lgdesc;
+ return caster->long();
+}