Logo
IT Dienstleistungen

Wer wird Millionär V1

Erste Version fuer die lokale Nutzung, mit 50/50 Joker und drei Fragekategorien.

Fragedateien hier: (im selben Ordner platzieren)

/***************************************             
* Wer wird Millionaer                  *             
* Praktikum Betriebssysteme 01.05.2009 *             
* (c) Manuel Krischer                  *             
***************************************/             
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <string.h>
 
#define FRAGEN          15      /*anzahl der maximalen fragen*/
#define Z_P_A           6       /*Zeilen pro Antwort in der Fragendatei*/
#define Q_LENGTH        512     /*Anzahl der erlaubten Zeichen pro Frage*/ 
#define A_LENGTH        64      /*Anzahl der erlaubten Zeichen pro Anwort*/
 
/*Dateien mit den Fragen. Struktur: jeweils eine Zeile fuer Frage, Antwort[1-4], loesung als int*/
char *q_easy   = "easy.txt";     /*einfache fragen bis zur ersten sicherheitsstufe*/              
char *q_medium = "medium.txt";   /*mittlere fragen bis zur zweiten sicherheitsstufe*/             
char *q_hard   = "hard.txt";     /*schwere fragen bis zum ende*/                                  
 
int stufe[] = {50, 100, 200, 300, 500, 1000, 2000, 4000, 8000, 
               16000, 32000, 64000, 125000, 500000, 1000000};  /*Wertigkeiten in Eur*/
 
int fallback[2] = {4,9}; /*fragestufen auf die ein kandidat zurueckfaellt bei falscher antwort*/
 
int merke_easy[FRAGEN/3];       /*merkt sich bereits gestellte einfache fragen*/
int merke_medium[FRAGEN/3];     /*merkt sich bereits gestellte mittlere fragen*/
int merke_heavy[FRAGEN/3];      /*merkt sich bereits gestellte schwere fragen*/ 
 
/*Struktur einer Frage*/
struct Frage {          
    char frage[Q_LENGTH];       /*Nimmt den Fragenstring in Lenge Q_LENGTH auf*/
    char ans_a[A_LENGTH];       /*Nimmt Antwort in Laenge von A_LENGTH auf*/    
    char ans_b[A_LENGTH];                                                       
    char ans_c[A_LENGTH];                                                       
    char ans_d[A_LENGTH];                                                       
    int  loesung;               /*Loesung 1-4 als int*/                         
};                                                                              
 
/*Zufallszahlen ziehen*/
int zufall(int max) {   
    return rand() % max;
}                       
 
/* Die Fragen in ein Array einlesen
   Benötigt ein Char-Pointer mit einem Dateinamen
   Gibt die Anzahl der ermittelten Fragen zurueck
*/                                               
int fragen_zaehlen(char *fragendatei) {          
    /*dateihandler*/                             
    FILE * datei;                                
    /*datei zum lesen oeffnen*/                  
    datei = fopen(fragendatei, "r");             
      if (datei == 0)  {                         
         printf("Kritischer Fehler: Fragendatei wurde nicht gefunden. Abbruch\n");
         exit(1);                                                                 
      }                                                                           
    /*ein paar zaehlvariablen*/                                                   
    int c=0,zeile=0,zeichen=0, fragen;                                            
   /*Zeichen und Zeilen zaehlen*/                                                 
    while((c=fgetc(datei))!=EOF) {                                                
        ++zeichen;                                                                
       (c == '\n') ? ++zeile : 1;                                                 
    }                                                                             
    if (zeile%Z_P_A == 0) {                                                       
      fragen=zeile/Z_P_A;                                                         
/*      printf("Fragendatei OK, %i Fragen gefunden\n", fragen);*/                 
    }                                                                             
    else {                                                                        
      printf("Kritischer Fehler: Fragendatei Fehlerhaft (Fehlerhafte Zeilenzahl), Abbruch\n");
      exit(2);                                                                                
    }                                                                                         
    /*datei schliessen*/                                                                      
    fclose( datei );                                                                          
return fragen;                                                                                
}                                                                                             
 
