diff --git a/doc/sphinx/lfun/id.rst b/doc/sphinx/lfun/id.rst
new file mode 100644
index 0000000..539b0cd
--- /dev/null
+++ b/doc/sphinx/lfun/id.rst
@@ -0,0 +1,99 @@
+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
+
