/* Ramen_Physik.c
Hier werden Physikaufgaben gelöst mit einem Spiel als Pause

Autor: Jana Nieblas, Debora Semmler
Firma: FHGR
Version 1.0
Datum 11.12.2024
Aenderungen:
V 1.0 11.12.2024 Erste Version
*/

// Einbindung Bibliotheken
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#include <unistd.h>
#ifdef _WIN32
#include <windows.h>
#endif

// Einbindung Dateien
#include "Tic_Tac_Toe.h"

//Definitionen
#define max_anzahl_fehler 3

// Abfrage Antworten
int antwort (int loesung, int *falsche_antwort){

    while (1)
    {
        int eingabe;
        scanf("%d", &eingabe);

        if (eingabe == loesung)
        {
            printf("Richtige Antwort \n");
            return 0;
        }

        else {
            printf("Falsche antwort \n");
            *falsche_antwort += 1;
           if (*falsche_antwort >= max_anzahl_fehler) {
                printf("Zu viele ungültige Eingaben. Programm beendet.\n");

                fflush(stdout);
                //Sleep
                #ifdef __linux__
                    sleep(2);
                #elif _WIN32
                    // Sleep ist in Milisekunden
                    Sleep(2 * 1000);
                #endif

                return 20;
            }
        }    
    }
}

// Zufällige Ausgabe der Fragen
int zufaellig(int maximum){
    int n = rand() % maximum;
    return n;
}

//einfache Fragen
int einfache_fragen(int *falsche_antwort){

    //Variabeln
    const int anzahl_fragen = 8;
    int fragen[3] = {-1, -1,-1};
    int return_code = 0;
    int x = 0;

    //Lösungseingabe
    printf("Gib '1' ein falls die Aussage wahr ist und '2' falls die Aussage falsch ist. \n \n");

    //abfragen der verwendeten Fragen
    for (int i = 0; i < 3; i++)
    {
        
        while (1)      
        {
            x = zufaellig(anzahl_fragen);

            if (x != fragen[0] && x != fragen[1] && x != fragen[2])
            {
                break;
            }
            
        }
        
        fragen[i]=x;

        //Fragen
        switch (x)
        {
        case 0 :
            printf("Der relative Fehler ist eine Grösse ohne Masseinheit. \n");
            return_code = antwort(1, falsche_antwort);
            break;

        case 1 :
            printf("Es gilt 10^-12 nm = 1 km  \n");
            return_code = antwort(2, falsche_antwort);
            break;

        case 2 :
            printf("Die Gewichtskraft eines Objektes steigt linear mit dessen Masse. \n");
            return_code = antwort(1, falsche_antwort);
            break;

        case 3 :
            printf("Ein Druck kann sowohl in Flüssigkeiten als auch in Gasen herrschen. \n");
            return_code = antwort(1, falsche_antwort);
            break;

        case 4 :
            printf("Der Luftdruck auf Meereshöhe beträgt ca. 10 bar.  \n");
            return_code = antwort(2, falsche_antwort);
            break;

        case 5 :
            printf("Die barometrische Höhenformel gilt unter der Annahme, dass die Luft in der Atmosphäre überall die gleiche Temperatur hat. \n");
            return_code = antwort(1, falsche_antwort);
            break;

        case 6 :
            printf("Es gilt ∆W = mg ∆h, wenn man Reibung und Luftwiderstand vernachlässigt. \n");
            return_code = antwort(1, falsche_antwort);
            break;

        case 7 :
            printf("Wird eine Kugel von einer an der Wand befestigten Feder horizontal weggeschleudert wird, dann wird die elastische Energie in kinetische Energie umgewandelt.  \n");
            return_code = antwort(1, falsche_antwort);
            break;

        default:
            break;
        }

        if (return_code == 20)
        {
            return 20;
        }
        
    }
    return 10;
}