/* fragen einlesen benoetigt ein struct vom typ Fragen sowie die zu oeffnende Fragendatei
liest die datei zeichenweise ein, bei jedem zeilenumbruch wird in ein neues Feld der     
struktur geschrieben. zeile 1 frage, zeile 2-5 antwortmoeglichkeiten, zeile 6 loesung als int
liefert 0 zurueck bei fehlerfreier ausfuehrung, dateifehler sind kritischer abbruch          
*/                                                                                           
int fragen_einlesen(struct Frage structname[], char *fragendatei) {                          
    /*dateihandler*/                                                                         
    FILE * datei;                                                                            
    /*datei zum lesen oeffnen*/                                                              
    datei = fopen(fragendatei, "r");                                                         
    if (datei == 0)  {                                                                       
       printf("Kritischer Fehler: Fragendatei wurde nicht gefunden. Abbruch\n");             
       exit(1);                                                                              
    }                                                                                        
    /*zaehlvariablen*/                                                                       
    int zeichen=0;                                                                           
    int zeile=0;                                                                             
    int i,j,c;                                                                               
    char temp[Q_LENGTH]; /*nimmt die ausgelesenen strings auf*/                              
    /*datei einlesen, dabei zeilenweise in struct schreiben*/                                
      while((c=fgetc(datei))!=EOF) {                                                         
              ++zeichen;                                                                     
              if (c != '\n') {                                                               
               temp[i++] = c;                                                                
              }                                                                              
              else {                                                                         
              temp[i] = '\0';                                                                
              i=0;                                                                           
                  if (zeile%Z_P_A == 0) {                                                    
                      strcpy(structname[j].frage, temp);                                     
                  }                                                                          
                  if (zeile%Z_P_A == 1) {                                                    
                      strcpy(structname[j].ans_a, temp);                                     
                  }                                                                          
                  if (zeile%Z_P_A == 2) {                                                    
                      strcpy(structname[j].ans_b, temp);                                     
                  }                                                                          
                  if (zeile%Z_P_A == 3) {                                                    
                      strcpy(structname[j].ans_c, temp);                                     
                  }                                                                          
                  if (zeile%Z_P_A == 4) {                                                    
                      strcpy(structname[j].ans_d, temp);                                     
                  }                                                                          
                  if (zeile%Z_P_A == 5) {                                                    
                      structname[j++].loesung = atoi(temp);                                  
                  }                                                                          
              zeile++;                                                                       
              }                                                                              
      }                                                                                      
    /*datei schliessen*/                                                                     
    fclose( datei );                                                                         
return 0;                                                                                    
}                                                                                            
 
/*zieht fragen, benoetigt anzahl der fragen als int sowie int array 
  in groesse der fragen pro stufe um doppelte zu vermeiden.         
  das letzte int ist ein zaehler, bei welcher frage wir sind.       
  liefert gezogene frage als int zurueck                            
*/                                                                  
int frage_ziehen(int anzahl, int sammlung[], int j) {               
            int k,neu=0;                                            
            /*Eine einfach Frage ziehen*/                           
            int ziehen = zufall(anzahl);                            
            /*pruefschleife*/                                       
            while (1) {                                             
                  /*pruefen ob frage schon genutzt*/                
                     for (k=0; k<j; k++) {                          
                        /*wenn gezogene zahl alter zahl entspricht....*/
                        if (ziehen == sammlung[k]) {                    
                            /*markierung setzen*/                       
                            neu = 1;                                    
                        }                                               
                     }                                                  
                 /*wenn noch nicht gestellte frage gezogen, merken und schleife verlassen*/
                 if (neu != 1) {                                                           
                     sammlung[j] = ziehen;                                                 
                     break;                                                                
                 }                                                                         
                 /*ansonsten neue fragen ziehen und wieder pruefen*/                       
                 else {                                                                    
                     ziehen = zufall(anzahl);                                              
                     neu=0;                                                                
                 }                                                                         
              }                                                                            
return ziehen;                                                                             
}                                                                                          
 
