/***************************************************************************************/
/*								       */
/*		2. Uebungsblatt  Allgemeine Informatik III WS 1999/2000 	       */
/*								       */
/***************************************************************************************/
#include <stdio.h>

/*Konstanten*/
const unsigned maxAnzahlMitspieler   = 10;
const unsigned UntergrenzeVerflixteN =  2;
const unsigned ObergrenzeVerflixteN  = 10;
const unsigned maxNamenlaenge	       = 80;


/***************************************************************************************/
/*	Funktion zur Bestimmung der naechsten gueltigen Zahl                         */
/*								       */
/*	int f_naechsteGueltigeN(int aktuelleGueltigeN, const int verflixteN)         */
/*								       */
/*  Paramater:                                                                         */      
/*               aktuelleGueltigeN:  derzeit gueltige Zahl                             */
/*               verflixteN:         verflixte Zahl                                    */
/*								       */
/*  Rueckgabewert:   						       */
/*                die bestimmte naechste gueltige Zahl                                 */
/*								       */
/***************************************************************************************/
int f_naechsteGueltigeN(int aktuelleGueltigeN, const int verflixteN)
{
	/*Hilfsvariablen*/
	int hilf = 0, hilf2=0;

					
	/*Bestimmung der naechsten gueltigen Zahl*/
	
	/*TEST: Ist die naechste gueltige Zahl durch die verflixteN teilbar,*/
	/*		oder ist die Ziffer "verflixteN" enthalten.     */
	do
	{
		aktuelleGueltigeN++;
		hilf = aktuelleGueltigeN;
		hilf2=0;
		
		/* Ist die Ziffer "verflixteN" enthalten?                            */
		/* Die letzte Ziffer wird durch die Berechnung Zahl % 10 bestimmt    */
		/* Wird die veflixteN in der Zahl gefunden, so wird hilf2 = 1 und    */
		/* hilf =0 gesetzt.                                                  */
		do
		{
			if ((hilf%10)==verflixteN)
			{						
				hilf2 = 1;
				hilf  = 0;
			}
			else
			{
				hilf = hilf / 10;
			}
			
		}while (hilf>0);				
		
		
	} while( ((aktuelleGueltigeN%verflixteN)==0) || (hilf2==1) );
	
	/*Ende der Bestimmung der naechsten gueltigen Zahl*/
	return aktuelleGueltigeN; 
}

/***************************************************************************************/
/*	Funktion zum Einlesen der verflixten Zahl                                    */
/*								       */
/*			void f_verflixteN(int *verflixteN)		       */
/*								       */
/*  Paramater:                                                                         */
/*								       */
/*               verflixteN:         verflixte Zahl                                    */
/*								       */
/*	Rueckgabewert:						       */
/*				 keiner				       */
/***************************************************************************************/
void f_verflixteN(int *verflixteN)
{
	/*Testvariable für scanf-Ergebnis*/
	int result=0;
	
	*verflixteN = 0;
	do 
	{
		printf("verflixte N [2-9]: ", verflixteN);
		do
		{
			result = scanf("%d", verflixteN);
		}while(result == 0);

	}while((*verflixteN<UntergrenzeVerflixteN)||(*verflixteN>ObergrenzeVerflixteN ));	
    
}

/***************************************************************************************/
/*	Funktion zum Einlesen der Spielernamen                                       */
/*								       */
/*            void f_NameMitspieler(int AnzahlMitspieler, int *gueltigeSpieler,        */
/*                                  const char Spieler[][maxNamenlaenge])              */
/*								       */
/*  Paramater:                                                                         */
/*            AnzahlMitspieler : Anzahl der Mitspieler                                 */
/*            gueltigeSpieler  : Array der gueltigen Spieler                           */
/*            Spieler          : Namen der Spieler                                     */
/*								       */
/*								       */
/*	Rueckgabewert:	                    			       */
/*			  keiner					       */
/***************************************************************************************/
void f_NameMitspieler(int AnzahlMitspieler, int *gueltigeSpieler, char Spieler[][maxNamenlaenge])
{
	int i;

	/*Gueltige Spieler mit 1 markieren*/
	for (i=0;i<AnzahlMitspieler;i++)
	{
		gueltigeSpieler[i]=1;
		printf("\n%d-ter Spielername: ", i+1);
		scanf("%s", Spieler[i]);
	}
	/*Ungueltige Spieler mit 0 markieren*/
	for (i=AnzahlMitspieler;i<maxAnzahlMitspieler;i++)
	{
		gueltigeSpieler[i]=0;			
	}

}

