***********************************************************************
***********************************************************************
***********************************************************************
* Deutsche Inform Library: Änderungsliste 16 (02.10.2002)
***********************************************************************
***********************************************************************
***********************************************************************

Vorschläge von: Dennis Brakhane

***********************************************************************
* parserm.h
***********************************************************************

Alt:
    for (m=0:m<=l:m++)
        if (wd==k-->m) rtrue;
Neu:
    for (m=0:m<=l:m++)
	if(wd==k-->m) {
	    if (obj provides changing_gender) {
	    	if (m<l) {
		    m = k-->(m+1);
	    	    if (m>255)
			m=0;
		    else if (obj ~= player) {
			!Wir müssen noch ein weiteres Pronomen setzen.
			wd = PowersOfTwo_TB-->(GetGNAOfObjectWithGender(obj,m));
   			for (l = 1 : l <= LanguagePronouns-->0: l = l+3)
       			    if (wd & (LanguagePronouns-->(l+1)) ~= 0)
           			LanguagePronouns-->(l+2) = obj;
		    }
		} else
		    m = 0;
	    	obj.changing_gender = m;
	    }
	    rtrue;
	}

***********************************************************************

Alt:
  for (x = 1, d = 0 : x <= LanguagePronouns-->0: x = x+3)
  {   !print "~", (address) LanguagePronouns-->x, "~ "; !auskommentiert Max Kalus
      y = LanguagePronouns-->(x+2);
Neu:
  for (x = 1, d = 0 : x <= LanguagePronouns-->0: x = x+3)
  {   !print "~", (address) LanguagePronouns-->x, "~ "; !auskommentiert Max Kalus
      if (LanguagePronouns-->x == 'spez.') continue;
      y = LanguagePronouns-->(x+2);

***********************************************************************
* germang.h
***********************************************************************

Alt:
Verb 'greif' 'fass' 'ergreif'
	* multi					 -> Take
	* multiinside 'in' noun			 -> Remove
	* multiinside 'auf' noun		 -> Remove
	* multiinside xheraus    		 -> Remove
	* 'an' noun				 -> Touch
	* creature 'an'				 -> Attack
	* noun 'an'				 -> Touch
	* 'nach' multi				 -> Take
	* 'nach' multiinside 'in' noun		 -> Remove
	* 'nach' multiinside 'auf' noun		 -> Remove
	* multiinside 'von'/'aus' noun  	 -> Remove
	* multiinside 'von'/'aus' noun heraus 	 -> Remove;
Neu:
Verb 'greif' 'fass' 'ergreif'
	* multi					 -> Take
	* multiinside 'in' noun			 -> Remove
	* multiinside 'auf' noun		 -> Remove
	* multiinside xheraus    		 -> Remove
	* 'an' noun				 -> Touch
	* creature 'an'				 -> Attack
        * creature 'mit' held 'an'               -> Attack
        * 'mit' held creature 'an'               -> Attack reverse
        * creature 'an' 'mit' held               -> Attack
	* noun 'an'				 -> Touch
	* 'nach' multi				 -> Take
	* 'nach' multiinside 'in' noun		 -> Remove
	* 'nach' multiinside 'auf' noun		 -> Remove
	* multiinside 'von'/'aus' noun  	 -> Remove
	* multiinside 'von'/'aus' noun heraus 	 -> Remove;

***********************************************************************
* german.h
***********************************************************************

Alt:
[ PreProcessGerman  x;

! Glulx does not lower the ASCII-chars, so do it now
#ifdef TARGET_GLULX;
Neu:
[ PreProcessGerman  x;
#ifndef NO_PUNCTUATION;
    x=0; !Warnung über unbenutze Variable (wenn TARGET_ZCODE,
    !PUNCTUATION gesetzt ist) verhindern
#endif;

! Glulx does not lower the ASCII-chars, so do it now
#ifdef TARGET_GLULX;

***********************************************************************

Alt:
!ProcessGermanSuffixes
!Routine to cut off German suffixes, but leave things like 'se' alone
[ ProcessGermanSuffixes  x at end word len;
! 4. Pass: make lemmas out of inflected nouns
!          -> this is equal to removing any suffixes
!          -> on parsing case or number or gender is not looked at at all
!          -> Umlaute (ä as 'ae') have to be entered separately in 
!              the names - property
!  List of (most) german noun suffixes:
!  e n s se ses en er ern 

#ifdef TARGET_ZCODE;
for (x=0:x<parse->1:x++)
{
  word = parse-->(x*2+1);
  if (word == 0)                 ! if word not recognized
  {
    len = parse->(x*4+4);
    at = parse->(x*4+5);
#ifnot; ! TARGET_GLULX
for (x=0:x<parse-->0:x++)
{
  word = parse-->(x*3+1);
  if (word == 0)
  {
    len = parse-->(x*3+2);
    at = parse-->(x*3+3);
#endif; ! TARGET_

    end = at+len-1;              ! last letter of the word

!Zusatz MK:
!Falls das Wort nur zwei oder so Buchstaben hat, dann nicht weiter ändern: Behebt Fehler mit "se" "ne", etc.

! --- suffix "ern" ---
     if ((buffer->end == 'n') && 
        (buffer->(end-1) == 'r') &&
        (buffer->(end-2) == 'e') &&
        (len > 4) &&
        DictionaryLookup(buffer+at,len-3) > 0) ! word without suffix in lex
     {
      buffer->end = ' ';           ! remove suffix
      buffer->(end-1) = ' ';
      buffer->(end-2) = ' ';
     }

! --- suffix "ses" ---
     if ((buffer->end == 's') && 
        (buffer->(end-1) == 'e') &&
        (buffer->(end-2) == 's') &&
        (len > 4) &&
       DictionaryLookup(buffer+at,len-3) > 0)
     {
      buffer->end = ' ';
      buffer->(end-1) = ' ';
      buffer->(end-2) = ' ';
     }


! --- suffix "se" ---
   if ((buffer->end == 'e') &&
        (buffer->(end-1) == 's') &&
        (len > 3) &&
        DictionaryLookup(buffer+at,len-2) > 0)
    {
      buffer->end = ' ';
      buffer->(end-1) = ' ';
    }

! --- suffix "es" ---
! Thanks to Max Kalus
if ((buffer->end == 's') &&
    (buffer->(end-1) == 'e') &&
    (len > 3) &&
    DictionaryLookup(buffer+at,len-2) > 0)
{
    buffer->end = ' ';
    buffer->(end-1) = ' ';
}

! --- suffix "er" ---
   if ((buffer->end == 'r') &&
        (buffer->(end-1) == 'e') &&
        (len > 3) &&
       DictionaryLookup(buffer+at,len-2) > 0)
    {
      buffer->end = ' ';
      buffer->(end-1) = ' ';
    }

! --- suffix "en" ---
   if ((buffer->end == 'n') &&
        (buffer->(end-1) == 'e') &&
        (len > 3) &&
       DictionaryLookup(buffer+at,len-2) > 0)
    {
      buffer->end = ' ';
      buffer->(end-1) = ' ';
    }

! --- suffix "em" ---	Thanks to Max Kalus
   if ((buffer->end == 'm') &&
        (buffer->(end-1) == 'e') &&
        (len > 3) &&
       DictionaryLookup(buffer+at,len-2) > 0)
    {
      buffer->end = ' ';
      buffer->(end-1) = ' ';
    }

! --- suffix "s" ---
   if ((buffer->end == 's') &&
        (len > 2) &&
        DictionaryLookup(buffer+at,len-1) > 0)
      buffer->end = ' ';

! --- suffix "n" ---
   if ((buffer->end == 'n') &&
        (len > 2) &&
        DictionaryLookup(buffer+at,len-1) > 0)
      buffer->end = ' ';

! --- suffix "e" ---
   if ((buffer->end == 'e') &&
        (len > 2) &&
        DictionaryLookup(buffer+at,len-1) > 0)
      buffer->end = ' ';

    break;
  }
}
];
Neu:
#ifdef USE_OLD_GERMAN_SUFFIX_ROUTINE;
    
!ProcessGermanSuffixes
!Routine to cut off German suffixes, but leave things like 'se' alone
[ ProcessGermanSuffixes  x at end word len;
! 4. Pass: make lemmas out of inflected nouns
!          -> this is equal to removing any suffixes
!          -> on parsing case or number or gender is not looked at at all
!          -> Umlaute (ä as 'ae') have to be entered separately in 
!              the names - property
!  List of (most) german noun suffixes:
!  e n s se ses en er ern 

#ifdef TARGET_ZCODE;
for (x=0:x<parse->1:x++)
{
  word = parse-->(x*2+1);
  if (word == 0)                 ! if word not recognized
  {
    len = parse->(x*4+4);
    at = parse->(x*4+5);
#ifnot; ! TARGET_GLULX
for (x=0:x<parse-->0:x++)
{
  word = parse-->(x*3+1);
  if (word == 0)
  {
    len = parse-->(x*3+2);
    at = parse-->(x*3+3);
#endif; ! TARGET_

    end = at+len-1;              ! last letter of the word

!Zusatz MK:
!Falls das Wort nur zwei oder so Buchstaben hat, dann nicht weiter ändern: Behebt Fehler mit "se" "ne", etc.

! --- suffix "ern" ---
     if ((buffer->end == 'n') && 
        (buffer->(end-1) == 'r') &&
        (buffer->(end-2) == 'e') &&
        (len > 4) &&
        DictionaryLookup(buffer+at,len-3) > 0) ! word without suffix in lex
     {
      buffer->end = ' ';           ! remove suffix
      buffer->(end-1) = ' ';
      buffer->(end-2) = ' ';
     }

! --- suffix "ses" ---
     if ((buffer->end == 's') && 
        (buffer->(end-1) == 'e') &&
        (buffer->(end-2) == 's') &&
        (len > 4) &&
       DictionaryLookup(buffer+at,len-3) > 0)
     {
      buffer->end = ' ';
      buffer->(end-1) = ' ';
      buffer->(end-2) = ' ';
     }


! --- suffix "se" ---
   if ((buffer->end == 'e') &&
        (buffer->(end-1) == 's') &&
        (len > 3) &&
        DictionaryLookup(buffer+at,len-2) > 0)
    {
      buffer->end = ' ';
      buffer->(end-1) = ' ';
    }

! --- suffix "es" ---
! Thanks to Max Kalus
if ((buffer->end == 's') &&
    (buffer->(end-1) == 'e') &&
    (len > 3) &&
    DictionaryLookup(buffer+at,len-2) > 0)
{
    buffer->end = ' ';
    buffer->(end-1) = ' ';
}

! --- suffix "er" ---
   if ((buffer->end == 'r') &&
        (buffer->(end-1) == 'e') &&
        (len > 3) &&
       DictionaryLookup(buffer+at,len-2) > 0)
    {
      buffer->end = ' ';
      buffer->(end-1) = ' ';
    }

! --- suffix "en" ---
   if ((buffer->end == 'n') &&
        (buffer->(end-1) == 'e') &&
        (len > 3) &&
       DictionaryLookup(buffer+at,len-2) > 0)
    {
      buffer->end = ' ';
      buffer->(end-1) = ' ';
    }

! --- suffix "em" ---	Thanks to Max Kalus
   if ((buffer->end == 'm') &&
        (buffer->(end-1) == 'e') &&
        (len > 3) &&
       DictionaryLookup(buffer+at,len-2) > 0)
    {
      buffer->end = ' ';
      buffer->(end-1) = ' ';
    }

! --- suffix "s" ---
   if ((buffer->end == 's') &&
        (len > 2) &&
        DictionaryLookup(buffer+at,len-1) > 0)
      buffer->end = ' ';

! --- suffix "n" ---
   if ((buffer->end == 'n') &&
        (len > 2) &&
        DictionaryLookup(buffer+at,len-1) > 0)
      buffer->end = ' ';

! --- suffix "e" ---
   if ((buffer->end == 'e') &&
        (len > 2) &&
        DictionaryLookup(buffer+at,len-1) > 0)
      buffer->end = ' ';

    break;
  }
}
];

#ifnot; !USE_OLD_GERMAN_SUFFIX_ROUTINE ist nicht aktiv
     
[ ProcessGermanSuffixes x at end word len i;

#ifdef TARGET_ZCODE;
for (x=0:x<parse->1:x++)
{
    word = parse-->(x*2+1);
    
    if (word == 0)                 ! if word not recognized
    {
	len = parse->(x*4+4);
	at = parse->(x*4+5);

	for(i=0:i<len:i++) buffer2->(2+i)=buffer->(at+i);
	buffer2->1 = len;
#ifnot; ! TARGET_GLULX
for (x=0:x<parse-->0:x++)
{
    word = parse-->(x*3+1);
    if (word == 0)
    {
	len = parse-->(x*3+2);
	at = parse-->(x*3+3);
	
	for(i=0:i<len:i++) buffer2->(WORDSIZE+i)=buffer->(at+i);
	buffer2-->0 = len;
#endif; ! TARGET_
	end = at+len-1;              ! last letter of the word

	PGSuffixes_helper(len,end,0);
!	break;
    }
}	
];

#ifndef GERMAN_SUFFIXES_PEDANTIC;

    !Einfacher Suffixentferner. Er entfernt alle möglichen Endungen
    !solange, bis ein bekanntes Wort entstanden ist. "Bauern" wird
    !somit zu "Bauer" und nicht zu "Bau" umgeformt. Allerdings schneidet diese
    !Version auch sinnlose Suffixes ab, wenn ein sinnvolles Wort
    !entstehen würde, z.B. würden, wenn "Bauer" bekannt ist, "Bauerssm",
    !"Bauersss" und "Bauersre" alle zu "Bauer" transformiert.
    
Array _PGS_Array ->
    !Startindex
    3 9 13
    !Round 0
    'e' 'm' 'n' 'r' 's' 0
    !Round 1
    'e' 'r' 's' 0
    !Round 2
    'e' 's' 0;

[PGSuffixes_helper len end  round   i;
    ! evtl. gar kein Längencheck?
    if (len<2)
	rfalse;

#ifdef TARGET_ZCODE;
	buffer2->1 = len;
    	Tokenise__(buffer2,parse2);
#ifnot; !TARGET_GLULX
        buffer2-->0 = len;
	Tokenise__(buffer2,parse2);
#endif; !TARGET_
    
    if (parse2-->1) !Wort bekannt
	rtrue;

    if (round>2)
	rfalse;
    
    for (i=_PGS_Array->round:_PGS_Array->i:i++) {
    	if (buffer->end == _PGS_Array->i &&
	    PGSuffixes_helper(len-1,end-1,round+1)) {
	    buffer->end = ' ';
	    rtrue;
	}
    }
    rfalse;
];

#ifnot; !GERMAN_SUFFIXES_PEDANTIC ist an

!Eine einfache Turingmaschine(ok, die andere Version könnte man auch
!als eine Bezeichnen) zum Abschneiden der Endungen. Arbeitet wie die einfache Version,
!nur schneidet sie nur "richtige" Endungen ab, z.B. nur "ern","ses" aber nicht "ssm", "sre" etc. 

Array _PGS_Array ->
!Startindex der einzelnen Zustände
    5 16 19 24 27
!Format: Zeichen, Zielzustand (99=stop); 0 schließt Liste ab
!State 0
    'e' 1 'n' 2 's' 3 'm' 4 'r' 4 0
!State 1
    's' 99 0 
!State 2
    'e' 99 'r' 4 0
!State 3
    'e' 1 0
!State 4, hier muß eines der angegeben Zeichen folgen
    'e' 99 0;

[PGSuffixes_helper len end state    i;
    
!Ist der Längencheck notwendig? Ich glaube nicht...
    if (len<2)
	rfalse;
    
    if (state ~= 4) !Spezialfall
    {
#ifdef TARGET_ZCODE;
	buffer2->1 = len;
    	Tokenise__(buffer2,parse2);
#ifnot; !TARGET_GLULX
	buffer2-->0 = len;
	Tokenise__(buffer2,parse2);
#endif; !TARGET_
	if (parse2-->1) 
	    rtrue;
    }
    
    if (state == 99)
	!Kein bekanntes Wort nach abschneiden eines Suffixes -> nicht abschneiden!
	rfalse;

    !Andere Möglichkeiten abprüfen
    for(i=_PGS_Array->state:_PGS_Array->i:i=i+2) {
	if (buffer->end == _PGS_Array->i &&
	    PGSuffixes_helper(len-1,end-1,_PGS_Array->(i+1))) {
	    buffer->end = ' ';
	    rtrue;
	}
    }
    rfalse;
];

#endif; !GERMAN_SUFFIXES_PEDANTIC

#endif; !USE_OLD_GERMAN_SUFFIX_ROUTINE

***********************************************************************

Alt:
Object DunkelObj "Gegenstand"
	with dekl 1, adj "undefinierbar" "dunkl",
	has male scenery;

[ LanguageLM n x1;
Neu:
Object DunkelObj "Gegenstand"
	with dekl 1, adj "undefinierbar" "dunkl",
!Property suffixes muß noch deklariert werden.
!Also machen wir das doch hier.
    	suffixes,
	has male scenery;

[ LanguageLM n x1 flag;

***********************************************************************

Alt:
              23: "Gesprächspartner nicht gefunden!";
Neu:
              23: "[Du scheinst mit jemandem sprechen zu wollen, aber ich weiss nicht, mit wem.]";

***********************************************************************

Alt:
              27: "Dieses Verb verstehe ich nicht.";
Neu:
              27: "Diesen Satz verstehe ich nicht.";

***********************************************************************

Alt:
              28: print "Wahrscheinlich meinst du: ";
Neu:
              28: print "Ich habe dich nur soweit verstanden: ";

***********************************************************************

Alt:
              38: "Diesen Satz verstehe ich nicht.";
Neu:
              38: "Dieses Verb verstehe ich nicht.";

***********************************************************************

Alt:
              50: print "Dein Punktestand hat sich um ";
                  if (x1==1) print "einen Punkt ";
                    else print (number) x1, " Punkte ";
                  if (x1 > 0) print "erhöht"; else 
                      { x1 = -x1; print "verringert"; }
Neu:
              50: print "Dein Punktestand hat sich um ";
                  if (x1<0) {flag=0;x1=-x1;} else flag=1;
		  if (x1==1) print "einen Punkt ";
                    else print (number) (x1), " Punkte ";
                  if (flag) print "erhöht"; else 
			    print "verringert";	

***********************************************************************

Alt:
               3: print "Ich nehme nicht an, ", (der) x1, " ";
                  singplur(x1, "würde", "würden");
                  print_ret " sich dafür interessieren.";
Neu:
               3: print "Ich nehme nicht an, ", (string) C_DASS,(der) x1, " das ";
                  singplur(x1, "möchte", "möchten");
                  print_ret ".";

***********************************************************************

Alt:
              11: print_ret (GDer) x1, " steh", (endT) x1,
                  " unbeweglich da. Du bewegst ", (ihn) x1, " keinen Millimeter weit.";
Neu:
              11: print_ret (GDer) x1, " ", (ist) x1," hier fest verankert.";

***********************************************************************
* tgerman.h
***********************************************************************

Alt:
Property dekl;	
Property adj;
Property post;
Neu:
Property dekl;	
Property adj;
Property post;
Property changing_gender;

***********************************************************************

Alt:
[ta_ArticlesGenderOffset obj;
Neu:
[ta_ArticlesGenderOffset obj;
  if (obj provides changing_gender) obj.changing_gender = 0;

***********************************************************************

Alt:
];

[ta_ArticlesNumberOffset obj;
Neu:
];

[ta_ArticlesChangingGenderOffset obj x;
  if (~~(obj provides changing_gender && obj.changing_gender ~= 0))
    return ta_ArticlesGenderOffset(obj);
  x = obj.changing_gender;
    
  if (x==male) x=0; else
  { if (x==female) x=ta_LanguageNumberCases; else
    { if (x==neuter) 
	{x=ta_LanguageNumberCases * 2;
     } else {
#ifdef DEBUG;
        print "^# TGERMAN Warnung: ", obj, 
             " hat kein korrektes changing_gender - Interner Fehler?^";
#endif;
     return ta_ArticlesGenderOffset(obj); !sonst default nehmen
      }
    }
  }
  return x;
];

[ta_ArticlesNumberOffset obj;

***********************************************************************

Alt:
     rtrue;
   };
#ifdef DEBUG;
 } else {
   print "^# TGERMAN Warnung: ", obj, " hat keine Deklination (dekl)";
Neu:
     rtrue;
   } else if (obj provides suffixes) {
       n = case + ta_ArticlesNumberOffset(obj);
       if (metaclass(obj.suffixes) == Routine) 
	   obj.suffixes(case);
       else
	   print (string) (obj.&suffixes-->case);
   }
	   
#ifdef DEBUG;
 } else {
   print "^# TGERMAN Warnung: ", obj, " hat keine Deklination (dekl)";

***********************************************************************

Alt:
[er obj; 
  print (string) ta_LanguageItPronouns --> 
   (ta_ArticlesNumberOffset(obj) + ta_ArticlesGenderOffset(obj));
];

[ihn obj;
  print (string) ta_LanguageItPronouns --> 
   (ta_ArticlesNumberOffset(obj) + ta_ArticlesGenderOffset(obj) + 1);
];
 
[ihm obj;
  print (string) ta_LanguageItPronouns --> 
   (ta_ArticlesNumberOffset(obj) + ta_ArticlesGenderOffset(obj) + 2);
];

[seiner obj;
  print (string) ta_LanguageItPronouns --> 
   (ta_ArticlesNumberOffset(obj) + ta_ArticlesGenderOffset(obj) + 3);
];


Array ta_LanguageUpperItPronouns -->

! Nom   Akk   Dat   Gen          personal pronoun 3rd person singular

  "Er"  "Ihn" "Ihm" "Seiner"   ! Mask
  "Sie" "Sie" "Ihr" "Ihrer"    ! Fem
  "Es"  "Es"  "Ihm" "Seiner"   ! Neutr

! Nom   Akk   Dat     Gen          personal pronoun 3rd person plural

  "Sie" "Sie" "Ihnen" "Ihrer"    ! Mask
  "Sie" "Sie" "Ihnen" "Ihrer"    ! Fem
  "Sie" "Sie" "Ihnen" "Ihrer"    ! Neutr
;


[Ger obj; 
  print (string) ta_LanguageUpperItPronouns --> 
   (ta_ArticlesNumberOffset(obj) + ta_ArticlesGenderOffset(obj));
];

[Gihn obj;
  print (string) ta_LanguageUpperItPronouns --> 
   (ta_ArticlesNumberOffset(obj) + ta_ArticlesGenderOffset(obj) + 1);
];
 
[Gihm obj;
  print (string) ta_LanguageUpperItPronouns --> 
   (ta_ArticlesNumberOffset(obj) + ta_ArticlesGenderOffset(obj) + 2);
];

[Gseiner obj;
  print (string) ta_LanguageUpperItPronouns --> 
   (ta_ArticlesNumberOffset(obj) + ta_ArticlesGenderOffset(obj) + 3);
];





! german replacements for ThatorThose;
! ------------------------------------

Array ta_LanguageThatPronouns --> 

! Nom       Akk      Dat      Gen      demonstrative pronoun 3rd person sg

  "dieser"  "diesen" "diesem" "dieses"   ! Mask
  "diese"   "diese"  "dieser" "dieser"   ! Fem
  "dieses"  "dieses" "diesem" "dieses"   ! Neutr

! Nom     Akk     Dat      Gen         demonstative pronoun 3rd person pl

  "diese" "diese" "diesen" "dieser"    ! Mask
  "diese" "diese" "diesen" "dieser"    ! Fem
  "diese" "diese" "diesen" "dieser"    ! Neutr
;


[dieser obj; 
  print (string) ta_LanguageThatPronouns --> 
   (ta_ArticlesNumberOffset(obj) + ta_ArticlesGenderOffset(obj));
];

[diesen obj;
  print (string) ta_LanguageThatPronouns --> 
   (ta_ArticlesNumberOffset(obj) + ta_ArticlesGenderOffset(obj) + 1);
];
 
[diesem obj;
  print (string) ta_LanguageThatPronouns --> 
   (ta_ArticlesNumberOffset(obj) + ta_ArticlesGenderOffset(obj) + 2);
];

[dieses obj;
  print (string) ta_LanguageThatPronouns --> 
   (ta_ArticlesNumberOffset(obj) + ta_ArticlesGenderOffset(obj) + 3);
];



Array ta_LanguageUpperThatPronouns --> 

! Nom       Akk      Dat      Gen      demonstrative pronoun 3rd person sg

  "Dieser"  "Diesen" "Diesem" "Dieses"   ! Mask
  "Diese"   "Diese"  "Dieser" "Dieser"   ! Fem
  "Dieses"  "Dieses" "Diesem" "Dieses"   ! Neutr

! Nom     Akk     Dat      Gen         demonstative pronoun 3rd person pl

  "Diese" "Diese" "Diesen" "Dieser"    ! Mask
  "Diese" "Diese" "Diesen" "Dieser"    ! Fem
  "Diese" "Diese" "Diesen" "Dieser"    ! Neutr
;


[Gdieser obj; 
  print (string) ta_LanguageUpperThatPronouns --> 
   (ta_ArticlesNumberOffset(obj) + ta_ArticlesGenderOffset(obj));
];

[Gdiesen obj;
  print (string) ta_LanguageUpperThatPronouns --> 
   (ta_ArticlesNumberOffset(obj) + ta_ArticlesGenderOffset(obj) + 1);
];
 
[Gdiesem obj;
  print (string) ta_LanguageUpperThatPronouns --> 
   (ta_ArticlesNumberOffset(obj) + ta_ArticlesGenderOffset(obj) + 2);
];

[Gdieses obj;
  print (string) ta_LanguageUpperThatPronouns --> 
   (ta_ArticlesNumberOffset(obj) + ta_ArticlesGenderOffset(obj) + 3);
];
Neu:
[er obj; 
  print (string) ta_LanguageItPronouns --> 
   (ta_ArticlesNumberOffset(obj) + ta_ArticlesChangingGenderOffset(obj));
];

[ihn obj;
  print (string) ta_LanguageItPronouns --> 
   (ta_ArticlesNumberOffset(obj) + ta_ArticlesChangingGenderOffset(obj) + 1);
];
 
[ihm obj;
  print (string) ta_LanguageItPronouns --> 
   (ta_ArticlesNumberOffset(obj) + ta_ArticlesChangingGenderOffset(obj) + 2);
];

[seiner obj;
  print (string) ta_LanguageItPronouns --> 
   (ta_ArticlesNumberOffset(obj) + ta_ArticlesChangingGenderOffset(obj) + 3);
];


Array ta_LanguageUpperItPronouns -->

! Nom   Akk   Dat   Gen          personal pronoun 3rd person singular

  "Er"  "Ihn" "Ihm" "Seiner"   ! Mask
  "Sie" "Sie" "Ihr" "Ihrer"    ! Fem
  "Es"  "Es"  "Ihm" "Seiner"   ! Neutr

! Nom   Akk   Dat     Gen          personal pronoun 3rd person plural

  "Sie" "Sie" "Ihnen" "Ihrer"    ! Mask
  "Sie" "Sie" "Ihnen" "Ihrer"    ! Fem
  "Sie" "Sie" "Ihnen" "Ihrer"    ! Neutr
;


[Ger obj; 
  print (string) ta_LanguageUpperItPronouns --> 
   (ta_ArticlesNumberOffset(obj) + ta_ArticlesChangingGenderOffset(obj));
];

[Gihn obj;
  print (string) ta_LanguageUpperItPronouns --> 
   (ta_ArticlesNumberOffset(obj) + ta_ArticlesChangingGenderOffset(obj) + 1);
];
 
[Gihm obj;
  print (string) ta_LanguageUpperItPronouns --> 
   (ta_ArticlesNumberOffset(obj) + ta_ArticlesChangingGenderOffset(obj) + 2);
];

[Gseiner obj;
  print (string) ta_LanguageUpperItPronouns --> 
   (ta_ArticlesNumberOffset(obj) + ta_ArticlesChangingGenderOffset(obj) + 3);
];





! german replacements for ThatorThose;
! ------------------------------------

Array ta_LanguageThatPronouns --> 

! Nom       Akk      Dat      Gen      demonstrative pronoun 3rd person sg

  "dieser"  "diesen" "diesem" "dieses"   ! Mask
  "diese"   "diese"  "dieser" "dieser"   ! Fem
  "dieses"  "dieses" "diesem" "dieses"   ! Neutr

! Nom     Akk     Dat      Gen         demonstative pronoun 3rd person pl

  "diese" "diese" "diesen" "dieser"    ! Mask
  "diese" "diese" "diesen" "dieser"    ! Fem
  "diese" "diese" "diesen" "dieser"    ! Neutr
;


[dieser obj; 
  print (string) ta_LanguageThatPronouns --> 
   (ta_ArticlesNumberOffset(obj) + ta_ArticlesChangingGenderOffset(obj));
];

[diesen obj;
  print (string) ta_LanguageThatPronouns --> 
   (ta_ArticlesNumberOffset(obj) + ta_ArticlesChangingGenderOffset(obj) + 1);
];
 
[diesem obj;
  print (string) ta_LanguageThatPronouns --> 
   (ta_ArticlesNumberOffset(obj) + ta_ArticlesChangingGenderOffset(obj) + 2);
];

[dieses obj;
  print (string) ta_LanguageThatPronouns --> 
   (ta_ArticlesNumberOffset(obj) + ta_ArticlesChangingGenderOffset(obj) + 3);
];



Array ta_LanguageUpperThatPronouns --> 

! Nom       Akk      Dat      Gen      demonstrative pronoun 3rd person sg

  "Dieser"  "Diesen" "Diesem" "Dieses"   ! Mask
  "Diese"   "Diese"  "Dieser" "Dieser"   ! Fem
  "Dieses"  "Dieses" "Diesem" "Dieses"   ! Neutr

! Nom     Akk     Dat      Gen         demonstative pronoun 3rd person pl

  "Diese" "Diese" "Diesen" "Dieser"    ! Mask
  "Diese" "Diese" "Diesen" "Dieser"    ! Fem
  "Diese" "Diese" "Diesen" "Dieser"    ! Neutr
;


[Gdieser obj; 
  print (string) ta_LanguageUpperThatPronouns --> 
   (ta_ArticlesNumberOffset(obj) + ta_ArticlesChangingGenderOffset(obj));
];

[Gdiesen obj;
  print (string) ta_LanguageUpperThatPronouns --> 
   (ta_ArticlesNumberOffset(obj) + ta_ArticlesChangingGenderOffset(obj) + 1);
];
 
[Gdiesem obj;
  print (string) ta_LanguageUpperThatPronouns --> 
   (ta_ArticlesNumberOffset(obj) + ta_ArticlesChangingGenderOffset(obj) + 2);
];

[Gdieses obj;
  print (string) ta_LanguageUpperThatPronouns --> 
   (ta_ArticlesNumberOffset(obj) + ta_ArticlesChangingGenderOffset(obj) + 3);
];

***********************************************************************

Alt:
[ta_PrintPostNoun obj;
   if(obj provides post)
   {
     if(metaclass(obj.post) == string)
     {
       print " ", (string) obj.post;
     } else {
	print " ";
     	obj.post();
     }
   }
];
Neu:
[ta_PrintPostNoun obj;
   if(obj provides post)
   {
     if(metaclass(obj.post) == string)
     {
       print " ", (string) obj.post;
     } else {
	!print " ";
     	obj.post();
     }
   }
];

***********************************************************************
***********************************************************************
***********************************************************************
* Deutsche Inform Library: Änderungsliste 15 (25.09.2002)
***********************************************************************
***********************************************************************
***********************************************************************

Vorschläge von: Dieter Köhler, Beate Pupik

***********************************************************************
* german.h
***********************************************************************

Alt:
              39: "Ein flüchtiger Blick auf ", (den) x1, " sagt dir, ", (string) C_DASS,
                    (er) x1, " für das Spiel nicht wichtig ", (isorare) x1, ".";
Neu:
              39: "Ein flüchtiger Blick darauf sagt dir, ", (string) C_DASS,
                    " es sich um nichts wichtiges für das Spiel handelt.";

***********************************************************************
* tgerman.h
***********************************************************************

Alt:
[ta_PrintPostNoun obj;
  if (obj provides post)
    print " ", (string) obj.post;
];
Neu:
[ta_PrintPostNoun obj;
   if(obj provides post)
   {
     if(metaclass(obj.post) == string)
     {
       print " ", (string) obj.post;
     } else {
	print " ";
     	obj.post();
     }
   }
];

***********************************************************************
***********************************************************************
***********************************************************************
* Deutsche Inform Library: Änderungsliste 14 (15.08.2002)
***********************************************************************
***********************************************************************
***********************************************************************

Vorschläge von: Sophie Frühling

***********************************************************************
* german.h
***********************************************************************

Alt:
              #ifdef R_NEU;
                  39: "Das ist nichts, worauf du dich in diesem Spiel beziehen musst.";
              #ifnot;
                  39: "Das ist nichts, worauf du dich in diesem Spiel beziehen mußt.";
              #endif;
Neu:
              #ifdef R_NEU;
                  36: "Das ist nichts, worauf du dich in diesem Spiel beziehen musst.";
              #ifnot;
                  36: "Das ist nichts, worauf du dich in diesem Spiel beziehen mußt.";
              #endif;

Alt:
              27: "Diesen Befehl verstehe ich nicht.";
Neu:
              27: "Dieses Verb verstehe ich nicht.";

***********************************************************************
***********************************************************************
***********************************************************************
* Deutsche Inform Library: Änderungsliste 13 (26.07.2002)
***********************************************************************
***********************************************************************
***********************************************************************

Vorschläge von: Max Kalus, Sophie Frühling

***********************************************************************
* german.h
***********************************************************************

******************* LanguageToInformese *******************************

LanguageToInformese-Routine vollständig ausgetauscht und in mehrere
kleinere Routinen geteilt

***********************************************************************

Alt:
              38: "Dieses Verb verstehe ich nicht.";
Neu:
              38: "Diesen Satz verstehe ich nicht.";

***********************************************************************

Alt:
              26: if (not_holding == player) "(nehme zuerst dich selbst)"; !Änderung v. Max Kalus
                  "(nehme zuerst ", (den) not_holding, ")";
Neu:
               26: if (not_holding == player) "(Dazu nimmst du zuerst dich selbst)";
                  "(Dazu nimmst du zuerst ", (den) not_holding, ")";

***********************************************************************

Alt:
               3: "(nehme zuerst ", (den) x1, ")";
Neu:
               3: "(Dazu nimmst du zuerst ", (den) x1, ")";

***********************************************************************

Alt (2x):
               5: "(nehme ", (ihn) x1, " zuerst)^";
Neu (2x):
               5: "(Dazu nimmst du ", (ihn) x1, " zuerst)^";

***********************************************************************

Alt (2x):
               6: "(nehme ", (ihn) x1, " zuerst)^";
Neu (2x):
               6: "(Dazu nimmst du ", (ihn) x1, " zuerst)^";

***********************************************************************

Alt:
              13: "(lege ", (den) x1, " in ", (den) SACK_OBJECT,
                  ", um Platz zu schaffen)";
Neu:
              13: "(Dazu legst du ", (den) x1, " in ", (den) SACK_OBJECT,
                  ", um Platz zu schaffen)";

***********************************************************************

Alt:
               6: print "(komme ";
                  if (x1 has supporter) print "herunter von "; 
                  else print "hinaus aus "; print (dem) x1; ")";
               7: if (x1 has supporter) "(gelange auf ", (den) x1, ")^";
                  if (x1 has container) "(gelange in ", (den) x1, ")^";
                  "(trete in ", (den) x1, " ein)^";
Neu:
               6: print "(Du kommst ";
                  if (x1 has supporter) print "herunter von "; 
                  else print "hinaus aus "; print (dem) x1; ")";
               7: if (x1 has supporter) "(Du gelangst auf ", (den) x1, ")^";
                  if (x1 has container) "(Du gelangst in ", (den) x1, ")^";
                  "(Du trittst in ", (den) x1, " ein)^";

***********************************************************************
***********************************************************************
***********************************************************************
* Deutsche Inform Library: Änderungsliste 12 (25.07.2002)
***********************************************************************
***********************************************************************
***********************************************************************

Behebung einer falschen Fehlerverbesserung...

***********************************************************************
* verblibm.h
***********************************************************************

Alt:
             !Bugfix, Inform Patches [Problem with additive 'describe' property]
             if (o hasnt moved || o.describe~=0 || f2==1)
             {   if (o.describe~=0 && RunRoutines(o,describe)~=0)
Neu:
             !Bugfix, Inform Patches [Problem with additive 'describe' property]
             if (o hasnt moved || o.&describe~=0 || f2==1)
             {   if (o.&describe~=0 && RunRoutines(o,describe)~=0)

***********************************************************************

Alt:
      !Bugfix, Inform Patches [Problem with additive 'describe' property]
      {   if (location.describe~=0) RunRoutines(location,describe);
Neu:
      !Bugfix, Inform Patches [Problem with additive 'describe' property]
      {   if (location.&describe~=0) RunRoutines(location,describe);

***********************************************************************
***********************************************************************
***********************************************************************
* Deutsche Inform Library: Änderungsliste 11 (17.07.2002)
***********************************************************************
***********************************************************************
***********************************************************************

Vorschläge von: Dennis Brakhane, Max Kalus, Inform-Bugfixes, if-Liste

***********************************************************************
* Alle
***********************************************************************
Bugfixes nach Patch-Library mit entsprechenden Referenzen versehen

***********************************************************************
* parserm.h
***********************************************************************

Alt:
               l = multiple_object-->k;
               PronounNotice(l);
               print (name) l, ": ";
               if (inp1 == 0)
Neu:
               l = multiple_object-->k;
               PronounNotice(l);
               print (_en) l, ": ";
               if (inp1 == 0)

***********************************************************************

Alt:
[ DisplayStatus;
   if (the_time==NULL)
   {   sline1=score; sline2=turns; }
   else
   {   sline1=the_time/60; sline2=the_time%60; }
];
Neu:
[ DisplayStatus;
   if ((0->1)&2 == 0)	!Bugfix, Inform Patches [Implementing a clock]
   {   sline1=score; sline2=turns; }
   else
   {   sline1=the_time/60; sline2=the_time%60; }
];

***********************************************************************

Alt:
      obj = match_list-->i; its_owner = parent(obj); its_score=0;
Neu:
      obj = match_list-->i; its_owner = parent(obj); its_score=0;
      met = 0; !Bugfix, Inform Patches [Match list handled incorrectly]

***********************************************************************

Alt:
[ ParseToken__ given_ttype given_tdata token_n
             token l o i j k and_parity single_object desc_wn many_flag
             token_allows_multiple;
Neu:
[ ParseToken__ given_ttype given_tdata token_n
             token l o i j k and_parity single_object desc_wn many_flag
             token_allows_multiple;

   !Bugfix, Inform Patches ["Read" verb on out-of-scope objects]
   if (o==-1 && (line_ttype-->(token_n+1) == PREPOSITION_TT))
       return GPR_FAIL;    ! don't infer if required preposition is absent

***********************************************************************
* verblibm.h
***********************************************************************

Alt:
[ ListEqual o1 o2;
  if (child(o1)~=0 && WillRecurs(o1)~=0) rfalse;
  if (child(o2)~=0 && WillRecurs(o2)~=0) rfalse;

  if (c_style & (FULLINV_BIT + PARTINV_BIT) ~= 0)
  {   if ((o1 hasnt worn && o2 has worn)
          || (o2 hasnt worn && o1 has worn)) rfalse;
      if ((o1 hasnt light && o2 has light)
          || (o2 hasnt light && o1 has light)) rfalse;
  }

  return Identical(o1,o2);
];
Neu:
[ ListEqual o1 o2;
  if (child(o1)~=0 && WillRecurs(o1)~=0) rfalse;
  if (child(o2)~=0 && WillRecurs(o2)~=0) rfalse;

  if (c_style & (FULLINV_BIT + PARTINV_BIT) ~= 0)
  {   if ((o1 hasnt worn && o2 has worn)
          || (o2 hasnt worn && o1 has worn)) rfalse;
      if ((o1 hasnt light && o2 has light)
          || (o2 hasnt light && o1 has light)) rfalse;

      !Bugfix, Inform Patches [Plural containers listed wrong]
      if (o1 has container)
      {    if (o2 hasnt container) rfalse;
           if ((o1 has open && o2 hasnt open)
                || (o2 has open && o1 hasnt open))
                    rfalse;
      }
      else if (o2 has container) rfalse;
  }

  return Identical(o1,o2);
];

***********************************************************************

Alt:
  if (noun has container && noun hasnt transparent	!geändert Max Kalus
      && IndirectlyContains(noun,player)==0)
Neu:
  !Bugfix, Inform Patches [Revealing contents in darkness]
  if (noun has container && noun hasnt transparent && child(noun)~=0
      && location ~= thedark
      && IndirectlyContains(noun,player)==0)
      return L__M(##Open,4,noun);

***********************************************************************

Alt:
  if (noun has scenery)  return L__M(##Push,2,noun);
  if (noun has animate)  return L__M(##Pull,4,noun);
Neu:
  if (noun has scenery)  return L__M(##Push,2,noun);
  !Bugfix, Inform Patches [Wrong messages for PUSH/TURN]
  if (noun has animate)  return L__M(##Push,4,noun);

***********************************************************************

Alt:
  if (noun has scenery)  return L__M(##Turn,2,noun);
  if (noun has animate)  return L__M(##Pull,4,noun);
Neu:
  if (noun has scenery)  return L__M(##Turn,2,noun);
  !Bugfix, Inform Patches [Wrong messages for PUSH/TURN]
  if (noun has animate)  return L__M(##Turn,4,noun);

***********************************************************************

Alt:
[ ExitSub p;
  p=parent(player);
Neu:
[ ExitSub p;
  p=parent(player);
  !Bugfix, Inform Patches [LEAVE tries too hard]
  if (noun ~= nothing && noun ~= p) return L__M(##Exit,4,noun);

***********************************************************************

Alt:
  if (second == d_obj || player in second) <<Drop noun>>;
Neu:
  if (second == d_obj || player in second) <<Drop noun>>;
  !Bugfix, Inform Patches [Object already in/on another]
  if (parent(noun) == second) return L__M(##Drop,1,noun);

***********************************************************************

Alt:
  if (second==d_obj || player in second) <<Drop noun>>;
Neu:
  if (second==d_obj || player in second) <<Drop noun>>;
  !Bugfix, Inform Patches [Object already in/on another]
  if (parent(noun) == second) return L__M(##Drop,1,noun);

***********************************************************************

Alt:
             if (o hasnt moved || o.describe~=NULL || f2==1)
             {   if (o.describe~=NULL && RunRoutines(o,describe)~=0)
Neu:
             !Bugfix, Inform Patches [Problem with additive 'describe' property]
             if (o hasnt moved || o.describe~=0 || f2==1)
             {   if (o.describe~=0 && RunRoutines(o,describe)~=0)

***********************************************************************

Alt:
      {   if (location.describe~=NULL) RunRoutines(location,describe);
Neu:
      !Bugfix, Inform Patches [Problem with additive 'describe' property]
      {   if (location.describe~=0) RunRoutines(location,describe);

***********************************************************************
* german.h
***********************************************************************

Alt:
              39: "Ein flüchtiger Blick auf ", (den) x1, " sagt dir, ", (string) C_DASS,
                    (er) x1, " für das Spiel nicht wichtig ", (isorare) x1, ".";
Neu:
              #ifdef R_NEU;
                  39: "Das ist nichts, worauf du dich in diesem Spiel beziehen musst.";
              #ifnot;
                  39: "Das ist nichts, worauf du dich in diesem Spiel beziehen mußt.";
              #endif;

***********************************************************************

Alt:
               3: print "Du gelangst ";
                  if (x1 has supporter) print "runter von "; 
                  else print "hinaus aus "; print_ret (dem) x1, ".";
Neu:
               3: print "Du gelangst ";
                  if (x1 has supporter) print "runter von "; 
                  else print "hinaus aus "; print_ret (dem) x1, ".";
               4: !Bugfix, Inform Patches [LEAVE tries too hard]
                  print "Aber du bist doch gerade gar nicht ";
                  if (x1 has supporter) print "auf"; else print "in"; 
                  print_ret " ", (dem) x1, ".";

***********************************************************************
***********************************************************************
***********************************************************************
* Deutsche Inform Library: Änderungsliste 10 (05.06.2002)
***********************************************************************
***********************************************************************
***********************************************************************

Vorschläge von: Andrea Weikert, Sophie Frühling, Max Kalus

***********************************************************************
* parserm.h
***********************************************************************

Alt:
  return parse2->1; !Geändert Max Kalus
Neu:
  return parse2-->1;

***********************************************************************

Alt:
];

! ----------------------------------------------------------------------------
!  Converting between dictionary addresses and entry numbers
Neu:
];

[ GetGNAOfObjectWithGender  obj gender case;
    !Wird für ChangingGender Objekte gebraucht, um die Pronomen
    !richtig zu setzen
   if (obj hasnt animate) case = 6;
   if (gender == female) case = case + 1;
   if (gender == neuter) case = case + 2;
   if (obj has pluralname) case = case + 3;
   return case;
];

! ----------------------------------------------------------------------------
!  Converting between dictionary addresses and entry numbers

***********************************************************************
* german.h
***********************************************************************

Alle @ss in ß umgewandelt.

***********************************************************************

Alt:
Constant LanguageVersion
        = "Übersetzung ins Deutsche (c) 1998/99 Toni Arnold, Serial No 990919";
Neu:
#ifndef R_NEU;
	Constant R_ALT;		!Alte Rechtschreibung als Defaultwert
#endif;

Constant LanguageVersion
        = "Offizielle deutsche Inform-Library, Release 10, Serial 020605";

***********************************************************************

Alt:
                  if (DEATH_MENTION_UNDO==0)
                      print ", den letzten Zug R@:UCKG@:ANGIG machen";
Neu:
                  if (DEATH_MENTION_UNDO==0)
                      print ", den letzten Zug RÜCKGÄNGIG machen";

***********************************************************************

Alt:
              38: #ifdef DIALECT_US;
                  "That's not a verb I recognize.";
                  #ifnot;
                  "Dieses Verb verstehe ich nicht.";
                  #endif;
Neu:
              38: "Dieses Verb verstehe ich nicht.";

***********************************************************************

Alt:
              39: "Ein flüchtiger Blick auf ", (den) x1, " sagt dir, ", (string) C_DASS,
                    (er) x1, " für das Spiel nicht wichtig ", (isorare) x1, ".";
Neu:
              39: "Ein flüchtiger Blick auf ", (den) x1, " sagt dir, 
                    daß ", (er) x1, " für das Spiel nicht wichtig ", (isorare) x1, ".";

***********************************************************************

Alt:
           {   1: print "Bist du sicher, daß du einen Neustart willst? ";
Neu:
           {   1: print "Bist du sicher, ", (string) C_DASS, "du einen Neustart willst? ";

***********************************************************************

Alt:
  Restore: switch(n)
           {   1: "Laden eines Spielstandes mißlang.";
               2: "In Ordnung.";
           }
  Save:    switch(n)
           {   1: "Das Speichern mißlang.";
               2: "In Ordnung.";
           }
Neu:
#ifdef R_NEU;
  Restore: switch(n)
           {   1: "Laden eines Spielstandes misslang.";
               2: "In Ordnung.";
           }
  Save:    switch(n)
           {   1: "Das Speichern misslang.";
               2: "In Ordnung.";
           }
#ifnot;
  Restore: switch(n)
           {   1: "Laden eines Spielstandes mißlang.";
               2: "In Ordnung.";
           }
  Save:    switch(n)
           {   1: "Das Speichern mißlang.";
               2: "In Ordnung.";
           }
#endif;

***********************************************************************

Alt:
               2: "Es konnte nicht bestätigt werden, daß die 
                   Spielstanddatei in Ordnung ist. Möglicherweise ist
                   sie kaputt (es sei denn, Du spielst mit einem sehr 
                   primitiven Interpreter, welcher den Test nicht 
                   wirklich machen kann)."; 
Neu:
               2: "Es konnte nicht bestätigt werden, ", (string) C_DASS, "die 
                   Spielstanddatei in Ordnung ist. Möglicherweise ist
                   sie kaputt (es sei denn, Du spielst mit einem sehr 
                   einfachen Interpreter, welcher den Test nicht 
                   wirklich machen kann)."; 

***********************************************************************

Alt:
  PutOn:   switch(n)
           {   1: "Du mußt ", (den) x1,
                  " zuerst haben, bevor du ", (ihn) x1,
                  " auf etwas anderes legen kannst.";
               2: "Du kannst nichts auf sich selbst legen.";
               3: "Dinge auf ", (den) x1, " zu legen, würde nichts bringen.";
               4: "Dir fehlt die erforderliche Geschicklichkeit.";
               5: "(nehme ", (ihn) x1, " zuerst)^";
               6: "Da ist kein Platz mehr auf ", (dem) x1, ".";
               7: "Gesagt, getan!";
               8: "Du legst ", (den) x1, " auf ", (den) second, ".";
           }
  Insert:  switch(n)
           {   1: "Du mußt ", (den) x1,
                  " zuerst haben, bevor du ", (ihn) x1,
                  " in etwas anderes legen kannst.";
               2: print (Gdieser) x1, " ";
                  singplur(x1, "kann", "können");
                  " keine Dinge enthalten.";
               3: print_ret (gder) x1, " ", (isorare) x1, " geschlossen.";
               4: "Du solltest ", (ihn) x1, " zuerst wegnehmen.";
               5: "Du kannst nichts in sich selbst legen.";
               6: "(nehme ", (ihn) x1, " zuerst)^";
               7: "Da ist kein Platz mehr in ", (dem) x1, ".";
               8: "Gesagt, getan!";
               9: "Du legst ", (den) x1, " in ", (den) second, ".";
           }
Neu:
#ifdef R_NEU;
  PutOn:   switch(n)
           {   1: "Du mußt ", (den) x1,
                  " zuerst haben, bevor du ", (ihn) x1,
                  " auf etwas anderes legen kannst.";
               2: "Du kannst nichts auf sich selbst legen.";
               3: "Dinge auf ", (den) x1, " zu legen, würde nichts bringen.";
               4: "Dir fehlt die erforderliche Geschicklichkeit.";
               5: "(nehme ", (ihn) x1, " zuerst)^";
               6: "Da ist kein Platz mehr auf ", (dem) x1, ".";
               7: "Gesagt, getan!";
               8: "Du legst ", (den) x1, " auf ", (den) second, ".";
           }
  Insert:  switch(n)
           {   1: "Du mußt ", (den) x1,
                  " zuerst haben, bevor du ", (ihn) x1,
                  " in etwas anderes legen kannst.";
               2: print (Gdieser) x1, " ";
                  singplur(x1, "kann", "können");
                  " keine Dinge enthalten.";
               3: print_ret (gder) x1, " ", (isorare) x1, " geschlossen.";
               4: "Du solltest ", (ihn) x1, " zuerst wegnehmen.";
               5: "Du kannst nichts in sich selbst legen.";
               6: "(nehme ", (ihn) x1, " zuerst)^";
               7: "Da ist kein Platz mehr in ", (dem) x1, ".";
               8: "Gesagt, getan!";
               9: "Du legst ", (den) x1, " in ", (den) second, ".";
           }
#ifnot;
  PutOn:   switch(n)
           {   1: "Du musst ", (den) x1,
                  " zuerst haben, bevor du ", (ihn) x1,
                  " auf etwas anderes legen kannst.";
               2: "Du kannst nichts auf sich selbst legen.";
               3: "Dinge auf ", (den) x1, " zu legen, würde nichts bringen.";
               4: "Dir fehlt die erforderliche Geschicklichkeit.";
               5: "(nehme ", (ihn) x1, " zuerst)^";
               6: "Da ist kein Platz mehr auf ", (dem) x1, ".";
               7: "Gesagt, getan!";
               8: "Du legst ", (den) x1, " auf ", (den) second, ".";
           }
  Insert:  switch(n)
           {   1: "Du musst ", (den) x1,
                  " zuerst haben, bevor du ", (ihn) x1,
                  " in etwas anderes legen kannst.";
               2: print (Gdieser) x1, " ";
                  singplur(x1, "kann", "können");
                  " keine Dinge enthalten.";
               3: print_ret (gder) x1, " ", (isorare) x1, " geschlossen.";
               4: "Du solltest ", (ihn) x1, " zuerst wegnehmen.";
               5: "Du kannst nichts in sich selbst legen.";
               6: "(nehme ", (ihn) x1, " zuerst)^";
               7: "Da ist kein Platz mehr in ", (dem) x1, ".";
               8: "Gesagt, getan!";
               9: "Du legst ", (den) x1, " in ", (den) second, ".";
           }
#endif;

***********************************************************************

Alt:
  VagueGo: "Du solltest sagen, in welche Kompaßrichtung du gehen willst.";
Neu:
#ifdef R_NEU;
  VagueGo: "Du solltest sagen, in welche Kompassrichtung du gehen willst.";
#ifnot;
  VagueGo: "Du solltest sagen, in welche Kompaßrichtung du gehen willst.";
#endif;

***********************************************************************

Alt:
  Unlock:  switch(n)
           {   1: print (GDer) x1, " s";
                  if (x1 has pluralname) print "ehen";
                  else print "ieht";
                  " nicht aus wie etwas, das du aufschließen könntest.";
               2: print_ret (GEristSiesind) x1,
                  " ist im Augenblick aufgeschlossen.";
               3: print (GDer) x1, " sch";
                  if (x1 has pluralname) print "einen";
                  else print "eint";
                  " nicht ins Schloß zu passen.";
               4: "Du schließt ", (den) x1, " auf.";
           }
  Lock:    switch(n)
           {   1: print (GDer) x1, " s";
                  if (x1 has pluralname) print "ehen";
                  else print "ieht";
                  " nicht aus wie etwas, das du abschließen könntest.";
               2: print_ret (GEristSiesind) x1, " im Augenblick verschlossen.";
               3: "Zuerst solltest du ", (den) x1, " schließen.";
               4: print (GDer) noun, " sch";
                  if (noun has pluralname) print "einen";
                  else print "eint";
                  " nicht ins Schloß zu passen.";
               5: "Du verschließt ", (den) x1, ".";
           }
Neu:
#ifdef R_NEU;
  Unlock:  switch(n)
           {   1: print (GDer) x1, " s";
                  if (x1 has pluralname) print "ehen";
                  else print "ieht";
                  " nicht aus wie etwas, das du aufschließen könntest.";
               2: print_ret (GEristSiesind) x1,
                  " ist im Augenblick aufgeschlossen.";
               3: print (GDer) x1, " sch";
                  if (x1 has pluralname) print "einen";
                  else print "eint";
                  " nicht ins Schloss zu passen.";
               4: "Du schließt ", (den) x1, " auf.";
           }
  Lock:    switch(n)
           {   1: print (GDer) x1, " s";
                  if (x1 has pluralname) print "ehen";
                  else print "ieht";
                  " nicht aus wie etwas, das du abschließen könntest.";
               2: print_ret (GEristSiesind) x1, " im Augenblick verschlossen.";
               3: "Zuerst solltest du ", (den) x1, " schließen.";
               4: print (GDer) noun, " sch";
                  if (noun has pluralname) print "einen";
                  else print "eint";
                  " nicht ins Schloss zu passen.";
               5: "Du verschließt ", (den) x1, ".";
           }
#ifnot;
  Unlock:  switch(n)
           {   1: print (GDer) x1, " s";
                  if (x1 has pluralname) print "ehen";
                  else print "ieht";
                  " nicht aus wie etwas, das du aufschließen könntest.";
               2: print_ret (GEristSiesind) x1,
                  " ist im Augenblick aufgeschlossen.";
               3: print (GDer) x1, " sch";
                  if (x1 has pluralname) print "einen";
                  else print "eint";
                  " nicht ins Schloß zu passen.";
               4: "Du schließt ", (den) x1, " auf.";
           }
  Lock:    switch(n)
           {   1: print (GDer) x1, " s";
                  if (x1 has pluralname) print "ehen";
                  else print "ieht";
                  " nicht aus wie etwas, das du abschließen könntest.";
               2: print_ret (GEristSiesind) x1, " im Augenblick verschlossen.";
               3: "Zuerst solltest du ", (den) x1, " schließen.";
               4: print (GDer) noun, " sch";
                  if (noun has pluralname) print "einen";
                  else print "eint";
                  " nicht ins Schloß zu passen.";
               5: "Du verschließt ", (den) x1, ".";
           }
#endif;

***********************************************************************

Alt:
  Eat:     switch(n)
           {   1: print_ret (GEristSiesind) x1,
                  " völlig ungenießbar.";
               2: "Du ißt ", (den) x1, ". Nicht schlecht.";
           }
Neu:
#ifdef R_NEU;
  Eat:     switch(n)
           {   1: print_ret (GEristSiesind) x1,
                  " völlig ungenießbar.";
               2: "Du isst ", (den) x1, ". Nicht schlecht.";
           }
#ifnot;
  Eat:     switch(n)
           {   1: print_ret (GEristSiesind) x1,
                  " völlig ungenießbar.";
               2: "Du ißt ", (den) x1, ". Nicht schlecht.";
           }
#endif;

***********************************************************************

Alt:
               3: "Wenn du denkst, daß es vielleicht hilft.";
Neu:
               3: "Wenn du denkst, ", (string) C_DASS, "es vielleicht hilft.";

***********************************************************************

Alt:
  Sorry:          #ifdef DIALECT_US;
                  "Oh, don't apologize.";
                  #ifnot;
                  "Oh, macht nichts.";
                  #endif;
Neu:
  Sorry:          "Oh, macht nichts.";

***********************************************************************

Alt:
  Swing:          "Hier gibt es nichts, was schwingen k@:onnte.";
Neu:
  Swing:          "Hier gibt es nichts, was schwingen könnte.";

***********************************************************************

Alt:
  Climb:          "Ich denke nicht, daß damit viel erreicht werden könnte.";
Neu:
  Climb:          "Ich denke nicht, ", (string) C_DASS, "damit viel erreicht werden könnte.";

***********************************************************************

Alt:
         default: if (x1~=location)
                  {   if (x1 has supporter) print "^Auf "; else print "^In ";
                      print (dem) x1, " siehst Du hier ";
                  }
Neu:
         default: if (x1~=location)
                  {   if (x1 has supporter) print "^Auf "; else print "^In ";
                      print (dem) x1, " siehst du hier ";
                  }

***********************************************************************
* tgerman.h
***********************************************************************

Alt:
[DekliniereAllSub x;  ! manly to suppress warnings about articles not used
Neu:
[DekliniereAllSub x;  ! mainly to suppress warnings about articles not used

***********************************************************************
***********************************************************************
***********************************************************************
* Deutsche Inform Library: Änderungsliste 09 (20.05.2002)
***********************************************************************
***********************************************************************
***********************************************************************

Vorschläge von: Christoph Oleschinski, Max Kalus, Michael Kleinhenz

***********************************************************************
* german.h
***********************************************************************

Alt:
               4: print "Du solltest zuerst ";
                  if (x1 has supporter) print "von "; else print "aus ";
                  print_ret (dem) x1, " nehmen.";
Neu:
               4: print "Du solltest zuerst ";
                  if (x1 has supporter) print "von "; else print "aus ";
                  print_ret (dem) x1, " kommen.";

***********************************************************************

Alt:
Constant ME1__WD      = 'mich';
Constant ME2__WD      = 'mir';
Constant ME3__WD      = 'ich';
Neu:
Constant ME1__WD      = 'mich';
Constant ME2__WD      = 'dich';
Constant ME3__WD      = 'mir';

***********************************************************************

Alt:
Include "TGerman";
Neu:
Include "tgerman";

***********************************************************************
***********************************************************************
***********************************************************************
* Deutsche Inform Library: Änderungsliste 08 (14.03.2002)
***********************************************************************
***********************************************************************
***********************************************************************

Vorschläge von: Kai Roos, Martin Oehm, Max Kalus, Frank Borger

***********************************************************************
* german.h
***********************************************************************

Alt:
              51: "(Seit etwas sehr Dramatisches passiert ist, wurde deine Liste von
                   Verben gekürzt.)";
Neu:
              51: "(Da etwas sehr Dramatisches passiert ist, wurde deine Liste von
                   Verben gekürzt.)";

***********************************************************************

Alt:
CompassDirection -> nw_obj "Norwesten"
        with name 'nw' 'nordwest' 'nordwesten' 'nordwestlich', dekl 1, door_dir nw_to, has male;
Neu:
CompassDirection -> nw_obj "Nordwesten"
        with name 'nw' 'nordwest' 'nordwesten' 'nordwestlich', dekl 1, door_dir nw_to, has male;

***********************************************************************

Alt:
17: print "siebenzehn";
Neu:
17: print "siebzehn";

***********************************************************************

Alt:
             6: print "sechtzig";
             7: print "siebenzig";
Neu:
             6: print "sechzig";
             7: print "siebzig";

***********************************************************************

Alt:
Constant FORMER__TX   = "Dein früheres ich";
Neu:
Constant FORMER__TX   = "dein früheres ich";

***********************************************************************

Alt:
             14: "[Tschuldigung, das kann nicht korrigiert werden.]";
Neu:
             14: "[Entschuldigung, das kann nicht korrigiert werden.]";

***********************************************************************

Alt:
               2: "Du entdeckst an ", (dem) x1, " nichts Spezielles.";
Neu:
               2: if (x1 == u_obj or d_obj) "Dort ", (name) x1, " entdeckst du nichts Spezielles.";
                  print "Du entdeckst ";
                  if (x1 ofclass CompassDirection) print "im ", (name) x1;
               	  else print "an ", (dem) x1;
               	  " nichts Spezielles.";

***********************************************************************

Alt:
  Blow:           "Du kannst ", (dieses) x1, " nicht sinnvoll
                   blasen.";
Neu:
  Blow:           "Du kannst ", (diesen) x1, " nicht sinnvoll blasen.";

***********************************************************************

Alt:
               6: print (GDer) noun, " ";
                  singplur(noun, "scheint", "scheinen");
                  "zu ", (dem) x1, "zu gehören.";
               7: print (GDer) noun, " ";
                  singplur(noun, "scheint", "scheinen");
                  " ein Teil von ", (dem) x1, "zu sein.";
Neu:
               6: print (GDer) noun, " ";
                  singplur(noun, "scheint", "scheinen");
                  " zu ", (dem) x1, " zu gehören.";
               7: print (GDer) noun, " ";
                  singplur(noun, "scheint", "scheinen");
                  " ein Teil von ", (dem) x1, " zu sein.";

***********************************************************************

Alt:
  Taste:          "Du fühlst nichts Unerwartetes.";
Neu:
  Taste:          "Du schmeckst nichts Unerwartetes.";

***********************************************************************
* germang.h
***********************************************************************

Alt:
Verb meta 'superkurz' 'kurz' 'superkurzer' 'kurzer'
                *                                -> LMode3
                * 'modus'/'beschreibungen'	 -> LMode3;
Verb meta 'ausfuehrlich' 'lang' 'ausfuehrlicher' 'langer'
                *                                -> LMode2
                * 'modus'/'beschreibungen'	 -> LMode2;
Verb meta 'normal' 'normaler'
                *                                -> LMode1
                * 'modus'/'beschreibungen'	 -> LMode1;
Verb meta 'schilder'
	* 'sehr' 'knapp'/'kurz'				-> LMode3
	* 'kurz' 'und' 'knapp'				-> LMode1
	* 'knapp'/'normal'/'kurz'			-> LMode1
	* 'wortreich'/'ausfuehrlich'/'lang'		-> LMode2;
Neu:
Verb meta 'knapp' 'normal' * -> LMode1;
Verb meta 'ausfuehrlich' 'lang' * -> LMode2;
Verb meta 'superknapp' 'superkurz' 'kurz' * -> LMode3;

***********************************************************************

Alt:
Verb 'tu' 'leg' 'platzier'
                * multiheld                       -> Drop
                * worn 'ab'                       -> Disrobe
                * multiheld xhinweg		  -> Drop
                * xhinweg multiheld 		  -> Drop
                * multiheld 'hin'/'weg'/'ab'      -> Drop
                * 'auf'/'in' noun		  -> Enter
                * 'dich'/'mich' 'auf'/'in' noun	  -> Enter
                * 'dich'/'mich' 'auf'/'in' noun 'nieder'  -> Enter
                * multiexcept 'in' noun           -> Insert
                * multiexcept 'in' noun hinein    -> Insert
                * multiexcept xhinein		  -> Insert
                * multiexcept 'auf' noun          -> PutOn
                * held 'an'/'um'                  -> Wear;
Neu:
Verb 'tu' 'platzier'
                * multiheld                       -> Drop
                * multiheld 'weg'                 -> Drop
                * 'dich'/'mich' 'auf'/'in' noun	  -> Enter
                * 'dich'/'mich' 'auf'/'in' noun 'nieder'  -> Enter
		* 'dich'/'mich' xhinein		  -> Enter
                * multiexcept 'in' noun           -> Insert
                * multiexcept 'in' noun hinein    -> Insert
                * multiexcept xhinein		  -> Insert
                * multiexcept 'auf' noun          -> PutOn;

***********************************************************************

Alt:
Verb 'sitz' 'lieg' 'setz'
                * 'auf' noun                     -> Enter
                * 'in' noun                      -> Enter
                * xhinein			 -> Enter;
Neu:
Verb 'setz' 'leg'
                * multiheld                       -> Drop
                * worn 'ab'                       -> Disrobe
                * multiheld 'ab'/'hin'/'weg'      -> Drop
                * xhinweg multiheld 		  -> Drop
                * multiheld xhinweg		  -> Drop
                * 'dich'/'mich' 'auf'/'in' noun	  -> Enter
                * 'dich'/'mich' 'auf'/'in' noun 'nieder'  -> Enter
                * 'dich'/'mich' xhinein		  -> Enter
                * multiexcept 'in' noun           -> Insert
                * multiexcept 'in' noun hinein    -> Insert
                * multiexcept xhinein		  -> Insert
                * multiexcept 'auf' noun          -> PutOn
                * xhinein			  -> Enter
                * held 'an'/'um'                  -> Wear;

Verb 'sitz' 'lieg'
                * 'auf' noun                      -> Enter
                * 'in' noun                       -> Enter;

***********************************************************************

Alt:
Verb 'zeig' 'praesentier' 'fuehr'
	* creature held					-> Show reverse
	* held creature 				-> Show
	* creature held 'vor'				-> Show reverse
	* held creature 'vor'				-> Show;
Neu:
Verb 'zeig' 'praesentier' 'fuehr'
	* creature held					-> Show reverse
	* held creature 				-> Show
	* creature held 'vor'				-> Show reverse
	* held creature 'vor'				-> Show
	* 'inventar'/'besitz'/'eigentum'		-> Inv;

***********************************************************************

Alt:
Verb meta 'skript' 'script' 'transktript' 'transcript' 'mitschrift'
Neu:
Verb meta 'skript' 'script' 'transkript' 'transcript' 'mitschrift'

***********************************************************************

Alt:
Verb  'tadel' 'verfluch' 'verdamm' 'verdammt' 'mist' 'jammer' 'winsel' 'schmipf'
Neu:
Verb  'tadel' 'verfluch' 'verdamm' 'verdammt' 'mist' 'jammer' 'winsel' 'schimpf'

***********************************************************************

Alt:
Verb 'kletter' 'klettr' 'steig' 'erklimm'
Neu:
Verb 'kletter' 'klettr' 'steig' 'erklimm' 'erkletter'

***********************************************************************
* german.h
***********************************************************************

Alt:
#ifdef TARGET_ZCODE;
!Eingefügt von Max Kalus
!ändert alle "?", "!" und Anführungszeichen in Leerzeichen
   for (x=2:x<2+buffer->1:x++)
   {   
      if (buffer->x == '?' or '!' or '"' or 39) buffer->x = ' ';
   }
Neu:
#ifdef TARGET_ZCODE;
#ifdef NO_PUNCTUATION;
!Eingefügt von Max Kalus
!ändert alle "?", "!" und Anführungszeichen in Leerzeichen
   for (x=2:x<2+buffer->1:x++)
   {   
      if (buffer->x == '?' or '!' or '"' or 39) buffer->x = ' ';
   }
#endif; ! NO_PUNCTUATION

***********************************************************************
***********************************************************************
***********************************************************************
* Deutsche Inform Library: Änderungsliste 07 (04.03.2002)
***********************************************************************
***********************************************************************
***********************************************************************

Vorschläge von: Max Kalus

***********************************************************************
* german.h
***********************************************************************

Alt:
CompassDirection -> s_obj "Sueden"
        with name 's//' 'sued' 'sueden' 'suedlich',    dekl 1, door_dir s_to, has male;
CompassDirection -> e_obj "Osten"
        with name 'o//' 'e//' 'ost' 'osten' 'oestlich',     dekl 1, door_dir e_to, has male;
CompassDirection -> w_obj "Westen"
        with name 'w//' 'west' 'westen' 'westlich',     dekl 1, door_dir w_to, has male;
CompassDirection -> ne_obj "Nordosten"
        with name 'no' 'ne' 'nordost' 'nordosten' 'nordoestlich', dekl 1, door_dir ne_to, has male;
CompassDirection -> nw_obj "Norwesten"
        with name 'nw' 'nordwest' 'nordwesten' 'nordwestlich', dekl 1, door_dir nw_to, has male;
CompassDirection -> se_obj "Suedosten"
        with name 'so' 'se' 'suedost' 'suedosten' 'suedoestlich', dekl 1, door_dir se_to, has male;
CompassDirection -> sw_obj "Suedwesten"
        with name 'sw' 'suedwesten' 'suedwestlich', dekl 1, door_dir sw_to, has male;
Neu:
CompassDirection -> s_obj "Süden"
        with name 's//' 'sued' 'sueden' 'suedlich',    dekl 1, door_dir s_to, has male;
CompassDirection -> e_obj "Osten"
        with name 'o//' 'e//' 'ost' 'osten' 'oestlich',     dekl 1, door_dir e_to, has male;
CompassDirection -> w_obj "Westen"
        with name 'w//' 'west' 'westen' 'westlich',     dekl 1, door_dir w_to, has male;
CompassDirection -> ne_obj "Nordosten"
        with name 'no' 'ne' 'nordost' 'nordosten' 'nordoestlich', dekl 1, door_dir ne_to, has male;
CompassDirection -> nw_obj "Norwesten"
        with name 'nw' 'nordwest' 'nordwesten' 'nordwestlich', dekl 1, door_dir nw_to, has male;
CompassDirection -> se_obj "Südosten"
        with name 'so' 'se' 'suedost' 'suedosten' 'suedoestlich', dekl 1, door_dir se_to, has male;
CompassDirection -> sw_obj "Südwesten"
        with name 'sw' 'suedwesten' 'suedwestlich', dekl 1, door_dir sw_to, has male;

***********************************************************************

Alt:
  Unlock:  switch(n)
           {   1: print (GDer) x1, " s";
                  if (x1 has pluralname) print "ehen";
                  else print "ieht";
                  " nicht aus wie etwas, das du aufschliessen könntest.";
Neu:
  Unlock:  switch(n)
           {   1: print (GDer) x1, " s";
                  if (x1 has pluralname) print "ehen";
                  else print "ieht";
                  " nicht aus wie etwas, das du aufschlie@ssen könntest.";

***********************************************************************

Alt:
  Close:   switch(n)
           {   1: print_ret (GDen) x1,
                  " kannst du nicht schliessen.";
Neu:
  Close:   switch(n)
           {   1: print_ret (GDen) x1,
                  " kannst du nicht schlie@ssen.";

***********************************************************************
***********************************************************************
***********************************************************************
* Deutsche Inform Library: Änderungsliste 06 (03.03.2002)
***********************************************************************
***********************************************************************
***********************************************************************

Vorschläge von: Max Kalus und anderen, die diese Fehler bemerkt hatten

***********************************************************************
* german.h
***********************************************************************

Alt:
              11: print (GDer) x1, " steh", (endT) x1,
                  " unbeweglich da. Du bewegst ", (ihn) x1, " keinen Millimeter weit.";
Neu:
              11: print_ret (GDer) x1, " steh", (endT) x1,
                  " unbeweglich da. Du bewegst ", (ihn) x1, " keinen Millimeter weit.";

***********************************************************************

Alt:
 FullScore: switch(n)
           {   1: if (deadflag) print "Der Punktestand war ";
                  else          print "Der Punktestand ist ";
                  "folgendermassen zusammengesetzt:^";
Neu:
 FullScore: switch(n)
           {   1: if (deadflag) print "Der Punktestand war ";
                  else          print "Der Punktestand ist ";
                  "folgenderma@ssen zusammengesetzt:^";

***********************************************************************

Alt:
               3: print "Du gelangst ";
                  if (x1 has supporter) print "runter vom "; 
                  else print "hinaus aus "; print_ret (dem) x1, ".";
Neu:
               3: print "Du gelangst ";
                  if (x1 has supporter) print "runter von "; 
                  else print "hinaus aus "; print_ret (dem) x1, ".";

***********************************************************************
* tgerman.h
***********************************************************************

Alt:
[endEt obj;	!"et" oder "en" fuer Endungen schwacher Verben
  if(obj has pluralname) print "en";
  else print "t";
];
Neu:
[endEt obj;	!"et" oder "en" fuer Endungen schwacher Verben
  if(obj has pluralname) print "en";
  else print "et";
];

***********************************************************************
***********************************************************************
***********************************************************************
* Deutsche Inform Library: Änderungsliste 05 (07.02.2002)
***********************************************************************
***********************************************************************
***********************************************************************

Vorschläge von: Max Kalus und anderen, die diesen Fehler bemerkt hatten

***********************************************************************
* german.h
***********************************************************************

Alt:
               2: print (GDer) noun, " schein", (endT) noun, " verschlossen zu sein.";
Neu:
               2: print_ret (GDer) noun, " schein", (endT) noun, " verschlossen zu sein.";

***********************************************************************

Alt:
           {   1: print_ret (GEr) x1, " beweg", endT(x1),
                  " sich keinen Millimeter.";
Neu:
           {   1: print_ret (GEr) x1, " beweg", (endT) x1,
                  " sich keinen Millimeter.";

***********************************************************************
***********************************************************************
***********************************************************************
* Deutsche Inform Library: Änderungsliste 04 (18.01.2002)
***********************************************************************
***********************************************************************
***********************************************************************

Vorschläge von: Kai Roos

***********************************************************************
* german.h
***********************************************************************

Alt:
           switch(n)
           {   1: "(Nur die ersten sechzehn Objekte werden beachtet)^";
               2: "Nichts zu tun!";
               3: print " Du bist gestorben ";
               4: print " Du hast gewonnen ";
               5: print "^Möchtest du einen NEUSTART, ein vorher 
                          gespeichertes Spiel LADEN";
                  if (TASKS_PROVIDED==0)
                      print ", die VOLLE Punktzahl des Spiels sehen";
                  if (deadflag==2 && AMUSING_PROVIDED==0)
                      print ", einige Vorschläge sehen für LUSTIGE 
                      Sachen";
                  if (DEATH_MENTION_UNDO==0)
                      print ", den letzten Zug R@:UCKG@:ANGIG machen";
                  " oder das ENDE?";
               6: "[Dein Interpreter kennt kein ~rückgängig~.  Tschuldigung!]";
#ifdef TARGET_ZCODE;
               7: "Der letzte Zug konnte nicht ~rückgängig~ gemacht werden.
               		[Nicht alle Interpreter haben diese Funktion.]";
#ifnot; ! TARGET_GLULX
               7: "[Du kannst nichts mehr ~rückgängig~ machen.]";
#endif; ! TARGET_
               8: "Bitte gib eine der obigen Antworten.";
               9: "^Es ist jetzt stockdunkel hier!";
              10: "Wie bitte?";
              11: "[Du kannst mit ~rückgängig~ nichts ungeschehen machen, was
                    du gar nicht getan hast!]";
              12: "[~Rückgängig~ ist nicht zweimal nacheinander möglich. Tut mir
                    leid!]";
              13: "[Letzten Zug ungeschehen gemacht.]";
              14: "Tschuldigung, das kann nicht korrigiert werden.";
              15: "Denke einfach nichts davon.";
              16: "~Oops~ kann nur ein einzelnes Wort korrigieren.";
              17: "Es ist stockdunkel, und du siehst rein gar nichts.";
              18: print "dich selbst";
              19: "Du siehst wunderschön aus, wie immer.";           
              20: "Um einen Befehl wie ~Frosch, spring~ zu wiederholen, sag nur ~nochmal~,
                    nicht ~Frosch, nochmal~.";
              21: "Das kannst du wohl kaum wiederholen.";
              22: "Du kannst nicht mit einem Komma beginnen.";
              23: "Gesprächspartner nicht gefunden!";
              24: "Du kannst mit ", (dem) x1, " nicht sprechen.";
              25: "Um mit jemandem zu sprechen, versuche es mit ~person, hallo~ oder
                    so was ähnlichem.";
              26: if (not_holding == player) "(nehme zuerst dich selbst)"; !Änderung v. Max Kalus
                  "(nehme zuerst ", (den) not_holding, ")";
              27: "Diesen Befehl verstehe ich nicht.";
              28: print "Wahrscheinlich meinst du: ";
              29: "Diese Zahl verstehe ich nicht.";
              30: "Du kannst nichts dergleichen sehen.";
              31: "Es sieht so aus, als hättest du zu wenig gesagt!";
              32: "Du trägst ", (den) x1, " nicht bei dir!";
              33: "Mit diesem Verb kannst du nicht mehrere Objekte
                   ansprechen.";
              34: "Du kannst pro Zeile nur einmal mehrere Objekte
                   ansprechen.";
              35: "Ich verstehe nicht, was mit ~", (address) pronoun_word,
                  "~ gemeint ist.";
              36: "Du hast etwas ausgeschlossen, was ohnehin nicht inbegriffen war.";
              37: "Das kannst du nur mit belebten Objekten machen.";
              38: #ifdef DIALECT_US;
                  "That's not a verb I recognize.";
                  #ifnot;
                  "Dieses Verb verstehe ich nicht.";
                  #endif;
              39: "Ein flüchtiger Blick auf ", (den) x1, " sagt dir, 
                    da@ss ", (er) x1, " für das Spiel nicht wichtig ", (isorare) x1, ".";
              40: "Im Augenblick ist ~", (address) pronoun_word,
                  "~ (", (der) pronoun_obj, ") nicht zu sehen.";
              41: "Ich habe nicht verstanden, wie das endete.";
              42: if (x1==0) print "Kein";
                  else print "Nur ", (number) x1;
                  print " davon ";
                  if (x1==1) print "ist"; else print "sind";
                  " ansprechbar.";
              43: "Nichts zu tun!";
              44: "Keiner der Gegenstände hier will diesem Befehl Folge leisten!";
              45: print "Wen meinst du, ";
              46: print "Was meinst du, ";
              47: "Du kannst dich damit nur auf einen einzigen Gegenstand beziehen.
                   Gib bitte an, welchen du meinst!";
              48: print "Wen willst du ansprechen?^";
              49: print "Du wolltest vermutlich folgendes: ";
                  if (actor~=player) print " ", (der) actor; print "~";
                  PrintCommand(); print "...~ - aber was, wie, womit?^";
              50: print "Dein Punktestand hat sich um ";
                  if (x1==1) print "einen Punkt ";
                    else print (number) x1, " Punkte ";
                  if (x1 > 0) print "erhöht"; else 
                      { x1 = -x1; print "verringert"; }
              51: "(Seit etwas sehr dramatisches passiert ist, wurde deine Liste von
                   Verben gekürzt.)";
              52: "^Tippe eine Zahl von 1 bis ", x1,
                  ", 0 für eine Neuanzeige oder drücke ENTER.";
              53: "^[Bitte drücke die Leertaste.]";
              54: print "^Deine Antwort: ";
           }
Neu:
  Miscellany:
           switch(n)
           {   1: "(Nur die ersten sechzehn Objekte werden beachtet)^";
               2: "Nichts zu tun!";
               3: print " Du bist gestorben ";
               4: print " Du hast gewonnen ";
               5: print "^Möchtest du einen NEUSTART, ein vorher 
                          gespeichertes Spiel LADEN";
                  if (TASKS_PROVIDED==0)
                      print ", die VOLLE Punktzahl des Spiels sehen";
                  if (deadflag==2 && AMUSING_PROVIDED==0)
                      print ", einige Vorschläge sehen für LUSTIGE 
                      Sachen";
                  if (DEATH_MENTION_UNDO==0)
                      print ", den letzten Zug R@:UCKG@:ANGIG machen";
                  " oder das ENDE?";
               6: "[Dein Interpreter kennt kein ~rückgängig~.  Tut mir leid!]";
#ifdef TARGET_ZCODE;
               7: "[Der letzte Zug konnte nicht ~rückgängig~ gemacht werden.
               		Nicht alle Interpreter haben diese Funktion.]";
#ifnot; ! TARGET_GLULX
               7: "[Du kannst nichts mehr ~rückgängig~ machen.]";
#endif; ! TARGET_
               8: "Bitte gib eine der obigen Antworten.";
               9: "^Es ist jetzt stockdunkel hier!";
              10: "Wie bitte?";
              11: "[Du kannst mit ~rückgängig~ nichts ungeschehen machen, was
                    du gar nicht getan hast!]";
              12: "[~Rückgängig~ ist nicht zweimal nacheinander möglich. Tut mir
                    leid!]";
              13: "[Letzten Zug ungeschehen gemacht.]";
              14: "[Tschuldigung, das kann nicht korrigiert werden.]";
              15: "[Denke einfach nichts davon.]";
              16: "[~Oops~ kann nur ein einzelnes Wort korrigieren.]";
              17: "Es ist stockdunkel, und du siehst rein gar nichts.";
              18: print "dich selbst";
              19: "Du siehst wunderschön aus, wie immer.";           
              20: "[Um einen Befehl wie ~Frosch, spring~ zu wiederholen, sag nur ~nochmal~,
                    nicht ~Frosch, nochmal~.]";
              21: "[Das kannst du wohl kaum wiederholen.]";
              22: "[Du kannst nicht mit einem Komma beginnen.]";
              23: "Gesprächspartner nicht gefunden!";
              24: "Du kannst mit ", (dem) x1, " nicht sprechen.";
              25: "[Um mit jemandem zu sprechen, versuche es mit ~person, hallo~ oder
                    so was ähnlichem.]";
              26: if (not_holding == player) "(nehme zuerst dich selbst)"; !Änderung v. Max Kalus
                  "(nehme zuerst ", (den) not_holding, ")";
              27: "Diesen Befehl verstehe ich nicht.";
              28: print "Wahrscheinlich meinst du: ";
              29: "Diese Zahl verstehe ich nicht.";
              30: "Du kannst nichts dergleichen sehen.";
              31: "Es sieht so aus, als hättest du zu wenig gesagt!";
              32: "Du trägst ", (den) x1, " nicht bei dir!";
              33: "[Mit diesem Verb kannst du nicht mehrere Objekte
                   ansprechen.]";
              34: "[Du kannst pro Zeile nur einmal mehrere Objekte
                   ansprechen.]";
              35: "Ich verstehe nicht, was mit ~", (address) pronoun_word,
                  "~ gemeint ist.";
              36: "Du hast etwas ausgeschlossen, was ohnehin nicht inbegriffen war.";
              37: "Das kannst du nur mit belebten Objekten machen.";
              38: #ifdef DIALECT_US;
                  "That's not a verb I recognize.";
                  #ifnot;
                  "Dieses Verb verstehe ich nicht.";
                  #endif;
              39: "Ein flüchtiger Blick auf ", (den) x1, " sagt dir, 
                    da@ss ", (er) x1, " für das Spiel nicht wichtig ", (isorare) x1, ".";
              40: "Im Augenblick ist ~", (address) pronoun_word,
                  "~ (", (der) pronoun_obj, ") nicht zu sehen.";
              41: "[Ich habe nicht verstanden, wie das endete.]";
              42: if (x1==0) print "Kein";
                  else print "Nur ", (number) x1;
                  print " davon ";
                  if (x1==1) print "ist"; else print "sind";
                  " ansprechbar.";
              43: "Nichts zu tun!";
              44: "Keiner der Gegenstände hier will diesem Befehl Folge leisten!";
              45: print "Wen meinst du, ";
              46: print "Was meinst du, ";
              47: "Du kannst dich damit nur auf einen einzigen Gegenstand beziehen.
                   Gib bitte an, welchen du meinst!";
              48: print "Wen willst du ansprechen?^";
              49: print "Du wolltest vermutlich folgendes: ";
                  if (actor~=player) print " ", (der) actor; print "~";
                  PrintCommand(); print "...~ - aber was, wie, womit?^";
              50: print "Dein Punktestand hat sich um ";
                  if (x1==1) print "einen Punkt ";
                    else print (number) x1, " Punkte ";
                  if (x1 > 0) print "erhöht"; else 
                      { x1 = -x1; print "verringert"; }
              51: "(Seit etwas sehr Dramatisches passiert ist, wurde deine Liste von
                   Verben gekürzt.)";
              52: "^Tippe eine Zahl von 1 bis ", x1,
                  ", 0 für eine Neuanzeige oder drücke ENTER.";
              53: "^[Bitte drücke die Leertaste.]";
              54: print "^Deine Antwort: ";
           }

***********************************************************************
* germang.h
***********************************************************************

Alt:
Verb 'geh' 'lauf' 'renn' 'wander' 'fluechte' 'flieh' 'schreite' 'spazier'
                *                                -> VagueGo
		* 'umher'/'weg'/'fort'		 -> VagueGo
                * 'in'/'durch'/'auf' noun        -> Enter
                * noun=ADirection	         -> Go
                * 'nach' noun=ADirection         -> Go
		* 'nach' 'draussen'		 -> Exit
                * noun                           -> Enter
                * 'raus'/'hinaus'/'heraus'       -> Exit
                * 'rein'/'hinein'/'herein'       -> GoIn;
Neu:
Verb 'geh' 'lauf' 'renn' 'wander' 'fluechte' 'flieh' 'schreite' 'spazier'
                *                                -> VagueGo
		* 'umher'/'weg'/'fort'		 -> VagueGo
                * 'in'/'durch' noun              -> Enter
                * 'auf' noun                     -> Climb
                * noun=ADirection	         -> Go
                * 'nach' noun=ADirection         -> Go
		* 'nach' 'draussen'		 -> Exit
                * noun                           -> Enter
                * 'raus'/'hinaus'/'heraus'       -> Exit
                * 'rein'/'hinein'/'herein'       -> GoIn;

***********************************************************************

Alt:
Verb 'fuell'
                * noun                           -> Fill
                * noun 'auf'                     -> Fill
                * noun 'in' noun                 -> EmptyT;
Neu:
Verb 'fuell'
                * noun                           -> Fill
                * noun 'auf'                     -> Fill
                * noun 'in' noun                 -> EmptyT
                * noun 'mit' noun                -> EmptyT reverse;

***********************************************************************

Kommentar bei 'streif' * 'ab' auf Wunsch gelöscht.

***********************************************************************
***********************************************************************
***********************************************************************
* Deutsche Inform Library: Änderungsliste 03 (09.12.2001)
***********************************************************************
***********************************************************************
***********************************************************************

Vorschläge von: Max Kalus

***********************************************************************
* german.h
***********************************************************************

CompassDirections:
Hinzufügen zusätzlicher Namen:
e_obj (...) name 'e'
ne_obj (...) name 'se'
se_obj (...) name 'ne'
(damit funktionieren englische Richtungsangaben wieder...)

***********************************************************************

Ersetze:
if (buffer->verbend == 'e') buffer->verbend = ' ';
durch:
if (buffer->verbend == 'e' && (parse->((x+1)*4+4) > 2)) buffer->verbend = ' ';
(Behebt das Problem, daß se in s konvertiert wird)


***********************************************************************
***********************************************************************
***********************************************************************
* Deutsche Inform Library: Änderungsliste 02 (22.11.2001)
***********************************************************************
***********************************************************************
***********************************************************************

Vorschläge von: Sophie Fruehling, Kai Roos und Max Kalus

Änderungen der GLULX-Teile auf den neuesten Stand der GLULX-Library -
einige Fehlerverbesserungen, so daß weniger Fehler auftreten sollten
(der Bi-Plattform-Compiler unterstützt im Moment noch keine Akzent-
Codes wie @ss für ß, so daß die GLULX-Unterstützung sowieso eher
theoretischer Natur ist...).

***********************************************************************
* german.h
***********************************************************************

Zweite Zeile geändert in:
Inform Language Definition File: German 011122

***********************************************************************
Ersetze:
Class  CompassDirection
  with article number 0, dekl 7,
  	before [;
  		LookUnder: "Die Wand ist am Boden festgemacht.";
  	],
  has  scenery female;
durch:
Class  CompassDirection
  with article 0, number 0, dekl 7,
  	before [;
  		LookUnder: "Die Wand ist am Boden festgemacht.";
  	],
  has  scenery female;

***********************************************************************

Ersetze:
6: "[Dein Interpreter kennt kein ~rückgängig~.  Tschuldigung!]";
durch:
6: "[Dein Interpreter kennt kein ~rückgängig~.  Tut mir leid!]";

***********************************************************************

Ersetze:
51: "(Seit etwas sehr dramatisches passiert ist, wurde deine Liste von
durch:
51: "(Seit etwas sehr Dramatisches passiert ist, wurde deine Liste von

***********************************************************************

Inv:
Ersetze:
1: "Du trägst nichts mit dir.";
durch:
1: "Du trägst nichts bei dir.";

***********************************************************************

FullScore:
Ersetze:
2: "diverse Dinge findend";
3: "verschiedenste Orte besuchend";
durch:
2: "für das Finden diverser Dinge";
3: "für den Besuch verschiedenster Orte";

***********************************************************************
* germang.h
***********************************************************************

nach Verb meta 'deklinier'...;
#ifdef TARGET_GLULX;
Verb meta 'glklist'
                *                                -> Glklist;
#endif; ! TARGET_;

nach #Stub ChooseObjects   2;
#ifdef TARGET_GLULX;
#Stub IdentifyGlkObject 4;
#Stub HandleGlkEvent  2;
#Stub InitGlkWindow   1;
#endif; ! TARGET_GLULX

***********************************************************************
* linklpa.h
***********************************************************************

ganze Datei durch GLULX-Version ausgetauscht

***********************************************************************
* parserm.h
***********************************************************************

Ersetze:
Constant GG_STATUSWIN_SIZE  1; !### make overridable
durch:
Global gg_statuswin_size = 1;

***********************************************************************

Ersetze GLULX-Tokenise__-Routine
mit Std.-GLULX-Version

***********************************************************************

Ersetze GLULX-Routinen Keychar und Keyboardprimitive
mit Std.-GLULX-Versionen

***********************************************************************

Ersetze:
i = ((ad-->0) ~= $70);
durch:
i = (((ad-->0)->0) ~= $70);

***********************************************************************

Ersetze:
StatusLineHeight(GG_STATUSWIN_SIZE);
durch:
StatusLineHeight(gg_statuswin_size);

***********************************************************************

Ersetze GLULX-Routinen Box__Routine, GGInitialise, GGRecoverObjects
mit Std.-GLULX-Versionen

***********************************************************************

Füge neue Funktion aus Std.-GLULX-Library hinzu:
ChangeAnyToCString

***********************************************************************

Nach der Funktion UnsignedCompare
NITFOL_HOOKS aus Std.-GLULX-Library hinzu

***********************************************************************
* verblibm.h
***********************************************************************

Ersetze GLULX-Routinen VersionSub
mit Std.-GLULX-Versionen

***********************************************************************

Füge neue Funktion aus Std.-GLULX-Library hinzu:
GlkListSub (nach ScopeSub)

***********************************************************************

Ersetze XObj durch:
!Anpassung an deutsche Lib:
[ XObj obj f;
  if (obj provides dekl) {
      if (parent(obj) == 0) print (_er) obj; else print (ein) obj;
  } else {
       print (name) obj;
  }
  print " (", obj, ") ";
  if (f==1 && parent(obj) ~= 0)
      print "(in ", (name) parent(obj), " ", parent(obj), ")";
  new_line;
  if (child(obj)==0) rtrue;
  if (obj == Class)
      WriteListFrom(child(obj),
      NOARTICLE_BIT + INDENT_BIT + NEWLINE_BIT + ALWAYS_BIT, 1);
  else {
      if (obj == Compass)
          WriteListFrom(child(obj),
          NOARTICLE_BIT + FULLINV_BIT + INDENT_BIT + NEWLINE_BIT + ALWAYS_BIT, 1);
      else
          WriteListFrom(child(obj),
          FULLINV_BIT + INDENT_BIT + NEWLINE_BIT + ALWAYS_BIT, 1);
   }
];

***********************************************************************
***********************************************************************
***********************************************************************
* Deutsche Inform Library: Änderungsliste 01 (10.11.2001)
***********************************************************************
***********************************************************************
***********************************************************************

Vorschläge von: Kai Roos, Florian Edlbauer, Martin Oehm, Ralf Siemon
                Christoph Oleschinski, Miron Schmidt und Max Kalus

Vielen Dank!

***********************************************************************
* tgermang.h
***********************************************************************

nach:
! german replacements for CTheyreorThats
! --------------------------------------

[GEristSiesind obj;
  print (Ger) obj, " "; isorare(obj);
];

einfügen:
! Einige Funktionen, um das Leben zu vereinfachen - Dank an Martin Oehm
[ist obj;
  isorare(obj);
];

[hat obj;
  if(obj has pluralname) print "haben";
  else print "hat";
];

[wird obj;
  if(obj has pluralname) print "werden";
  else print "wird";
];

[endT obj;	!"t" oder "en" fuer Endungen schwacher Verben
  if(obj has pluralname) print "en";
  else print "t";
];

[endEt obj;	!"et" oder "en" fuer Endungen schwacher Verben
  if(obj has pluralname) print "en";
  else print "t";
];

!gibt sing oder plur fuer unregelmaessige Verben
!aus: singplur(noun, "kann", "koennen")
[singplur obj sing plur;
  if(obj has pluralname) print (string) plur;
  else print (string) sing;
];


***********************************************************************
* germang.h
***********************************************************************


Alt:
Verb 'streif'   * noun 'ab'                       -> Take;
Neu:
Verb 'streif'   * noun 'ab'                       -> Disrobe; !geändert v. Kai Roos

***********************************************************************

Alt:
Verb 'frag' 'befrag'
		* creature			 -> Ask
                * creature 'ueber' topic         -> Ask
                * creature 'nach' noun           -> AskFor
		* creature 'nach'/'ueber'/'ob' topic -> Ask;
Neu:
Verb 'frag' 'befrag'
		* creature			 -> Ask
                * creature 'ueber' topic         -> Ask
                * creature 'nach'/'um' noun      -> AskFor
		* creature 'nach'/'ueber'/'ob' topic -> Ask;

***********************************************************************

Alt:
Verb 'steck'
	* multiexcept 'in' noun hinein			-> Insert
	* multiexcept 'in' noun				-> Insert
	* multiexcept xhinein				-> Insert
	* multiexcept 'auf' noun			-> PutOn
	* clothing 'an'					-> Wear
	* 'an' clothing					-> Wear
	* noun 'an'					-> Burn
	* noun 'mit' held 'an'				-> Burn
	* 'mit' held noun 'an'				-> Burn;
Neu:
Verb 'steck'
	* multiexcept 'in' noun hinein			-> Insert
	* multiexcept 'in' noun				-> Insert
	* multiexcept 'ein'				-> Take
	* multiexcept xhinein				-> Insert
	* multiexcept 'auf' noun			-> PutOn
	* clothing 'an'					-> Wear
	* 'an' clothing					-> Wear
	* noun 'an'					-> Burn
	* noun 'mit' held 'an'				-> Burn
	* 'mit' held noun 'an'				-> Burn;

***********************************************************************

Alt:
Verb 'schliess' 'verschliess' 'sperr' 'verriegel' 'verriegl'
                * noun                           -> Close
                * noun 'mit' held                -> Lock
                * noun 'mit' held 'ab'           -> Lock
                * noun 'ab' 'mit' held           -> Lock
                * noun 'ab'                      -> Lock
                * noun 'mit' held 'auf'          -> Unlock
                * noun 'auf' 'mit' held          -> Unlock
                * noun xdamit                    -> Lock
                * noun xdamit 'ab'               -> Lock
                * noun 'ab' xdamit               -> Lock
                * noun xdamit 'auf'              -> Unlock
                * noun 'auf' xdamit              -> Unlock;

Neu:
Verb 'schliess' 'sperr'
                * noun                           -> Close
                * noun 'mit' held                -> Lock
                * noun 'mit' held 'ab'           -> Lock
                * noun 'ab'                      -> Lock
                * noun 'ab' 'mit' held           -> Lock
                * noun 'mit' held 'auf'          -> Unlock
                * noun 'auf' 'mit' held          -> Unlock
                * noun xdamit                    -> Lock
                * noun xdamit 'ab'               -> Lock
                * noun 'ab' xdamit               -> Lock
                * noun xdamit 'auf'              -> Unlock
                * noun 'auf' xdamit              -> Unlock;

Verb 'verschliess' 'verriegel' 'verriegl'
                * lockable                       -> Lock
                * noun                           -> Close
                * noun 'mit' held                -> Lock
                * noun xdamit                    -> Lock;

***********************************************************************
* german.h
***********************************************************************

LanguageLM wurde an vielen Stellen überarbeitet.
Neu:
[ LanguageLM n x1;
	if (location == thedark) x1 = DunkelObj;
  Prompt:  print "^>";
  Miscellany:
           switch(n)
           {   1: "(Nur die ersten sechzehn Objekte werden beachtet)^";
               2: "Nichts zu tun!";
               3: print " Du bist gestorben ";
               4: print " Du hast gewonnen ";
               5: print "^Möchtest du einen NEUSTART, ein vorher 
                          gespeichertes Spiel LADEN";
                  if (TASKS_PROVIDED==0)
                      print ", die VOLLE Punktzahl des Spiels sehen";
                  if (deadflag==2 && AMUSING_PROVIDED==0)
                      print ", einige Vorschläge sehen für LUSTIGE 
                      Sachen";
                  if (DEATH_MENTION_UNDO==0)
                      print ", den letzten Zug R@:UCKG@:ANGIG machen";
                  " oder das ENDE?";
               6: "[Dein Interpreter kennt kein ~rückgängig~.  Tschuldigung!]";
#ifdef TARGET_ZCODE;
               7: "Der letzte Zug konnte nicht ~rückgängig~ gemacht werden.
               		[Nicht alle Interpreter haben diese Funktion.]";
#ifnot; ! TARGET_GLULX
               7: "[Du kannst nichts mehr ~rückgängig~ machen.]";
#endif; ! TARGET_
               8: "Bitte gib eine der obigen Antworten.";
               9: "^Es ist jetzt stockdunkel hier!";
              10: "Wie bitte?";
              11: "[Du kannst mit ~rückgängig~ nichts ungeschehen machen, was
                    du gar nicht getan hast!]";
              12: "[~Rückgängig~ ist nicht zweimal nacheinander möglich. Tut mir
                    leid!]";
              13: "[Letzten Zug ungeschehen gemacht.]";
              14: "Tschuldigung, das kann nicht korrigiert werden.";
              15: "Denke einfach nichts davon.";
              16: "~Oops~ kann nur ein einzelnes Wort korrigieren.";
              17: "Es ist stockdunkel, und du siehst rein gar nichts.";
              18: print "dich selbst";
              19: "Du siehst wunderschön aus, wie immer.";           
              20: "Um einen Befehl wie ~Frosch, spring~ zu wiederholen, sag nur ~nochmal~,
                    nicht ~Frosch, nochmal~.";
              21: "Das kannst du wohl kaum wiederholen.";
              22: "Du kannst nicht mit einem Komma beginnen.";
              23: "Gesprächspartner nicht gefunden!";
              24: "Du kannst mit ", (dem) x1, " nicht sprechen.";
              25: "Um mit jemandem zu sprechen, versuche es mit ~person, hallo~ oder
                    so was ähnlichem.";
              26: if (not_holding == player) "(nehme zuerst dich selbst)"; !Änderung v. Max Kalus
                  "(nehme zuerst ", (den) not_holding, ")";
              27: "Diesen Befehl verstehe ich nicht.";
              28: print "Wahrscheinlich meinst du: ";
              29: "Diese Zahl verstehe ich nicht.";
              30: "Du kannst nichts dergleichen sehen.";
              31: "Es sieht so aus, als hättest du zu wenig gesagt!";
              32: "Du trägst ", (den) x1, " nicht bei dir!";
              33: "Mit diesem Verb kannst du nicht mehrere Objekte
                   ansprechen.";
              34: "Du kannst pro Zeile nur einmal mehrere Objekte
                   ansprechen.";
              35: "Ich verstehe nicht, was mit ~", (address) pronoun_word,
                  "~ gemeint ist.";
              36: "Du hast etwas ausgeschlossen, was ohnehin nicht inbegriffen war.";
              37: "Das kannst du nur mit belebten Objekten machen.";
              38: #ifdef DIALECT_US;
                  "That's not a verb I recognize.";
                  #ifnot;
                  "Dieses Verb verstehe ich nicht.";
                  #endif;
              39: "Ein flüchtiger Blick auf ", (den) x1, " sagt dir, 
                    da@ss ", (er) x1, " für das Spiel nicht wichtig ", (isorare) x1, ".";
              40: "Im Augenblick ist ~", (address) pronoun_word,
                  "~ (", (der) pronoun_obj, ") nicht zu sehen.";
              41: "Ich habe nicht verstanden, wie das endete.";
              42: if (x1==0) print "Kein";
                  else print "Nur ", (number) x1;
                  print " davon ";
                  if (x1==1) print "ist"; else print "sind";
                  " ansprechbar.";
              43: "Nichts zu tun!";
              44: "Keiner der Gegenstände hier will diesem Befehl Folge leisten!";
              45: print "Wen meinst du, ";
              46: print "Was meinst du, ";
              47: "Du kannst dich damit nur auf einen einzigen Gegenstand beziehen.
                   Gib bitte an, welchen du meinst!";
              48: print "Wen willst du ansprechen?^";
              49: print "Du wolltest vermutlich folgendes: ";
                  if (actor~=player) print " ", (der) actor; print "~";
                  PrintCommand(); print "...~ - aber was, wie, womit?^";
              50: print "Dein Punktestand hat sich um ";
                  if (x1==1) print "einen Punkt ";
                    else print (number) x1, " Punkte ";
                  if (x1 > 0) print "erhöht"; else 
                      { x1 = -x1; print "verringert"; }
              51: "(Seit etwas sehr dramatisches passiert ist, wurde deine Liste von
                   Verben gekürzt.)";
              52: "^Tippe eine Zahl von 1 bis ", x1,
                  ", 0 für eine Neuanzeige oder drücke ENTER.";
              53: "^[Bitte drücke die Leertaste.]";
              54: print "^Deine Antwort: ";
           }


  ListMiscellany:
           switch(n)
           {   1: print " (leuchtend)";
               2: print " (", (er) x1, " ", (isorare) x1,
                         " geschlossen)";
               3: print " (geschlossen und Licht spendend)";
               4: print " (", (er) x1, " ", (isorare) x1, 
                         " leer)";
               5: print " (leer und Licht spendend)";
               6: print " (", (er) x1, " ", (isorare) x1, 
                         " geschlossen und leer)";
               7: print " (geschlossen, leer und Licht spendend)";
               8: print " (leuchtend und angezogen";
               9: print " (leuchtend";
              10: print " (angezogen";
              11: print " (", (er) x1, " ", (isorare) x1, " ";
              12: print "offen";
              13: print "offen aber leer";
              14: print "geschlossen";
              15: print "geschlossen und verschlossen";
              16: print " und leer";
              17: print " (", (er) x1, " ", (isorare) x1, " leer)";
              18: print " (", (er) x1, " enthält ";
              19: print " (darauf ";
              20: print ", darauf ";
              21: print " (darin ";
              22: print ", darin ";
           }


  Pronouns: switch(n)
           {   1: print "Diese Pronomen stehen für jeweils folgenden Gegenstand";
               2: print "^~", (address) x1, "~ : ";
               3: print "^~", (address) x1, "~ : nichts";
               4: "Das Spiel kennt keinerlei Pronomen.";
           }
  Order:          print (gder) x1;
                  if (x1 has pluralname) print " haben"; else print " hat";
                  " besseres zu tun.";
  Quit:    switch(n)
           {   1: print "Bitte antworte entweder ja oder nein.";
               2: print "Möchtest Du wirklich aufhören? ";
           }
  Restart: switch(n)
           {   1: print "Bist du sicher, da@ss du einen Neustart willst? ";
               2: "Fehlgeschlagen.";
           }
  Restore: switch(n)
           {   1: "Laden eines Spielstandes mi@sslang.";
               2: "In Ordnung.";
           }
  Save:    switch(n)
           {   1: "Das Speichern mi@sslang.";
               2: "In Ordnung.";
           }
  Verify:  switch(n)
           {   1: "Die Spielstanddatei wurde geprüft und ist in Ordnung.";
               2: "Es konnte nicht bestätigt werden, da@ss die 
                   Spielstanddatei in Ordnung ist. Möglicherweise ist
                   sie kaputt (es sei denn, Du spielst mit einem sehr 
                   primitiven Interpreter, welcher den Test nicht 
                   wirklich machen kann)."; 
            }
  ScriptOn: switch(n)
           {   1: "Das Transkribieren ist schon eingeschaltet.";
               2: "Ich beginne ein Transkript von";
               3: "Der Versuch, ein Transkript zu beginnen, scheiterte.";
           }
  
  ScriptOff: switch(n)
           {   1: "Das Transkribieren ist schon ausgeschaltet.";
               2: "^Ende des Transkriptes.";
               3: "Der Versuch, das Transkript zu beenden, scheiterte.";
           }
  NotifyOn:       "Punktezahlankündigung eingeschaltet.";
  NotifyOff:      "Punktezahlankündigung ausgeschaltet.";
  Places:         print "Du hast besucht: ";
  Objects: switch(n)
           {   1: "Objekte, mit denen du schon zu tun hattest:^";
               2: "Keines.";
               3: print "   (angezogen)";
               4: print "   (in der Hand gehalten)";
               5: print "   (weggegeben)";
               6: print "   (in ", (name) x1, ")";
               7: print "   (in ", (dem) x1, ")";
               8: print "   (innerhalb ", (des) x1, ")";
               9: print "   (auf ", (dem) x1, ")";
              10: print "   (verloren)";
           }
  Score:          if (deadflag) print "In diesem Spiel hast Du ";
                  else print "Du hast bisher ";
                  print score, " Punkte von ", MAX_SCORE, " möglichen gemacht, und zwar ";
                  if (turns>1) print "in ", turns, " Zügen";
                   else print "im Zug ", turns; return;
  FullScore: switch(n)
           {   1: if (deadflag) print "Der Punktestand war ";
                  else          print "Der Punktestand ist ";
                  "folgendermassen zusammengesetzt:^";
               2: "diverse Dinge findend";
               3: "verschiedenste Orte besuchend";
               4: print "insgesamt (von ", MAX_SCORE; ")";
           }
  Inv:     switch(n)
           {   1: "Du trägst nichts mit dir.";
               2: print "Du trägst";
           }
  Take:    switch(n)
           {   1: "Du trägst ", (den) x1, " jetzt bei dir.";
               2: "Du bist schon in deiner eigenen Hand.";
               3: print "Ich nehme nicht an, ", (der) x1, " ";
                  singplur(x1, "würde", "würden");
                  print_ret " sich dafür interessieren.";
               4: print "Du solltest zuerst ";
                  if (x1 has supporter) print "von "; else print "aus ";
                  print_ret (dem) x1, " nehmen.";
               5: "Du hast ", (diesen) x1, " schon.";
               6: print (GDer) noun, " ";
                  singplur(noun, "scheint", "scheinen");
                  "zu ", (dem) x1, "zu gehören.";
               7: print (GDer) noun, " ";
                  singplur(noun, "scheint", "scheinen");
                  " ein Teil von ", (dem) x1, "zu sein.";
               8: print_ret (Gdieser) x1, " ", (isorare) x1,
                  " nicht vorhanden.";
!               9: print_ret (gder) x1, " ", (isorare) x1, " nicht offen.";
		9: print_ret "Du kommst nicht an diesen Gegenstand heran, da ",
			(der) x1, " nicht offen ", (isorare) x1, ".";
              10: print_ret (gder) x1, " ", (isorare) x1, " zu schwer für dich.";
!              11: print_ret (GEristsiesind) x1, " wahrscheinlich am Boden
!                       festgenagelt... Nichts zu machen!";
              11: print (GDer) x1, " steh", (endT) x1,
                  " unbeweglich da. Du bewegst ", (ihn) x1, " keinen Millimeter weit.";
              12: "Du trägst schon zu viel mit dir herum.";
              13: "(lege ", (den) x1, " in ", (den) SACK_OBJECT,
                  ", um Platz zu schaffen)";
           }
  Drop:    switch(n)
           {   1: print_ret (GEristSiesind) x1, " schon hier.";
               2: "Du hast ", (diesen) x1, " nicht.";
               3: "(nehme zuerst ", (den) x1, ")";
               4: "Fallengelassen.";
           }
  Remove:  switch(n)
           {   1: print_ret (GEristSiesind) x1, " unglücklicherweise geschlossen.";
               2: print_ret (GDer) x1, " befindet sich aber nicht dort!";
               3: "Entfernt.";
           }
  PutOn:   switch(n)
           {   1: "Du mu@sst ", (den) x1,
                  " zuerst haben, bevor du ", (ihn) x1,
                  " auf etwas anderes legen kannst.";
               2: "Du kannst nichts auf sich selbst legen.";
               3: "Dinge auf ", (den) x1, " zu legen, würde nichts bringen.";
               4: "Dir fehlt die erforderliche Geschicklichkeit.";
               5: "(nehme ", (ihn) x1, " zuerst)^";
               6: "Da ist kein Platz mehr auf ", (dem) x1, ".";
               7: "Gesagt, getan!";
               8: "Du legst ", (den) x1, " auf ", (den) second, ".";
           }
  Insert:  switch(n)
           {   1: "Du mu@sst ", (den) x1,
                  " zuerst haben, bevor du ", (ihn) x1,
                  " in etwas anderes legen kannst.";
               2: print (Gdieser) x1, " ";
                  singplur(x1, "kann", "können");
                  " keine Dinge enthalten.";
               3: print_ret (gder) x1, " ", (isorare) x1, " geschlossen.";
               4: "Du solltest ", (ihn) x1, " zuerst wegnehmen.";
               5: "Du kannst nichts in sich selbst legen.";
               6: "(nehme ", (ihn) x1, " zuerst)^";
               7: "Da ist kein Platz mehr in ", (dem) x1, ".";
               8: "Gesagt, getan!";
               9: "Du legst ", (den) x1, " in ", (den) second, ".";
           }
  EmptyT:  switch(n)
           {   1: print (Gdieser) x1, " ";
                  singplur(x1, "kann", "können");
                  " keine Dinge enthalten.";
               2: print_ret (Gder) x1, " ", (isorare) x1, " geschlossen.";
               3: print_ret (Gder) x1, " ", (isorare) x1, " schon leer.";
               4: "Diese Aktion würde kaum etwas leeren.";
           }
  Give:    switch(n)
           {   1: "Du hast ", (den) x1, " nicht.";
               2: "Du wedelst eine Weile mit ", (dem) x1,
                  " herum, aber erreichst nicht viel .";
               3: print (Gder) x1, " ";
                  singplur(x1, "sieht", "sehen");
                  " nicht interessiert aus.";
           }
  Show:    switch(n)
           {   1: "Du hast ", (Gden) x1, " nicht.";
               2: print_ret (Gder) x1, " ", (isorare) x1, 
                   " nicht beeindruckt.";
           }
  Enter:   switch(n)
           {   1: print "Aber du bist schon ";
                  if (x1 has supporter) print "auf "; else print "in ";
                  print_ret (dem) x1, ".";
               2: print_ret (GEristSiesind) x1, " nichts, in das du hineingelangen
                    könntest.";
               3: "Du gelangst nicht in ", (der) x1, " weil ", (er) x1, 
                   " geschlossen ist.";
               4: "Du kannst nur in etwas hineinkommen, das frei steht.";
               5: print "Du gelangst ";
                  if (x1 has supporter) print "auf "; else print "in ";
                  print_ret (den) x1, ".";
               6: print "(komme ";
                  if (x1 has supporter) print "herunter von "; 
                  else print "hinaus aus "; print (dem) x1; ")";
               7: if (x1 has supporter) "(gelange auf ", (den) x1, ")^";
                  if (x1 has container) "(gelange in ", (den) x1, ")^";
                  "(trete in ", (den) x1, " ein)^";
           }
  GetOff:         "Aber du bist im Augenblick nicht auf ", (dem) x1, ".";
  Exit:    switch(n)
           {   1: "Aber du bist im Augenblick in nichts drin.";
               2: "Du kommst aus dem verschlossenen ", (name) x1, 
                  " nicht hinaus.";
               3: print "Du gelangst ";
                  if (x1 has supporter) print "runter vom "; 
                  else print "hinaus aus "; print_ret (dem) x1, ".";
           }
  VagueGo: "Du solltest sagen, in welche Kompa@ssrichtung du gehen willst.";

  Go:      switch(n)
           {   1: print "Du solltest zuerst ";
                  if (x1 has supporter) print "runter von "; else print "aus ";
                  print_ret (dem) x1, " kommen.";
               2: "Du kannst nicht in diese Richtung gehen.";
               3: "Du bist unfähig, auf ", (den) x1, " zu klettern.";
               4: "Du bist unfähig, ", (den) x1, " hinunterzugehen.";
               5: "Du kannst nicht, weil ", (der) x1, " geschlossen ", (isorare) x1, ".";
               6: print "Du kannst nicht weil ", (der) x1, " nirgendwohin ";
                  if (x1 has pluralname) "führt.";
                  "führen.";
           }

  LMode1:         " ist jetzt im normalen Beschreibungsmodus. Es werden ab nun lange
                    Beschreibungen von Orten gegeben, an denen du noch nie gewesen bist, und
                    kurze von Orten, die du schon besucht hast.";
  LMode2:         " ist jetzt im ausführlichen Beschreibungsmodus. Es werden ab nun
                    immer lange Beschreibungen von Orten gegeben (selbst wenn du schon einmal
                    dort warst)."; 
  LMode3:         " ist jetzt im superkurzen Beschreibungsmodus. Es werden nun immer
                    kurze Beschreibungen von Orten gegeben (selbst wenn du vorher noch nie
                    dort warst).";

  Look:    switch(n)
           {   1: print " (auf ", (dem) x1, ")";
               2: print " (in ", (dem) x1, ")";
 !               3: print " (als "; @print_obj x1; print ")";
               3: print " (als ", (object) x1, ")";
               4: print "^Auf ", (dem) x1;
                  WriteListFromCase(child(x1),
                      ENGLISH_BIT + RECURSE_BIT + PARTINV_BIT
                      + TERSE_BIT + ISARE_BIT + CONCEAL_BIT, 0, Nom);
                  ".";
         default: if (x1~=location)
                  {   if (x1 has supporter) print "^Auf "; else print "^In ";
                      print (dem) x1, " siehst Du hier ";
                  }
                  else print "^Du siehst hier ";
                  if (n==5) print "auch ";
                  WriteListFrom(child(x1),
                      ENGLISH_BIT + WORKFLAG_BIT + RECURSE_BIT
                      + PARTINV_BIT + TERSE_BIT + CONCEAL_BIT);
                  if (x1~=location) ".";
                  ".";
           }

  Examine: switch(n)
           {   1: "Dunkelheit, die. Abwesenheit von Licht.";
               2: "Du entdeckst an ", (dem) x1, " nichts Spezielles.";
               3: print (Gder) x1, " ", (isorare) x1, " momentan ";
                  if (x1 has on) "eingeschaltet."; else "ausgeschaltet.";
           }
  LookUnder: switch(n)
           {   1: "Aber es ist dunkel.";
               2: "Du findest nichts Interessantes.";
           }

  Search:  switch(n)
           {   1: "Aber es ist dunkel.";
               2: "Da ist nichts auf ", (dem) x1, ".";
               3: print "Auf ", (dem) x1;			!Max Kalus
                  WriteListFromCase(child(x1),
                      TERSE_BIT + ENGLISH_BIT + ISARE_BIT + CONCEAL_BIT, 0, Gen);
                  ".";
               4: "Du findest nichts Interessantes.";
               5: "Du kannst in ", (dem) x1, " nichts sehen, weil ", 
                    (er) x1, " geschlossen ", (isorare) x1, ".";
               6: print_ret (Gder) x1, " ", (isorare) x1, " leer.";
               7: print "In ", (dem) x1, " siehst du ";
                  WriteListFrom(child(x1),
                      TERSE_BIT + ENGLISH_BIT + CONCEAL_BIT);
                  ".";
           }

  Unlock:  switch(n)
           {   1: print (GDer) x1, " s";
                  if (x1 has pluralname) print "ehen";
                  else print "ieht";
                  " nicht aus wie etwas, das du aufschliessen könntest.";
               2: print_ret (GEristSiesind) x1,
                  " ist im Augenblick aufgeschlossen.";
               3: print (GDer) x1, " sch";
                  if (x1 has pluralname) print "einen";
                  else print "eint";
                  " nicht ins Schlo@ss zu passen.";
               4: "Du schlie@sst ", (den) x1, " auf.";
           }
  Lock:    switch(n)
           {   1: print (GDer) x1, " s";
                  if (x1 has pluralname) print "ehen";
                  else print "ieht";
                  " nicht aus wie etwas, das du abschlie@ssen könntest.";
               2: print_ret (GEristSiesind) x1, " im Augenblick verschlossen.";
               3: "Zuerst solltest du ", (den) x1, " schlie@ssen.";
               4: print (GDer) noun, " sch";
                  if (noun has pluralname) print "einen";
                  else print "eint";
                  " nicht ins Schlo@ss zu passen.";
               5: "Du verschlie@sst ", (den) x1, ".";
           }

  SwitchOn: switch(n)
           {   1: print_ret (Gden) x1,
                  " kannst du weder ein- noch ausschalten.";
               2: print_ret (GEristSiesind) x1,
                  " schon eingeschaltet.";
               3: "Du schaltest ", (den) x1, " ein.";
           }
  SwitchOff: switch(n)
           {   1: print_ret (Gden) x1,
                  " kannst du weder aus- noch einschalten.";
               2: print_ret (GEristSiesind) x1,
                  " schon ausgeschaltet.";
               3: "Du schaltest ", (den) x1, " aus.";
           }

  Open:    switch(n)
           {   1: print_ret "Man kann ", (den) x1, " nicht öffnen.";
               2: print (GDer) noun, " schein", (endT) noun, " verschlossen zu sein.";
               3: print_ret (GEristSiesind) x1,
                  " schon offen.";
               4: print "Du öffnest ", (den) x1, " und bringst ";
                  if (child(x1)==0) print "nichts";
                  else if (WriteListFrom(child(x1),
                      ENGLISH_BIT + TERSE_BIT + CONCEAL_BIT)==0) 
                       "nichts";
                  " zum Vorschein.";
               5: "Du öffnest ", (den) x1, ".";
           }

  Close:   switch(n)
           {   1: print_ret (GDen) x1,
                  " kannst du nicht schliessen.";
               2: print_ret (GEristSiesind) x1,
                  " schon geschlossen.";
               3: "Du schlie@sst ", (den) x1, ".";
           }
  Disrobe: switch(n)
           {   1: "Du trägst ", (ihn) x1, " nicht.";
               2: "Du ziehst ", (den) x1, " aus.";
           }
  Wear:    switch(n)
           {   1: "Du kannst ", (diesen) x1, " nicht anziehen!";
               2: "Du hast ", (diesen) x1, " nicht!";
               3: "Du hast ", (diesen) x1, " schon angezogen!";
               4: "Du ziehst ", (den) x1, " an.";
           }
  Eat:     switch(n)
           {   1: print_ret (GEristSiesind) x1,
                  " völlig ungenie@ssbar.";
               2: "Du i@sst ", (den) x1, ". Nicht schlecht.";
           }

  Yes, No:        "Das war eine rhetorische Frage.";
  Burn:           "Diese gefährliche Aktion würde wenig bringen.";
  Pray:           "Dein Gebet bringt dir in praktischer Hinsicht nichts.";
  Wake:           "Die schreckliche Wahrheit lautet: Das hier ist kein Traum.";
  WakeOther:      "Das scheint unnötig zu sein.";
  Kiss:           "Konzentriere dich auf das Spiel.";
  Think:          "Was für eine gute Idee!";
  Smell:          "Du riechst nichts Unerwartetes.";
  Listen:         "Du hörst nichts Unerwartetes.";
  Taste:          "Du fühlst nichts Unerwartetes.";
  Touch:   switch(n)
           {   1: "Behalte deine Hände bei dir!";
               2: "Du fühlst nichts Unerwartetes.";
               3: "Wenn du denkst, da@ss es vielleicht hilft.";
           }
  Dig:            "Graben würde hier nichts bringen.";
  Cut:            "Das Schneiden gestaltet sich ohne Werkzeug schwierig.";
  Jump:           "Du hüpfst an Ort und Stelle. Ohne ersichtlichen Erfolg.";
  JumpOver, Tie:  "Damit würdest du nichts erreichen.";
  Drink:          "Es ist nichts Trinkbares in der Nähe.";
  Fill:           "Aber es gibt hier kein Wasser.";
  Sorry:          #ifdef DIALECT_US;
                  "Oh, don't apologize.";
                  #ifnot;
                  "Oh, macht nichts.";
                  #endif;
  Strong:         "Echte Abenteurer sprechen diese Sprache nicht.";
  Mild:           "Ziemlich.";
  Attack:         "Gewalt ist keine Antwort!";
  Swim:           "Hier gibt es nicht genug Wasser, um zu schwimmen.";
  Swing:          "Hier gibt es nichts, was schwingen k@:onnte.";
  Blow:           "Du kannst ", (dieses) x1, " nicht sinnvoll
                   blasen.";
  Rub:            "Damit erreichst du nichts.";
  Set:            "Nein, du kannst ", (diesen) x1, " nicht einstellen.";
  SetTo:          "Nein, du kannst ", (diesen) x1, 
                    " auf nichts einstellen.";
  WaveHands:      "Du winkst und fühlst dich lächerlich.";
  Wave:    switch(n)
           {   1: "Du hast ", (diesen) x1, " nicht.";
               2: "Du siehst lächerlich aus wie du ", (den) x1, " wedelst.";
           }
  Pull, Push, Turn:
           switch(n)
           {   1: print_ret (GEr) x1, " beweg", endT(x1),
                  " sich keinen Millimeter.";
               2: "Du bist dazu unfähig.";
               3: "Offenbar passiert nichts.";
               4: "Das wäre nicht besonders höflich.";
           }
  PushDir: switch(n)
           {   1: "Ist das das beste, was dir einfällt?";
               2: "Das ist keine Richtung.";
               3: "In diese Richtung geht das nicht.";
           }
  Squeeze: switch(n)
           {   1: "Behalte deine Hände bei dir.";
               2: "Damit erreichst du nichts.";
           }
  ThrowAt: switch(n)
           {   1: "Idiotisch.";
               2: "Du hast im entscheidenden Moment nicht die Nerven dazu.";
           }
  Tell:    switch(n)
           {   1: "Du führst eine Weile lang Selbstgespräche.";
               2: "Das scheint keine Reaktion zu provozieren.";
           }
  Answer, Ask:    "Es kommt keine Antwort.";
  Buy:            "Es gibt nichts zu kaufen.";
  Sing:           "Dein Gesang ist abscheulich.";
  Climb:          "Ich denke nicht, da@ss damit viel erreicht werden könnte.";
  Wait:           "Zeit geht vorbei.";
  Sleep:          "Du fühlst dich nicht besonders schläfrig.";
  Consult:        "In ", (dem) x1, " steht darüber nichts Interessantes.";
];