/*
Zeigt eine Frage an
 - benoetigt die Struct der Fragenkategorie
 - benoetigt die ermittelte zufallszahl aus fragen_ziehen()
 - einen zaehler aus dem hauptprogramm, bei welcher Frage wir sind
 - einen int mit 0 oder 1 fuer den Joker                          
 - liefert 1 zurueck, wenn der joker benutzt wurde                
*/                                                                
int frage_zeigen(struct Frage kategorie[], int ziehen, int i, int joker) {
int antwort = -1, antworten[4] = {1, 1, 1, 1 }, zweite, k, j;             
char eingabe[Q_LENGTH];                                                   
/*zeigt die schleife solange an, bis eine moegliche antwort eingegeben wurde*/
      while (antwort != 1 || antwort != 2 || antwort != 3 || antwort != 4) {  
            printf("\n+ + + + + + + + + + + + + + + + + + + + + + + + + +");  
            printf("\nJetzt spielen wir um %i Eur!",stufe[i]);                
            printf("\n+ + + + + + + + + + + + + + + + + + + + + + + + + +");  
            printf("\n%s\n",    kategorie[ziehen].frage);                     
            /*anworten nur anzeigen wenn ausgewaehlt.*/                       
              if (antworten[0] == 1) printf("\t1: %s\n", kategorie[ziehen].ans_a);
              if (antworten[1] == 1) printf("\t2: %s\n", kategorie[ziehen].ans_b);
              if (antworten[2] == 1) printf("\t3: %s\n", kategorie[ziehen].ans_c);
              if (antworten[3] == 1) printf("\t4: %s\n", kategorie[ziehen].ans_d);
            printf("\nLoesung ");                                                 
             /*nur gueltige antwortmoeglichkeiten gehen*/                         
              for (j=0; j<4; j++) {                                               
                 if (antworten[j] == 1) printf("%i,",j+1);                        
              }                                                                   
            printf(" \"a\" fuer Aussteigen");                                     
              if (joker == 1) printf(" oder \"j\" fuer den 50/50 Joker");         
            printf("\nIhre Antwort: ");                                           
 
            /*antwort einlesen und umwandeln*/                                    
            scanf("%s", &eingabe);                                                
              if (eingabe[0] == 'a') {                                            
                  /*ausstieg mit aktuellem gewinn*/                               
                  printf("\nSie sind ausgestiegen und haben %i Eur gewonnen  :-)\n\n", stufe[i-1]);
                  exit(0);                                                                         
              }                                                                                    
              else {                                                                               
                antwort = atoi(eingabe);                                                           
              }                                                                                    
            /*richtige antwort*/                                                                   
              if (antwort == kategorie[ziehen].loesung) {                                          
                printf("\nRichtige Antwort!\n\n\n");                                               
                /*wenn wir bei der letzten frage sind und diese richtig war, ehrung anzeigen*/     
                if (i+1 == FRAGEN) {                                                               
                    oneinamillion();                                                               
                }                                                                                  
                break;                                                                             
              }                                                                                    
              /*joker angefordert und noch vorhanden*/                                             
              else if (eingabe[0] == 'j' && joker == 1) {                                          
                  printf("\n50/50 Joker angefordert!\n");                                          
                  /*antwortflags nullen*/                                                          
                    for (k=0; k<4; k++) {                                                          
                        antworten[k] = 0;                                                          
                    }                                                                              
                  /*richtige antwort reaktivieren*/                                                
                  antworten[kategorie[ziehen].loesung-1] = 1 ;                                     
                  /*zweite antwort suchen..*/                                                      
                  zweite = zufall(3)+1;                                                            
                  /*...die nicht mit der ersten uebereinstimmt...*/                                
                      while ( zweite == kategorie[ziehen].loesung ) {                              
                          zweite = zufall(3)+1;                                                    
                      }                                                                            
                  /*..und dann auch reaktivieren*/                                                 
                  antworten[zweite-1] = 1;                                                         
                  /*ausserdem den joker eliminieren*/                                              
                  joker = 0;                                                                       
              }                                                                                    
              /*joker angefordert aber schon benutzt*/                                             
              else if (eingabe[0] == 'j' && joker == 0) {                                          
                  printf("\nJoker wurde schon benutzt!\n");                                        
                  antwort = -1;                                                                    
              }                                                                                    
              /*zahlen dies nich gibt ausfiltern*/                                                 
              else if (antwort > 4 || antwort < 1) {                                               
                  printf("\nDiese Anwort ist ungueltig.\n");                                       
              }                                                                                    
              else {                                                                               
              /*falsche antwort*/                                                                  
                  printf("\n%i ist die falsche Antwort, die richtige waere %i gewesen",antwort, kategorie[ziehen].loesung);
                  /*verloren ohne sicherheitsstufe*/                                                                       
                    if (i < fallback[0]+1) {                                                                               
                        printf("\nSie sind leider ohne Gewinn ausgeschieden :-((  \n\n");                                  
                    }                                                                                                      
                    /*verloren mit erster sicherheitsstufe*/                                                               
                    else if (i < fallback[1]+1) {                                                                          
                        printf("\nSie sind leider auf %i Eur zurueckgefallen! :-(  \n\n",stufe[fallback[0]]);              
                    }                                                                                                      
                    /*verloren mit zweiter sicherheitsstufe*/                                                              
                    else {                                                                                                 
                       printf("\nNa, wenigstens haben sie sich die %i Eur gesichert! :-/ \n\n",stufe[fallback[1]]);        
                    }                                                                                                      
                  exit(0);                                                                                                 
              }                                                                                                            
      }                                                                                                                    
  /*wenn der joker genutzt wurde, 1 zurueckgeben*/                                                                         
  if (joker == 0) return 1;                                                                                                
  else return 0;                                                                                                           
}                                                                                                                          
 
