diff --git a/doc/lfun/id b/doc/lfun/id
new file mode 100644
index 0000000..7cf5aed
--- /dev/null
+++ b/doc/lfun/id
@@ -0,0 +1,76 @@
+id()
+
+FUNKTION:
+     varargs int id(string str, int lvl);
+
+DEFINIERT IN:
+     /std/thing/description.c
+     /std/player/base.c
+
+ARGUMENTE:
+     string str
+          String, auf den getestet werden soll.
+     int lvl
+          In /std/player/base.c benutzt. Wenn der Spieler unsichtbar ist
+          und lvl kleiner ist als sein Level, wird 0 zurueckgegeben.
+
+BESCHREIBUNG:
+     Es wird geprueft, ob sich das Objekt mit str ansprechen laesst. Dazu
+     wird str mit dem Inhalt der Property P_IDS verglichen. Falls
+     P_ADJECTIVES gesetzt ist, werden auch alle Adjektivkombinationen mit
+     den Bezeichnern geprueft.
+
+     Besondere Bedeutung hat diese Funktion bei Mengenobjekten: Anhand von
+     str wird vermerkt, welche Menge des Objektes angesprochen wird. Es
+     werden dabei mehrere Faelle unterschieden:
+     o str ist einer der mit AddId() angegebener Bezeichner. In diesem
+       Fall ist die angesprochene Menge die Gesamtmenge.
+     o str ist einer der mit AddSingularId() angegebenen Bezeichner. Die
+       angesprochene Menge ist in diesem Fall 1.
+     o str ist einer der mit AddPluralId() angegebenen Bezeichner. Die
+       angesprochene Menge ist in diesem Fall . die Gesamtmenge.
+     o Hat str die Form "<n> <id>", wobei <n>=1 und <id> eine SingularId
+       oder 1 < <n> <= der Gesamtmenge und <id> eine PluralId, so ist die
+       angesprochene Menge = <n>.
+     Wie gesagt, gilt dies einzig und allein bei Mengenobjekten!
+
+RUeCKGABEWERT:
+     1, wenn sich das Objekt von str angesprochen fuehlt, ansonsten 0.
+
+BEISPIELE:
+     Angenommen, ein Objekt habe folgende Bezeichner:
+
+     AddId( "murmel" );
+     AddAdjective( "runde" );
+
+     Dann liefern die angegebenen id()-Aufrufe folgende Ergebnisse:
+
+     id( "murmel" );         => 1
+     id( "runde murmel" );   => 1
+     id( "kleine murmel" );  => 0
+     id( "runder ball" );    => 0
+     id( "runde murmel 2" ); => 1, wenn dies die zweite Murmel in der
+                                   gleichen Umgebung ist, ansonsten 0
+
+     Bei einem Haufen von 100 Muenzen haette man zB.:
+
+     AddId( "geld" );
+     AddSingularId( "muenze" );
+     AddPluralId( "muenzen" );
+
+     Nach fuehlen sich nach den folgenden id()-Aufrufen folgende Anzahlen
+     angesprochen:
+
+     id( "geld" );       => 100 Muenzen
+     id( "muenze" );     => 1 Muenze
+     id( "muenzen" );    => 100 Muenzen
+     id( "1 muenze" );   => 1 Muenze
+     id( "42 muenzen" ); => 42 Muenzen
+
+     id() liefert in all diesen Faellen 1 zurueck.
+
+SIEHE AUCH:
+     AddId(), AddAdjective(), AddSingularId(), AddPluralId(), present(),
+     match_ids(), /std/thing/description.c, /std/unit.c
+
+6. Sep 2012 Gloinson
\ No newline at end of file