//mittlere Fragen
int mittlere_fragen(int *falsche_antwort){

    //Variabeln
    const int anzahl_fragen = 8;
    int fragen[3] = {-1, -1,-1};
    int return_code = 0;
    int x = 0;

    //Lösungseingabe
    printf("Gib '1' ein falls die Aussage wahr ist und '2' falls die Aussage falsch ist. \n \n");

    //abfragen verwendeter Fragen
    for (int i = 0; i < 3; i++)
    {
        
        while (1)      
        {
            x = zufaellig(anzahl_fragen);

            if (x != fragen[0] && x != fragen[1] && x != fragen[2])
            {
                break;
            }
            
        }
        
        fragen[i]=x;

        //Fragen
        switch (x)
        {
        case 0 :
            printf("In der Physik sind weltweit ausschliesslich SI-Einheiten in Gebrauch. \n");
            return_code = antwort(2, falsche_antwort);
            break;

        case 1 :
            printf("Das Prinzip actio et reactio ist eine Folge des Impuls-Erhaltungssatzes. \n");
            return_code = antwort(1, falsche_antwort);
            break;

        case 2 :
            printf("Befindet sich ein Körper im Stillstand, dann wirkt überhaupt keine Kraft auf ihn. \n");
            return_code = antwort(2, falsche_antwort);
            break;

        case 3 :
            printf("Verdoppelt man den Steigungswinkel einer Rampe, dann verdoppelt man auch ihre Steigung.  \n");
            return_code = antwort(2, falsche_antwort);
            break;

        case 4 :
            printf("Die Ruhepunkt-Methode basiert auf dem Newton-Aktionsprinzip.  \n");
            return_code = antwort(1, falsche_antwort);
            break;

        case 5 :
            printf("Mit Hilfe der Ruhepunkt-Methode erkennt man, ob die berechneten Kräfte eine Belastung auf Zug oder Druck bedeuten.  \n");
            return_code = antwort(1, falsche_antwort);
            break;

        case 6 :
            printf("Für jede Bewegung ist die geleistete Arbeit gleich der Fläche im s-F-Diagramm zwischen dem Graphen von F(s) und der s-Achse \n");
            return_code = antwort(1, falsche_antwort);
            break;

        case 7 :
            printf("Die Leistung quantifiziert den Energiestrom, d.h. die übertragene Energie pro Zeiteinheit auf ein Objekt.  \n");
            return_code = antwort(1, falsche_antwort);
            break;

        default:
            break;
        }

        if (return_code == 20)
        {
            return 20;
        }
        
    }
    return 10;
}

//schwere Fragen
int schwere_fragen(int *falsche_antwort){

    //Variabeln
    const int anzahl_fragen = 8;
    int fragen[3] = {-1, -1,-1};
    int return_code = 0;
    int x = 0;

    //Lösungseingabe
    printf("Gib '1' ein falls die Aussage wahr ist und '2' falls die Aussage falsch ist. \n \n");

    //abfragen verwendeter Fragen
    for (int i = 0; i < 3; i++)
    {
        
        while (1)      
        {
            x = zufaellig(anzahl_fragen);

            if (x != fragen[0] && x != fragen[1] && x != fragen[2])
            {
                break;
            }
            
        }
        
        fragen[i]=x;

        //Fragen
        switch (x)
        {
        case 0 :
            printf("Die 7 SI-Basis-Einheiten orientieren sich an den Grössenordnungen der Menschen.  \n");
            return_code = antwort(1, falsche_antwort);
            break;

        case 1 :
            printf("Die Ursache des Impuls-Erhaltungssatzes ist die Zeitunabhängigkeit der physikalischen Gesetze.  \n");
            return_code = antwort(2, falsche_antwort);
            break;

        case 2 :
            printf("Der Begriff Kraft quantifiziert den Impulsstrom, d.h. den Impulsübertrag pro Zeiteinheit auf ein Objekt.  \n");
            return_code = antwort(1, falsche_antwort);
            break;

        case 3 :
            printf("Wirkt auf ein fahrendes Auto nur der turbulente Strömungswiderstand, dann wird es gleichförmig abgebremst. \n");
            return_code = antwort(2, falsche_antwort);
            break;

        case 4 :
            printf("Die Leistung eines Blitzschlages kann die Leistung eines Grosskraftwerkes weit übertreffen.  \n");
            return_code = antwort(1, falsche_antwort);
            break;

        case 5 :
            printf("Wird ein Körper von der Geschwindigkeit v0 < 0 mit konstanter Leistung P auf eine Geschwindigkeit vE < v0 beschleunigt, dann gilt P < 0. \n");
            return_code = antwort(2, falsche_antwort);
            break;

        case 6 :
            printf("Ist die Beschleunigungsfunktion eines Objektes strikt negativ, d.h. gilt a(t) < 0 zu jeder Zeit t ≥ t0, dann bewegt sich das Objekt zu jeder Zeit t ≥ t0 in Rückwärtsrichtung (negative Bewegungsrichtung). \n");
            return_code = antwort(2, falsche_antwort);
            break;

        case 7 :
            printf("Es seien ∆t = tE - t0, ∆s = sE - s0 und ∆v = vE - v0. Dann gilt für jede Bewegung v(t) = ∆s/∆t und a(t) = ∆v/∆t. \n");
            return_code = antwort(2, falsche_antwort);
            break;

        default:
            break;
        }

        if (return_code == 20)
        {
            return 20;
        }
        
    }
    return 10;
}