/*kleines ehrungsbanner*/
int oneinamillion(){     
    printf("\n* * * H E R Z L I C H     G L U E C K W U N S C H * * *\n");
    printf("* Sie haben es tatsaechlich geschafft und alle Fragen *\n");  
    printf("* richtig beantwortet. Sie sind ab heute unser neuer  *\n");  
    printf("*              +++ M I L L I O N A E R +++            *\n");  
    printf("* * * * * * * * * * * * * * * * * * * * * * * * * * * *\n");  
return 0;                                                                 
}                                                                         
 
/*
  HAUPTPROGRAMM
*/             
int main(int argc, char* argv[]) {
    int i,j,k, alt[FRAGEN/3], ziehen, neu, joker = 1;
    /*einmaliges initialisieren des randomizers*/    
    srand(time(NULL));                               
 
    printf("\n==================================\n");
    printf(  "        Wer wird Millionaer?      \n");
    printf(  "==================================\n");
 
    /*                                               
    anzahl aus Funktion fragen_zaehlen()             
    Struct-Array fuer Fragen anlegen,                
    fragen in struct einlesen                        
    */                                               
    int anz_easy = fragen_zaehlen(q_easy);           
    struct Frage easy[anz_easy];                     
    fragen_einlesen(easy, q_easy);                   
 
    int anz_medium = fragen_zaehlen(q_medium);       
    struct Frage medium[anz_medium];                 
    fragen_einlesen(medium, q_medium);               
 
    int anz_hard = fragen_zaehlen(q_hard);           
    struct Frage hard[anz_hard];                     
    fragen_einlesen(hard, q_hard);                   
 
    /*los gehts mit dem Spiel*/
    for (i=0; i<FRAGEN; i++) { 
        /*                     
        Zu Beginn fangen wir mit was Einfachem an
        */                                       
        if (i <= fallback[0]) {                  
            if (i == 0) {                        
                for (k=0; k<FRAGEN/3; k++) {     
                    alt[k] = -1;                 
                }                                
                j=0;                             
            }                                    
            /*erst ne frage ziehen, die es noch nicht gibt*/
            ziehen = frage_ziehen(anz_easy, alt, j++);      
            /*dann die passende frage anzeigen und evtl den joker loeschen*/
            if (frage_zeigen(easy, ziehen, i, joker) == 1) joker = 0;       
        }                                                                   
        /*                                                                  
        Nach der ersten Huerde jetzt die mittleren Fragen                   
        */                                                                  
        else if (i <= fallback[1]) {                                        
            /*wenn die erste frage des neuen bereiches*/                    
            if (i == fallback[0]+1) {                                       
                printf("* * * * * * * * * * * * * * * *\n");                
                printf("*    %5i EUR gesichert      *\n",stufe[fallback[0]]);
                printf("* * * * * * * * * * * * * * * *\n\n");               
                sleep(3);                                                    
                printf("\nNach der Werbung nun die mittleren Fragen...\n\n");
                /*array wieder initialisieren, damit keine fragen rausfliegen*/
                for (k=0; k<FRAGEN/3; k++) {                                   
                    alt[k] = -1;                                               
                }                                                              
                /*wieder auf pos 0 setzen*/                                    
                j=0;                                                           
            }                                                                  
            /*Fragen Nr ziehen*/                                               
            ziehen = frage_ziehen(anz_medium, alt, j++);                       
            /*frage anzeigen*/                                                 
            if (frage_zeigen(medium, ziehen, i, joker) == 1) joker = 0;
        }
        /*
        Nach der zweiten Huerde zum schluss die schweren fragen
        */
        else {
            /*wenn die erste frage des neuen bereiches, dann speicherarray leeren*/
            if (i == fallback[1]+1) {
                printf("* * * * * * * * * * * * * * * *\n");
                printf("*    %i EUR gesichert   *\n",stufe[fallback[1]]);
                printf("* * * * * * * * * * * * * * * *\n\n");
                printf("\nNach der Werbung nun die schweren Fragen...\n\n");
                sleep(3);
                /*array wieder initialisieren, damit keine fragen rausfliegen*/
                for (k=0; k<FRAGEN/3; k++) {
                    alt[k] = 0;
                }
                /*wieder auf pos 0 setzen*/
                j=0;
            }
            /*Fragen Nr ziehen*/
            ziehen = frage_ziehen(anz_hard, alt, j++);
            /*frage anzeigen*/
            if (frage_zeigen(hard, ziehen, i, joker) == 1) joker = 0;
        }
    }
    printf("\nDas wars bei \"Wer wir Millionaer\"\n");
return 0;
}

Seiten-Werkzeuge