/***************************************************************************************/
/*	Funktion zum Einlesen der Anzahl der Mitspieler                              */
/*								       */
/*		void f_anzahlMitspieler(int *anzMitspieler )		       */
/*								       */
/*  Paramater:                                                                         */
/*								       */
/*		       anzMitspieler: Anzahl der Mitspieler                        */
/*								       */
/*	Rueckgabewert:					                 */
/*				keiner				       */
/***************************************************************************************/
void f_anzahlMitspieler(int *anzMitspieler )
{
    /*Testvariable für scanf-Ergebnis*/
	int result=0;

	*anzMitspieler = 0;

	/*Anzahl Mitspieler einlesen, maximal 10 Spieler*/
	do {
		printf("Anzahl Mitspieler (maximal 10): ", anzMitspieler);
		do
		{
			result = scanf("%d", anzMitspieler);
		}while(result ==0);
				
		if (*anzMitspieler > maxAnzahlMitspieler)
		{
			printf("Anzahl Mitspieler darf maximal 10 betragen. Bitte Eingabe wiederholen. Eine Null beendet das Spiel.\n");
		}
	} while (*anzMitspieler > maxAnzahlMitspieler);

}

/***************************************************************************************/
/*  eigentliche Spiel-Funktion                                                         */
/*								       */
/*  void Spiel(int AnzahlMitspieler, const verflixteN, int *gueltigeSpieler,           */
/*                           char Spieler[][maxNamenlaenge])                           */
/*								       */
/*  Paramater:                                                                         */
/*            AnzahlMitspieler : Anzahl der Mitspieler                                 */
/*            verflixteN       : verflixte Zahl                                        */  
/*            gueltigeSpieler  : Array der gueltigen Spieler                           */
/*            Spieler          : Namen der Spieler                                     */
/*								       */
/*	Rueckgabewert:						       */
/*	    keiner						       */
/***************************************************************************************/
void Spiel(int AnzahlMitspieler, const verflixteN, int *gueltigeSpieler, char Spieler[][maxNamenlaenge])
{
	/*aktuelle Anzahl der Mitspieler eines Spiels*/
	int aktuelleAnzahlMitspieler;

	/*die naechste gueltige Eingabe*/
	int naechsteGueltigeN;	

	/*die aktuelle Eingabe*/
	int eingegebeneN;

	/*Zaehlvariable*/
	int i;  

	/*Testvariable für scanf-Ergebnis*/
	int result=0;

    /*Initialisierung*/
	i=0;
	naechsteGueltigeN=0;
	aktuelleAnzahlMitspieler = AnzahlMitspieler;


	/*Spielbeginn, falls Spielinteressenten vorhanden.*/
	while(aktuelleAnzahlMitspieler > 0)
	{			
		/*So jetzt kann das eigentliche Spiel beginnen.*/
		naechsteGueltigeN=f_naechsteGueltigeN(naechsteGueltigeN, verflixteN);
		
		/*Naechster berechtigte Spieler*/
		while(gueltigeSpieler[i]==0)
		{
			i ++;
		   /*Die Runde faengt neu an*/
			if (i >= AnzahlMitspieler)
			{
				i = 0;
			}
		}					
		/*Einlesen der Eingabe des aktuellen Spielers.*/
		printf("Eingabe von %s wird erwartet: ", Spieler[i]);
		do
		{
			result = scanf("%d", &eingegebeneN);
		}while(result == 0);
					
		/*Eingabe auf Gueltigkeit pruefen.*/
		if (eingegebeneN != naechsteGueltigeN)
		{
			/*Falscheingabe Spieler scheidet aus.*/
			aktuelleAnzahlMitspieler--;
			gueltigeSpieler[i]=0;
			printf("Falscheingabe, die richtige Eingabe waere %d gewesen.\n", naechsteGueltigeN);
			printf("Spieler %d ist ausgeschieden, jetzt sind noch %d Spieler im Spiel.\n", i +1, aktuelleAnzahlMitspieler);					
		}
	
		/*Naechster Spieler*/
		i ++;	
	}
	/*naechste gueltige Zahl, bei Null wird mit der Rechnung begonnen.*/
	naechsteGueltigeN = 0;		
}

/***************************************************************************************/
/*								       */
/*								       */
/*		Hauptprogramm      					       */
/*								       */
/*								       */
/***************************************************************************************/
int main()
{
	/*Anzahl der Mitspieler eines Spiels und dessen aktuelle Spieler*/
	int AnzahlMitspieler;

	/*verflixte N*/
	int verflixteN;

	/*Zaehlvariable*/
	int i;
	
	/*Feld der gueltige Spieler*/
	int gueltigeSpieler[maxAnzahlMitspieler];

    	/*Feld mit den Spielernamen*/
	char Spieler[maxAnzahlMitspieler][maxNamenlaenge];
	
	/*Initialisierung mit Anfangswerten*/
	AnzahlMitspieler		= 0;
	verflixteN				= 0;
	i						= 0;
    
	do {				
		f_anzahlMitspieler(&AnzahlMitspieler);

		f_NameMitspieler(AnzahlMitspieler, &gueltigeSpieler[0], Spieler);

		/*Einlesen der verflixten Zahl im Bereich von 2-9*/
		if (AnzahlMitspieler > 0)
		{
			f_verflixteN(&verflixteN);
		}

		Spiel(AnzahlMitspieler, verflixteN, &gueltigeSpieler[0], Spieler);			

	}while (AnzahlMitspieler > 0);	
	
	return 0;
}