
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
