439 lines
12 KiB
C
439 lines
12 KiB
C
/* 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;
|
|
} |