// Hauptunktionen                                                            
int Ramen_Physik(){

    // Umlaute
    system("chcp 65001 >null");

    // Zufallsgenerator initialisieren
    srand(time(NULL));

    //Variabeln
    char eingabe = '0';
    int return_code = 0;
    int falsche_antwort = 0;

    while (1){
        //löschen der Konsole
        printf("\e[1;1H\e[2J");

        //Auswahl der Schwierigkeitsstufe
        printf("1 \t einfache Fragen \n");
        printf("2 \t mittlere Fragen \n");
        printf("3 \t schwere Fragen \n");
        printf("q \t zurück zum Hauptmenu \n");

        scanf("%c", &eingabe);

        //Abfrage der Eingabe
        switch (eingabe){
            case '1':{
                printf("\neinfache Fragen\n");
                return_code = einfache_fragen(&falsche_antwort);
                break;
            }
            case '2':{
                printf("\nmittlere Fragen\n");
                return_code = mittlere_fragen(&falsche_antwort);
                break;
            }
            case '3':{
                printf("\nschwere Fragen\n");
                return_code = schwere_fragen(&falsche_antwort);
                break;
            }
            case '4':{
                Tic_Tac_Toe();

                fflush(stdout);
                //Sleep
                #ifdef __linux__
                    sleep(2);
                #elif _WIN32
                // Sleep ist in Milisekunden
                    Sleep(2 * 1000);
                #endif

                break;
            }

            case 'q':{
                printf("\nProgramm beendet \n");

                fflush(stdout);
                //Sleep
                #ifdef __linux__
                    sleep(2);
                #elif _WIN32
                // Sleep ist in Milisekunden
                    Sleep(2 * 1000);
                #endif

                return 10;
                break;
            }

            case '\n':{
                break;

            }
            default: {
                printf("Zu viele ungültige Eingaben. Programm beendet.\n");

                fflush(stdout);
                //Sleep
                #ifdef __linux__
                    sleep(2);
                #elif _WIN32
                    // Sleep ist in Milisekunden
                    Sleep(2 * 1000);
                #endif

                return 20;
            }
        }

        switch (return_code){
          case 10: { 
            Tic_Tac_Toe(); 

            fflush(stdout);
            //Sleep
            #ifdef __linux__
                sleep(2);
            #elif _WIN32
                // Sleep ist in Milisekunden
                Sleep(2 * 1000);
            #endif

            return_code = 0; 
            break;
          }
          case 20: return 20; break; 
        }
    }
    return 0;
}