straubruben
/
Photonics-Helfer
forked from zwickethomas/Photonics-Helfer
1
0
Fork 0
Code Pull Requests Activity

cleanup

main
MuedeHydra 2024-12-16 15:44:35 +01:00
parent dc829019bc
commit 4dba346f0c
14 changed files with 0 additions and 1807 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

413
src/Fehlenden_Elektronik.c
View File

@ -1,413 +0,0 @@
/* Elektronikhelper
Dieses Programm ist eine Unterstzützung in der Elektronik.
Es berechnet leichte rechnungsschritte.
Autor: Elena und Philip MR1 Semester
Firma: FHGR
Version 1.0
Datum 14.12.2024
Aenderungen:
V 1.0 14.12.2024 Erste Version
*/
// Bibliothek
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
// Hilfsfunktionen
#define PI 3.141592653589793
#define BOLTZMANN 1.380649e-23
#define ELEMENTARLADUNG 1.602176634e-19
// Funktionen für Widerstandsberechnungen
void widerstand_berechnen() {
double spannung, strom, widerstand;
int auswahl;
printf("\nWiderstandsberechnung (Ohmsches Gesetz):\n");
printf("1. Widerstand berechnen\n");
printf("2. Spannung berechnen\n");
printf("3. Strom berechnen\n");
printf("Wählen Sie eine Option: ");
scanf("%d", &auswahl);
switch (auswahl) {
case 1:
printf("Spannung (in Volt): ");
scanf("%lf", &spannung);
printf("Strom (in Ampere): ");
scanf("%lf", &strom);
if (strom != 0) {
widerstand = spannung / strom;
printf("Der Widerstand beträgt %.2f Ohm.\n", widerstand);
} else {
printf("Der Strom darf nicht null sein.\n");
}
break;
case 2:
printf("Widerstand (in Ohm): ");
scanf("%lf", &widerstand);
printf("Strom (in Ampere): ");
scanf("%lf", &strom);
if (widerstand > 0) {
spannung = widerstand * strom;
printf("Die Spannung beträgt %.2f Volt.\n", spannung);
} else {
printf("Der Widerstand muss größer als null sein.\n");
}
break;
case 3:
printf("Spannung (in Volt): ");
scanf("%lf", &spannung);
printf("Widerstand (in Ohm): ");
scanf("%lf", &widerstand);
if (widerstand > 0) {
strom = spannung / widerstand;
printf("Der Strom beträgt %.2f Ampere.\n", strom);
} else {
printf("Der Widerstand muss größer als null sein.\n");
}
break;
default:
printf("Ungültige Auswahl.\n");
}
}
void parallelschaltung_berechnen() {
int anzahl;
double widerstand, gesamtwiderstand = 0;
printf("\nParallelschaltung von Widerständen:\n");
printf("Anzahl der Widerstände: ");
scanf("%d", &anzahl);
for (int i = 0; i < anzahl; i++) {
printf("Widerstand %d (in Ohm): ", i + 1);
scanf("%lf", &widerstand);
if (widerstand > 0) {
gesamtwiderstand += 1 / widerstand;
} else {
printf("Ein Widerstand muss größer als null sein.\n");
return;
}
}
if (gesamtwiderstand > 0) {
gesamtwiderstand = 1 / gesamtwiderstand;
printf("Der Gesamtwiderstand der Parallelschaltung beträgt %.2f Ohm.\n", gesamtwiderstand);
}
}
void reihenschaltung_berechnen() {
int anzahl;
double widerstand, gesamtwiderstand = 0;
printf("\nReihenschaltung von Widerständen:\n");
printf("Anzahl der Widerstände: ");
scanf("%d", &anzahl);
for (int i = 0; i < anzahl; i++) {
printf("Widerstand %d (in Ohm): ", i + 1);
scanf("%lf", &widerstand);
if (widerstand > 0) {
gesamtwiderstand += widerstand;
} else {
printf("Ein Widerstand muss größer als null sein.\n");
return;
}
}
printf("Der Gesamtwiderstand der Reihenschaltung beträgt %.2f Ohm.\n", gesamtwiderstand);
}
void komplexe_schaltung_berechnen() {
int anzahlReihen, anzahlParallel;
double reihenWiderstand = 0, parallelWiderstand = 0, gesamtwiderstand = 0;
printf("\nBerechnung komplexer Netzwerke:\n");
// Reihenschaltung
printf("Anzahl der Widerstände in der Reihenschaltung: ");
scanf("%d", &anzahlReihen);
for (int i = 0; i < anzahlReihen; i++) {
double widerstand;
printf("Widerstand %d (in Ohm): ", i + 1);
scanf("%lf", &widerstand);
if (widerstand > 0) {
reihenWiderstand += widerstand;
} else {
printf("Ein Widerstand muss größer als null sein.\n");
return;
}
}
// Parallelschaltung
printf("Anzahl der Widerstände in der Parallelschaltung: ");
scanf("%d", &anzahlParallel);
for (int i = 0; i < anzahlParallel; i++) {
double widerstand;
printf("Widerstand %d (in Ohm): ", i + 1);
scanf("%lf", &widerstand);
if (widerstand > 0) {
parallelWiderstand += 1 / widerstand;
} else {
printf("Ein Widerstand muss größer als null sein.\n");
return;
}
}
if (parallelWiderstand > 0) {
parallelWiderstand = 1 / parallelWiderstand;
}
// Gesamtwiderstand
gesamtwiderstand = reihenWiderstand + parallelWiderstand;
printf("Der Gesamtwiderstand des Netzwerks beträgt %.2f Ohm.\n", gesamtwiderstand);
}
// Spannungsteiler-Funktion
void spannungsteiler_berechnen() {
int anzahl;
double vin, vout, gesamtwiderstand = 0;
printf("\nSpannungsteiler-Berechnung:\n");
printf("Anzahl der Widerstände im Spannungsteiler: ");
scanf("%d", &anzahl);
double widerstaende[anzahl];
for (int i = 0; i < anzahl; i++) {
printf("Widerstand R%d (in Ohm): ", i + 1);
scanf("%lf", &widerstaende[i]);
gesamtwiderstand += widerstaende[i];
}
printf("Eingangsspannung Vin (in Volt): ");
scanf("%lf", &vin);
for (int i = 0; i < anzahl; i++) {
vout = vin * (widerstaende[i] / gesamtwiderstand);
printf("Spannung über R%d beträgt %.2f Volt.\n", i + 1, vout);
}
}
// Leistungsberechnung
void leistung_berechnen() {
double spannung, strom, leistung;
int auswahl;
printf("\nLeistungsberechnung:\n");
printf("1. Leistung berechnen (benötigt Spannung und Strom)\n");
printf("2. Spannung berechnen (benötigt Leistung und Strom)\n");
printf("3. Strom berechnen (benötigt Leistung und Spannung)\n");
printf("Wählen Sie eine Option: ");
scanf("%d", &auswahl);
switch (auswahl) {
case 1:
printf("Spannung (in Volt): ");
scanf("%lf", &spannung);
printf("Strom (in Ampere): ");
scanf("%lf", &strom);
leistung = spannung * strom;
printf("Die Leistung beträgt %.2f Watt.\n", leistung);
break;
case 2:
printf("Leistung (in Watt): ");
scanf("%lf", &leistung);
printf("Strom (in Ampere): ");
scanf("%lf", &strom);
if (strom > 0) {
spannung = leistung / strom;
printf("Die Spannung beträgt %.2f Volt.\n", spannung);
} else {
printf("Der Strom muss größer als null sein.\n");
}
break;
case 3:
printf("Leistung (in Watt): ");
scanf("%lf", &leistung);
printf("Spannung (in Volt): ");
scanf("%lf", &spannung);
if (spannung > 0) {
strom = leistung / spannung;
printf("Der Strom beträgt %.2f Ampere.\n", strom);
} else {
printf("Die Spannung muss größer als null sein.\n");
}
break;
default:
printf("Ungültige Auswahl.\n");
}
}
// Weitere Funktionen (Dioden, Transistoren, Kondensatoren, LEDs, Knoten-/Maschenregel)
void dioden_berechnen() {
double temperatur, schwellenspannung, is, strom;
printf("\nDioden-Berechnung:\n");
printf("Geben Sie die Temperatur (in Kelvin) ein: ");
scanf("%lf", &temperatur);
printf("Geben Sie den Sättigungsstrom Is (in Ampere) ein: ");
scanf("%lf", &is);
printf("Geben Sie die Schwellenspannung der Diode (in Volt) ein: ");
scanf("%lf", &schwellenspannung);
double vt = (BOLTZMANN * temperatur) / ELEMENTARLADUNG;
strom = is * (exp(schwellenspannung / vt) - 1);
printf("Der Strom durch die Diode beträgt %.6f Ampere.\n", strom);
}
void transistor_berechnen() {
double verstaerkung, basisstrom, kollektorstrom, saettigungsspannung;
printf("\nTransistor-Berechnung:\n");
printf("Verstärkungsfaktor (hFE): ");
scanf("%lf", &verstaerkung);
printf("Basisstrom (in Ampere): ");
scanf("%lf", &basisstrom);
kollektorstrom = verstaerkung * basisstrom;
printf("Der Kollektorstrom beträgt %.6f Ampere.\n", kollektorstrom);
printf("Sättigungsspannung (in Volt): ");
scanf("%lf", &saettigungsspannung);
printf("Die Sättigungsspannung beträgt %.2f Volt.\n", saettigungsspannung);
}
void kondensator_berechnen() {
double kapazitaet, spannung, energie, zeit, widerstand;
printf("\nKondensator-Berechnung:\n");
printf("kapazität (in Farad): ");
scanf("%lf", &kapazitaet);
printf("Spannung (in Volt): ");
scanf("%lf", &spannung);
energie = 0.5 * kapazitaet * pow(spannung, 2);
printf("Die Energie im Kondensator beträgt %.6f Joule.\n", energie);
printf("Entladezeit berechnen? (1 für Ja, 0 für Nein): ");
int wahl;
scanf("%d", &wahl);
if (wahl == 1) {
printf("Widerstand (in Ohm): ");
scanf("%lf", &widerstand);
zeit = kapazitaet * widerstand;
printf("Die Zeitkonstante betraegt %.2f Sekunden.\n", zeit);
}
}
void led_vorwiderstand_berechnen() {
double betriebsspannung, durchlassspannung, strom, vorwiderstand, verlustleistung;
printf("\nLED-Vorwiderstandsberechnung:\n");
printf("Betriebsspannung (in Volt): ");
scanf("%lf", &betriebsspannung);
printf("Durchlassspannung der LED (in Volt): ");
scanf("%lf", &durchlassspannung);
printf("Strom durch die LED (in Ampere): ");
scanf("%lf", &strom);
vorwiderstand = (betriebsspannung - durchlassspannung) / strom;
verlustleistung = pow((betriebsspannung - durchlassspannung), 2) / vorwiderstand;
printf("Der Vorwiderstand beträgt %.2f Ohm.\n", vorwiderstand);
printf("Die maximale Verlustleistung des Widerstands beträgt %.2f Watt.\n", verlustleistung);
}
void knotenregel_berechnen() {
int n; // Anzahl der Ströme und Spannungen
float sum_current = 0.0, current;
// Knotenregel: Ströme berechnen
printf("Geben Sie die Anzahl der Stroeme ein im Knoten: ");
scanf("%d", &n);
printf("Geben Sie die Stroeme ein (in Ampere):\n");
for (int i = 1; i <= n; i++) {
printf("Strom %d: ", i);
scanf("%f", &current);
sum_current += current; // Ströme addieren
}
printf("\nSumme der Ströme: %.2f A\n", sum_current);
if (sum_current == 0) {
printf("Der Knoten erfüllt die Knotenregel (Summe der Ströme ist null).\n");
} else {
printf("Der Knoten erfüllt die Knotenregel nicht (Summe der Ströme ist %.2f).\n", sum_current);
}
}
void maschenregel_berechnen() {
int n; // Anzahl der Ströme und Spannungen
float sum_voltage = 0.0, voltage;
// Maschenregel: Spannungen berechnen
printf("\nGeben Sie die Anzahl der Spannungen in einer Masche ein: ");
scanf("%d", &n);
printf("Geben Sie die Spannungen ein (in Volt):\n");
for (int i = 1; i <= n; i++) {
printf("Spannung %d: ", i);
scanf("%f", &voltage);
sum_voltage += voltage; // Spannungen addieren
}
// Überprüfung der Maschenregel
printf("\nSumme der Spannungen: %.2f V\n", sum_voltage);
if (sum_voltage == 0) {
printf("Die Masche erfüllt die Maschenregel (Summe der Spannungen ist null).\n");
} else {
printf("Die Masche erfüllt die Maschenregel nicht (Summe der Spannungen ist %.2f).\n", sum_voltage);
}
}
int Fehlenden_Elektronik_main() {
char auswahl[21] = {0};
long auswahl_int = 0;
char *endptr;
do {
printf("\nElektronik-Berechnungstool:\n");
printf("1. Widerstandsberechnung (Ohmsches Gesetz)\n");
printf("2. Parallelschaltung von Widerständen\n");
printf("3. Reihenschaltung von Widerständen\n");
printf("4. Komplexe Netzwerke\n");
printf("5. Spannungsteiler\n");
printf("6. Leistungsberechnung\n");
printf("7. Dioden-Berechnung\n");
printf("8. Transistor-Berechnung\n");
printf("9. Kondensator-Berechnung\n");
printf("10. LED-Vorwiderstandsberechnung\n");
printf("11. Knotenregel-Berechnung\n");
printf("12. Maschenregel-Berechnung\n");
printf("0. Beenden\n");
printf("Wählen Sie eine Option: ");
scanf("%20s", auswahl);
auswahl_int = strtol((const char*)auswahl, &endptr, 10);
if (*endptr != 0){
auswahl_int = -1;
}
if (*endptr == 'q'){
return 10;
}
switch (auswahl_int) {
case 1: widerstand_berechnen(); break;
case 2: parallelschaltung_berechnen(); break;
case 3: reihenschaltung_berechnen(); break;
case 4: komplexe_schaltung_berechnen(); break;
case 5: spannungsteiler_berechnen(); break;
case 6: leistung_berechnen(); break;
case 7: dioden_berechnen(); break;
case 8: transistor_berechnen(); break;
case 9: kondensator_berechnen(); break;
case 10: led_vorwiderstand_berechnen(); break;
case 11: knotenregel_berechnen(); break;
case 12: maschenregel_berechnen(); break;
case 0: printf("Programm beendet.\n"); break;
default: printf("Ungültige Auswahl.\n");
}
} while (auswahl_int != 0);
return 0;
}

10
src/Fehlenden_Elektronik.h
View File

@ -1,10 +0,0 @@
#ifndef Fehlenden_Elektronik_H_
#define Fehlenden_Elektronik_H_
// #ifndef _FILE_NAME_H_
// #define _FILE_NAME_H_
// extern int kbhit();
int Fehlenden_Elektronik_main();
#endif

439
src/Ramen_Physik.c
View File

@ -1,439 +0,0 @@
/* 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;
}

18
src/Ramen_Physik.h
View File

@ -1,18 +0,0 @@
/* Ramen_Physik.h
Hier werden Physikaufgaben gelöst mit einem Spiel als Pause
Autor: Jana Nieblas
Firma: FHGR
Version 1.0
Datum 15.12.2024
Aenderungen:
V 1.0 15.12.2024 Erste Version
*/
#ifndef _FILE_NAME_H_
#define _FILE_NAME_H_
//extern Phxsik mit Spiel;
extern int Ramen_Physik();
#endif

187
src/Tic_Tac_Toe.c
View File

@ -1,187 +0,0 @@
/* Tic Tac Toe
Ein einfaches Tic Tac Toe programm
Autor: Debora Semmler
Firma: FHGR
Version: 1.0
Datum: 13.12.2024
Aenderungen:
V 1.0 13.12.2024 Erste Version
*/
// Einbinden von Headerdateien der Programmbibliothek.
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <time.h>
//Definition von Spielfeld und Symbolen
char board[3][3];
const char PLAYER = 'O';
const char COMPUTER = 'X';
//Funktionsprototypen
void resetBoard();
void printBoard();
int checkFreeSpaces();
void playerMoves();
void computerMoves();
char checkWinner();
void printWinner(char);
//Das Hauptprogramm
int Tic_Tac_Toe()
{
printf("Du spielst mit O und der Computer mit X \n \n");
char winner = ' ';
resetBoard();
while(winner == ' ' && checkFreeSpaces() != 0)
{
printBoard();
playerMoves();
winner = checkWinner();
if(winner != ' ' || checkFreeSpaces() == 0){
break;
}
computerMoves();
winner = checkWinner();
if(winner != ' ' || checkFreeSpaces() == 0){
break;
}
}
printBoard();
printWinner(winner);
// Rückgabewert, dass das Programm erfolgreich beendet wurde.
return 0;
}
void resetBoard(){
for(int i = 0; i<3; i++)
{
for(int j = 0; j<3; j++)
{
board[i][j] = ' ';
}
}
}
//Gibt das Spielfeld aus
void printBoard(){
printf("[ %c ][ %c ][ %c ]\n", board[0][0], board[0][1], board[0][2]);
printf("[ %c ][ %c ][ %c ]\n", board[1][0], board[1][1], board[1][2]);
printf("[ %c ][ %c ][ %c ]\n", board[2][0], board[2][1], board[2][2]);
}
//Zählt die freien Felder auf dem Spielfeld
int checkFreeSpaces(){
int freeSpaces = 9;
for(int i = 0; i<3; i++)
{
for(int j = 0; j<3; j++)
{
if(board[i][j] != ' ')
{
freeSpaces--;
}
}
}
return freeSpaces;
}
//Ernöglicht dem Spieler einen Zug zu machen
void playerMoves(){
int x;
int y;
do
{
printf("Gibt die Horizontale ein (1-3): ");
scanf("%d", &x);
x--;
printf("Gib die Vertikale ein (1-3): ");
scanf("%d", &y);
y--;
if(board[x][y] != ' ')
{
printf("Ungültig!\n");
}
else{
board[x][y] = PLAYER;
break;
}
} while (board[x][y] != ' ');
}
//Der Computer macht einen Zufallszug
void computerMoves(){
//Seed für Zufallszahlen
srand(time(0));
int x;
int y;
if(checkFreeSpaces() > 0){
do
{
x = rand() % 3;
y = rand() % 3;
} while (board[x][y] != ' ');
board[x][y] = COMPUTER;
}
else{
printWinner(' ');
}
}
//Überprüft die Gewinn bedingungen
char checkWinner(){
//Prüft nach horizontalen Gewinnbedingungen
for(int i = 0; i < 3; i ++){
if(board[i][0] == board[i][1] && board[i][0] == board[i][2]){
return board[i][0];
}
}
//Prüft nach vertikalen Gewinnbedingungen
for(int i = 0; i < 3; i ++){
if(board[0][i] == board[1][i] && board[0][i] == board[2][i]){
return board[0][i];
}
}
//Prüft nach diagonalen Gewinnbedingungen
if(board[0][0] == board[1][1] && board[0][0] == board[2][2]){
return board[0][0];
}
if(board[0][2] == board[1][1] && board[0][2] == board[2][0]){
return board[0][2];
}
return ' ';
}
//Gibt das Ergebnis des Spieldurchgangs aus
void printWinner(char winner){
if(winner == PLAYER){
printf("DU HAST GEWONNEN!");
}
else if(winner == COMPUTER){
printf("DU HAST VERLOREN!");
}
else{
printf("ES IST EIN UNENTSCHIEDEN!");
}
}

18
src/Tic_Tac_Toe.h
View File

@ -1,18 +0,0 @@
/* Ramen_Physik.h
Hier wir das Spiel als Pause verknüpft
Autor: Jana Nieblas
Firma: FHGR
Version 1.0
Datum 15.12.2024
Aenderungen:
V 1.0 15.12.2024 Erste Version
*/
#ifndef _FILE_NAME_H_
#define _FILE_NAME_H_
//extern Spiel;
extern int Tic_Tac_Toe();
#endif

34
src/kbhit_linux.c
View File

@ -1,34 +0,0 @@
#ifdef __linux__
#include <stdio.h>
#include <termios.h>
#include <unistd.h>
#include <fcntl.h>
int kbhit(void)
{
struct termios oldt, newt;
int ch;
int oldf;
tcgetattr(STDIN_FILENO, &oldt);
newt = oldt;
newt.c_lflag &= ~(ICANON | ECHO);
tcsetattr(STDIN_FILENO, TCSANOW, &newt);
oldf = fcntl(STDIN_FILENO, F_GETFL, 0);
fcntl(STDIN_FILENO, F_SETFL, oldf | O_NONBLOCK);
ch = getchar();
tcsetattr(STDIN_FILENO, TCSANOW, &oldt);
fcntl(STDIN_FILENO, F_SETFL, oldf);
if(ch != EOF)
{
ungetc(ch, stdin);
return 1;
}
return 0;
}
#endif

6
src/kbhit_linux.h
View File

@ -1,6 +0,0 @@
#ifndef KBHIT_LINUX_H_
#define KBHIT_LINUX_H_
int kbhit();
#endif

109
src/pipes2.c
View File

@ -1,109 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <unistd.h>
#include <time.h>
// #include <termios.h>
// #include <fcntl.h>
#ifdef __linux__
#include "kbhit_linux.h"
#elif _WIN32
#include <windows.h>
#include <conio.h>
#endif
#define GRID_GROESSE_X 200
#define GRID_GROESSE_Y 60
#define SLEEP_TIME 40000
#define RED "\033[31m"
#define GREEN "\033[32m"
#define YELLOW "\033[33m"
#define BLUE "\033[34m"
#define MAGENTA "\033[35m"
#define CYAN "\033[36m"
#define WHITE "\033[37m"
const char *colors2[] = {RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE};
int randome(int max){
return rand() % max;
}
void print_at(int x, int y, char c[4], char color)
{
printf("%s\033[%d;%dH%s", colors2[color], y, x, c);
}
char print_pipe(int *x, int *y, int x_max, int y_max, int length, char direction, char direction_old, char *color){
if ((direction == 0 && direction_old == 1) || (direction == 1 && direction_old == 0)){
return direction_old;
} else if ((direction == 2 && direction_old == 3) || (direction == 3 && direction_old == 2)){
return direction_old;
}
bool start = true;
for(int i = 0; i < length; i++){
if (start && direction != direction_old){
switch (direction_old){
case 0: *y -= 1; if (*y <= 0){ *y = y_max; *color = randome(7); } break; // up
case 1: *y += 1; if (*y > y_max){ *y = 0; *color = randome(7); } break; // down
case 2: *x -= 1; if (*x <= 0){ *x = x_max; *color = randome(7); } break; // left
case 3: *x += 1; if (*x >= x_max){ *x = 0; *color = randome(7); } break; // rigth
}
if ((direction == 2 && direction_old == 0) || (direction == 1 && direction_old == 3)){
print_at(*x, *y, "┓", *color);
} else if ((direction == 0 && direction_old == 2) || (direction == 3 && direction_old == 1)) {
print_at(*x, *y, "┗", *color);
} else if ((direction == 3 && direction_old == 0) || (direction == 1 && direction_old == 2)) {
print_at(*x, *y, "┏", *color);
} else if ((direction == 0 && direction_old == 3) || (direction == 2 && direction_old == 1)) {
print_at(*x, *y, "┛", *color);
} // else { printf("\nd = %i | d_o = %i\n", direction, direction_old); }
start = false;
} else {
switch (direction){
case 0: *y -= 1; if (*y <= 0){ *y = y_max; *color = randome(7); } break; // up
case 1: *y += 1; if (*y > y_max){ *y = 0; *color = randome(7); } break; // down
case 2: *x -= 1; if (*x <= 0){ *x = x_max; *color = randome(7); } break; // left
case 3: *x += 1; if (*x >= x_max){ *x = 0; *color = randome(7); } break; // rigth
}
if (direction <= 1) {
print_at(*x, *y, "┃", *color);
} else {
print_at(*x, *y, "━", *color);
}
}
fflush(stdout);
usleep(SLEEP_TIME);
}
return direction;
}
int pipes_2(int width, int height){
int x_max = width;
int y_max =height;
int x = width / 2;
int y = height / 2;
char direction_old = 0;
char color = 6;
int start_time = 0;
srand(time(0));
while(!kbhit()){
if (start_time + 20 <= time(0)){
printf("\e[1;1H\e[2J"); // clear terminal
start_time = time(0);
}
direction_old = print_pipe(&x, &y, x_max, y_max, randome(height / 3) + 1, randome(4), direction_old, &color);
}
// ist dazu da um "\n" aus dem buffer zu entfernen!
getchar();
printf("\033[00m"); // Farbe zurücksetzen
return 0;
}

10
src/pipes2.h
View File

@ -1,10 +0,0 @@
#ifndef pipes2_H_
#define pipes2_H_
// #ifndef _FILE_NAME_H_
// #define _FILE_NAME_H_
// extern int pipes(int width, int height);
int pipes_2(int width, int height);
#endif

158
src/pipes2_game.c
View File

@ -1,158 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <unistd.h>
#include <time.h>
#ifdef __linux__
#include <sys/ioctl.h>
#include <unistd.h>
#include <termio.h>
#elif _WIN32
#include <windows.h>
#include <conio.h>
#endif
// #include <termios.h>
// #include <fcntl.h>
#ifdef __linux__
#include "kbhit_linux.h"
#elif _WIN32
#include <windows.h>
#include <conio.h>
#endif
#define GRID_GROESSE_X 200
#define GRID_GROESSE_Y 60
#define SLEEP_TIME 0
#define RED "\033[31m"
#define GREEN "\033[32m"
#define YELLOW "\033[33m"
#define BLUE "\033[34m"
#define MAGENTA "\033[35m"
#define CYAN "\033[36m"
#define WHITE "\033[37m"
const char *colors3[] = {RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE};
#ifdef __linux__
int getch_pipese(){
int ch;
struct termios oldattr, newattr;
tcgetattr(STDIN_FILENO, &oldattr);
newattr = oldattr;
newattr.c_lflag &= ~ICANON;
newattr.c_lflag &= ~ECHO;
newattr.c_cc[VMIN] = 1;
newattr.c_cc[VTIME] = 0;
tcsetattr(STDIN_FILENO, TCSANOW, &newattr);
ch = getchar();
tcsetattr(STDIN_FILENO, TCSANOW, &oldattr);
return ch;
}
#endif
int randomee(int max){
return rand() % max;
}
void print_ate(int x, int y, char c[4], char color)
{
printf("%s\033[%d;%dH%s", colors3[color], y, x, c);
}
char print_pipee(int *x, int *y, int x_max, int y_max, int length, char direction, char direction_old, char *color){
if ((direction == 0 && direction_old == 1) || (direction == 1 && direction_old == 0)){
return direction_old;
} else if ((direction == 2 && direction_old == 3) || (direction == 3 && direction_old == 2)){
return direction_old;
}
bool start = true;
for(int i = 0; i < length; i++){
if (start && direction != direction_old){
switch (direction_old){
case 0: *y -= 1; if (*y <= 0){ *y = y_max; *color = randomee(7); } break; // up
case 1: *y += 1; if (*y > y_max){ *y = 0; *color = randomee(7); } break; // down
case 2: *x -= 1; if (*x <= 0){ *x = x_max; *color = randomee(7); } break; // left
case 3: *x += 1; if (*x >= x_max){ *x = 0; *color = randomee(7); } break; // rigth
}
if ((direction == 2 && direction_old == 0) || (direction == 1 && direction_old == 3)){
print_ate(*x, *y, "┓", *color);
} else if ((direction == 0 && direction_old == 2) || (direction == 3 && direction_old == 1)) {
print_ate(*x, *y, "┗", *color);
} else if ((direction == 3 && direction_old == 0) || (direction == 1 && direction_old == 2)) {
print_ate(*x, *y, "┏", *color);
} else if ((direction == 0 && direction_old == 3) || (direction == 2 && direction_old == 1)) {
print_ate(*x, *y, "┛", *color);
} // else { printf("\nd = %i | d_o = %i\n", direction, direction_old); }
start = false;
} else {
switch (direction){
case 0: *y -= 1; if (*y <= 0){ *y = y_max; *color = randomee(7); } break; // up
case 1: *y += 1; if (*y > y_max){ *y = 0; *color = randomee(7); } break; // down
case 2: *x -= 1; if (*x <= 0){ *x = x_max; *color = randomee(7); } break; // left
case 3: *x += 1; if (*x >= x_max){ *x = 0; *color = randomee(7); } break; // rigth
}
if (direction <= 1) {
print_ate(*x, *y, "┃", *color);
} else {
print_ate(*x, *y, "━", *color);
}
}
fflush(stdout);
usleep(SLEEP_TIME);
}
return direction;
}
int pipes_2_game(int width, int height){
int x_max = width;
int y_max =height;
int x = width / 2;
int y = height / 2;
char direction_old = 0;
char color = 6;
int start_time = 0;
srand(time(0));
while(!kbhit()){
int richtung = 0;
int length = 4;
if (start_time + 20 <= time(0)){
printf("\e[1;1H\e[2J"); // clear terminal
start_time = time(0);
}
#ifdef __linux__
char key_input = (char)getch_pipese();
#elif _WIN32
char key_input = (char)getch();
#endif
switch (key_input) {
case 'h': richtung = 2; break;
case 'a': richtung = 2; break;
case 'l': richtung = 3; break;
case 'd': richtung = 3; break;
case 'j': richtung = 1; break;
case 's': richtung = 1; break;
case 'k': richtung = 0; break;
case 'w': richtung = 0; break;
case 'q': return 0;
default: continue;
}
direction_old = print_pipee(&x, &y, x_max, y_max, length, richtung, direction_old, &color);
}
// ist dazu da um "\n" aus dem buffer zu entfernen!
getchar();
printf("\033[00m"); // Farbe zurücksetzen
return 0;
}

10
src/pipes2_game.h
View File

@ -1,10 +0,0 @@
#ifndef pipes2_game_H_
#define pipes2_game_H_
// #ifndef _FILE_NAME_H_
// #define _FILE_NAME_H_
// extern int pipes(int width, int height);
int pipes_2_game(int width, int height);
#endif

384
src/pipes_test.c
View File

@ -1,384 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#ifdef __linux__
#include <sys/ioctl.h>
#include <unistd.h>
#include <termio.h>
#elif _WIN32
#include <windows.h>
#include <conio.h>
#endif
#define DEBUGGER_PIPES_TO_NUMBERS 0
#define DEBUGGER_RANDOM 0
#define AUTOMATISCH 0
#define INFILL_PLAIN_PAPER 0
#define INFILL_X_PIPE 1
#define INFILL_Y_PIPE 2
#define FILLER " " // ░
//#define GRID_GROESSE_X 120 // x:y -> 2:1 for a square looking grid
//#define GRID_GROESSE_Y 60
#define MIN_LAENGE_PIPE 6
#define MAX_LAENGE_PIPE 6
#define SLEEP_TIMER 0 // in nano seconds
// #define SLEEP_TIMER 5000 // in nano seconds
#define COLOR_CHANGING_PROBABILITY 5 // format: "(1 : your_number)", for every direction change
#define RESET_COLOR "\033[0m"
#define RED "\033[31m"
#define GREEN "\033[32m"
#define YELLOW "\033[33m"
#define BLUE "\033[34m"
#define MAGENTA "\033[35m"
#define CYAN "\033[36m"
#define WHITE "\033[37m"
const char* color;
const char *colors[] = {RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE};
void random_color() {
color = colors[rand() % (sizeof(colors) / sizeof(colors[0]))];
}
#ifdef __linux__
int getch_pipes(){
int ch;
struct termios oldattr, newattr;
tcgetattr(STDIN_FILENO, &oldattr);
newattr = oldattr;
newattr.c_lflag &= ~ICANON;
newattr.c_lflag &= ~ECHO;
newattr.c_cc[VMIN] = 1;
newattr.c_cc[VTIME] = 0;
tcsetattr(STDIN_FILENO, TCSANOW, &newattr);
ch = getchar();
tcsetattr(STDIN_FILENO, TCSANOW, &oldattr);
return ch;
}
#endif
int print_grid(int x, int y, char **grid, int how_many_targets, int *lul) {
int target_count = 0;
for (int i = 0; i < y; i++) {
printf("\n");
for (int j = 0; j < x; j++) {
if(grid[i][j] == 3){
target_count += 1;
}if (!DEBUGGER_PIPES_TO_NUMBERS){
if(grid[i][j] == 0){
printf(FILLER);
} else if(grid[i][j] == 3){
printf("%s█","\033[31m" );
} else if(grid[i][j] != 0 && grid[i][j] != 1 && grid[i][j] != 2 && grid[i][j] != 3){
return 1;
} else if(grid[i - 1][j] == 0 && grid[i + 1][j] == 0 && grid[i][j - 1] != 0 && grid[i][j + 1] != 0 && grid[i][j] == 1 ){
printf("%s━", color);
} else if(grid[i - 1][j] != 0 && grid[i + 1][j] != 0 && grid[i][j - 1] == 0 && grid[i][j + 1] == 0 && grid[i][j] == 2 ){
printf("%s┃", color);
} else if(grid[i - 1][j] == 2 && grid[i + 1][j] == 2 && grid[i][j - 1] == 1 && grid[i][j + 1] == 1 && grid[i][j] != 0 ){
printf("%s╋", color);
} else if(grid[i - 1][j] == 0 && grid[i + 1][j] == 2 && grid[i][j - 1] == 1 && grid[i][j + 1] == 0 && grid[i][j] != 0 ){
printf("%s┓", color);
} else if(grid[i - 1][j] == 2 && grid[i + 1][j] == 0 && grid[i][j - 1] == 0 && grid[i][j + 1] == 1 && grid[i][j] != 0 ){
printf("%s┗", color);
} else if(grid[i - 1][j] == 0 && grid[i + 1][j] == 2 && grid[i][j - 1] == 0 && grid[i][j + 1] == 1 && grid[i][j] != 0 ){
printf("%s┏", color);
} else if(grid[i - 1][j] == 2 && grid[i + 1][j] == 0 && grid[i][j - 1] == 1 && grid[i][j + 1] == 0 && grid[i][j] != 0 ){
printf("%s┛", color);
} else if(grid[i - 1][j] == 2 && grid[i + 1][j] == 2 && grid[i][j - 1] == 0 && grid[i][j + 1] == 1 && grid[i][j] != 0 ){
printf("%s┣", color);
} else if(grid[i - 1][j] == 2 && grid[i + 1][j] == 2 && grid[i][j - 1] == 1 && grid[i][j + 1] == 0 && grid[i][j] != 0 ){
printf("%s┫", color);
} else if(grid[i - 1][j] == 0 && grid[i + 1][j] == 2 && grid[i][j - 1] == 1 && grid[i][j + 1] == 1 && grid[i][j] != 0 ){
printf("%s┳", color);
} else if(grid[i - 1][j] == 2 && grid[i + 1][j] == 0 && grid[i][j - 1] == 1 && grid[i][j + 1] == 1 && grid[i][j] != 0 ){
printf("%s┻", color);
} else if(grid[i - 1][j] == 0 && grid[i + 1][j] == 0 && grid[i][j - 1] != 0 && grid[i][j + 1] == 0 && grid[i][j] == 1 ){
printf("%s━", color);
} else if(grid[i - 1][j] == 0 && grid[i + 1][j] == 0 && grid[i][j - 1] == 0 && grid[i][j + 1] != 0 && grid[i][j] == 1 ){
printf("%s━", color);
} else if(grid[i - 1][j] != 0 && grid[i + 1][j] == 0 && grid[i][j - 1] == 0 && grid[i][j + 1] == 0 && grid[i][j] == 2 ){
printf("%s┃", color);
} else if(grid[i - 1][j] == 0 && grid[i + 1][j] != 0 && grid[i][j - 1] == 0 && grid[i][j + 1] == 0 && grid[i][j] == 2 ){
printf("%s┃", color);
} else if(grid[i - 1][j] == 1 && grid[i + 1][j] == 0 && grid[i][j - 1] == 1 && grid[i][j + 1] == 1 && grid[i][j] == 1 ){
printf("%s━", color);
} else if(grid[i - 1][j] == 0 && grid[i + 1][j] == 1 && grid[i][j - 1] == 1 && grid[i][j + 1] == 1 && grid[i][j] == 1 ){
printf("%s━", color);
} else if(grid[i - 1][j] == 1 && grid[i + 1][j] == 1 && grid[i][j - 1] == 1 && grid[i][j + 1] == 1 && grid[i][j] == 1 ){
printf("%s━", color);
} else if(grid[i - 1][j] == 2 && grid[i + 1][j] == 2 && grid[i][j - 1] == 0 && grid[i][j + 1] == 2 && grid[i][j] == 2 ){
printf("%s┃", color);
} else if(grid[i - 1][j] == 2 && grid[i + 1][j] == 2 && grid[i][j - 1] == 2 && grid[i][j + 1] == 0 && grid[i][j] == 2 ){
printf("%s┃", color);
} else if(grid[i - 1][j] == 2 && grid[i + 1][j] == 2 && grid[i][j - 1] == 2 && grid[i][j + 1] == 2 && grid[i][j] == 2 ){
printf("%s┃", color);
} else if(grid[i][j] == 3){
printf("✨");
} else if(grid[i - 1][j] != 0 && grid[i + 1][j] != 0 && grid[i][j - 1] != 0 && grid[i][j + 1] != 0 && grid[i][j] == 0 ){
printf("%s┃", color);
} else if(grid[i - 1][j] != 0 && grid[i + 1][j] != 0 && grid[i][j - 1] != 0 && grid[i][j + 1] == 0 && grid[i][j] != 0 ){
printf("%s┃", color);
} else if(grid[i - 1][j] != 0 && grid[i + 1][j] == 0 && grid[i][j - 1] != 0 && grid[i][j + 1] != 0 && grid[i][j] != 0 ){
printf("%s┻", color);
} else if(grid[i - 1][j] == 0 && grid[i + 1][j] != 0 && grid[i][j - 1] != 0 && grid[i][j + 1] != 0 && grid[i][j] != 0 ){
printf("%s┳", color);
} else if(grid[i - 1][j + 1] == 0 && grid[i - 1][j] != 0 && grid[i + 1][j] != 0 && grid[i][j - 1] != 0 && grid[i][j + 1] != 0 && grid[i][j] != 0 ){
printf("%s┗", color);
} else if(grid[i][j] == 2 ){
printf("%s┃", color);
} else if(grid[i][j] == 1 ){
printf("%s━", color);
} else{printf("x");}
printf(RESET_COLOR); // Setzt die Farbe zurück
}else{
printf("%i", grid[i][j]);
}
}
}
if (target_count <= 2*how_many_targets - 1*how_many_targets) {
printf("\e[1;1H\e[2J");
printf("\n");
printf(" █ █ █████ █ █ █ █ █████ ██ █\n");
printf(" ██ ██ █ █ █ █ █ █ █ █ ███ █\n");
printf(" █████ █ █ █ █ █ █ █ █ █ ██ █\n");
printf(" █ █ █ █ █ █ ██ █ █ █ █ ███\n");
printf(" █ █████ █████ █ █ █████ █ ██\n");
printf("\n");
printf("Targets overritten: %i\n", 2*how_many_targets-target_count);
*lul += 1;
system("xdg-open https://bit.ly/3BlS71b");
printf("'q' for start menue");
return 1;
}
return 0;
}
int generate_pipe_x(int GRID_GROESSE_X, int GRID_GROESSE_Y, char **grid, int *x_start, int *y_start, int laenge, int how_many_targets, int *return_code, int *lul) {
if (laenge < 0){
for (int i = *x_start; i > *x_start + laenge; i--) {
if (*return_code == 1) {
return 0;
}
if (i <= -laenge/2 -1) {
*x_start = GRID_GROESSE_X + laenge/2;
return 0;
}
grid[*y_start][i] = INFILL_X_PIPE;
printf("\33[H\033[J");
*return_code = print_grid(GRID_GROESSE_X, GRID_GROESSE_Y, grid, how_many_targets, lul);
}
} else {
for (int i = *x_start; i < *x_start + laenge; i++) {
if (*return_code == 1) {
return 0;
}
if (i >= GRID_GROESSE_X - laenge/2+1) {
*x_start = laenge/2;
return 0;
}
grid[*y_start][i] = INFILL_X_PIPE;
printf("\33[H\033[J");
*return_code = print_grid(GRID_GROESSE_X, GRID_GROESSE_Y, grid, how_many_targets, lul);
}
}
*x_start += laenge;
return 0;
}
int generate_pipe_y(int GRID_GROESSE_X, int GRID_GROESSE_Y, char **grid, int *x_start, int *y_start, int laenge, int how_many_targets, int *return_code, int *lul) {
if (laenge < 0){
for (int i = *y_start; i > *y_start + laenge/2; i--) {
if (*return_code == 1) {
return 0;
}
if (i <= -laenge/2) {
*y_start = GRID_GROESSE_Y + laenge/2;
return 0;
}
grid[i][*x_start] = INFILL_Y_PIPE;
printf("\33[H\033[J");
*return_code = print_grid(GRID_GROESSE_X, GRID_GROESSE_Y, grid, how_many_targets, lul);
}
} else{
for (int i = *y_start; i < *y_start + laenge/2; i++) {
if (*return_code == 1) {
return 0;
}
if (i >= (GRID_GROESSE_Y / 2)*2 - 1) {
*y_start = laenge/2;
return 0;
}
grid[i][*x_start] = INFILL_Y_PIPE;
printf("\33[H\033[J");
*return_code = print_grid(GRID_GROESSE_X, GRID_GROESSE_Y, grid, how_many_targets, lul);
}
}
*y_start += laenge/2;
return 0;
}
void generate_target(int GRID_GROESSE_X, int GRID_GROESSE_Y, char **grid, int *x_start, int *y_start, int laenge) {
int abstand_vom_rand_x = 6;
int abstand_vom_rand_y = 3;
int target_x = 0;
int target_y = 0;
while (target_x <= abstand_vom_rand_x || target_x >= GRID_GROESSE_X - abstand_vom_rand_x || target_y <= abstand_vom_rand_y || target_y >= GRID_GROESSE_Y - abstand_vom_rand_y) {
target_x = ((rand() % GRID_GROESSE_X));
target_y = ((rand() % GRID_GROESSE_Y));
}
for (int j = target_y; j < target_y + 2; j++) {
for (int i = target_x; i < target_x + 1; i++) {
grid[j][i] = 3;
}
}
}
int pipes(int GRID_GROESSE_X, int GRID_GROESSE_Y) {
//int main() {
// system("chcp 65001 >null");
// int GRID_GROESSE_X = 100; // x:y -> 2:1 for a square looking grid
// int GRID_GROESSE_Y = 60;
int x_start = GRID_GROESSE_X / 2;
int y_start = GRID_GROESSE_Y / 2;
int laenge = 20;
int max_l = MAX_LAENGE_PIPE + 1 - MIN_LAENGE_PIPE;
int min_l = MIN_LAENGE_PIPE - 1;
int color_c_p = COLOR_CHANGING_PROBABILITY + 1;
int return_code = 0;
int lul = 0;
srand(time(NULL));
random_color();
char **grid = malloc(GRID_GROESSE_Y * sizeof(char *));
for (int i = 0; i < GRID_GROESSE_Y; i++) {
grid[i] = malloc(GRID_GROESSE_X * sizeof(char));
}
for (int i = 0; i < GRID_GROESSE_Y; i++) {
for (int j = 0; j < GRID_GROESSE_X; j++) {
grid[i][j] = INFILL_PLAIN_PAPER;
}
}
// int richtungswechsler = 1;
int how_many_targets = 3;
for (int i = 1; i <= how_many_targets; i++) {
generate_target(GRID_GROESSE_X, GRID_GROESSE_Y, grid, &x_start, &y_start, laenge);
}
return_code = generate_pipe_x(GRID_GROESSE_X, GRID_GROESSE_Y, grid, &x_start, &y_start, 1, how_many_targets, &return_code, &lul);
if (!DEBUGGER_RANDOM) {
while (!AUTOMATISCH) {
if ((rand() %color_c_p) <= 1) {
random_color();
}
laenge = ((rand() %max_l)+min_l);
#ifdef __linux__
char key_input = (char)getch_pipes();
#elif _WIN32
char key_input = (char)getch();
#endif
switch (key_input) {
case 'h': generate_pipe_x(GRID_GROESSE_X, GRID_GROESSE_Y, grid, &x_start, &y_start, laenge * -1, how_many_targets, &return_code, &lul); break;
case 'a': generate_pipe_x(GRID_GROESSE_X, GRID_GROESSE_Y, grid, &x_start, &y_start, laenge * -1, how_many_targets, &return_code, &lul); break;
case 'l': generate_pipe_x(GRID_GROESSE_X, GRID_GROESSE_Y, grid, &x_start, &y_start, laenge, how_many_targets, &return_code, &lul); break;
case 'd': generate_pipe_x(GRID_GROESSE_X, GRID_GROESSE_Y, grid, &x_start, &y_start, laenge, how_many_targets, &return_code, &lul); break;
case 'j': generate_pipe_y(GRID_GROESSE_X, GRID_GROESSE_Y, grid, &x_start, &y_start, laenge, how_many_targets, &return_code, &lul); break;
case 's': generate_pipe_y(GRID_GROESSE_X, GRID_GROESSE_Y, grid, &x_start, &y_start, laenge, how_many_targets, &return_code, &lul); break;
case 'k': generate_pipe_y(GRID_GROESSE_X, GRID_GROESSE_Y, grid, &x_start, &y_start, laenge * -1, how_many_targets, &return_code, &lul); break;
case 'w': generate_pipe_y(GRID_GROESSE_X, GRID_GROESSE_Y, grid, &x_start, &y_start, laenge * -1, how_many_targets, &return_code, &lul); break;
case 'q': return 0;
default: continue;
}
}
// while (AUTOMATISCH) {
// if ((rand() %color_c_p) <= 1) {
// random_color();
// }
// if ((rand() %2)-1) {
// laenge = ((rand() %max_l)+min_l);
// } else {
// laenge = ((rand() %max_l)+min_l)*-1;
// }
//
// if (richtungswechsler == 1) {
// generate_pipe_x(GRID_GROESSE_X, GRID_GROESSE_Y, grid, &x_start, &y_start, laenge, how_many_targets);
// richtungswechsler *= -1;
// } else {
// generate_pipe_y(GRID_GROESSE_X, GRID_GROESSE_Y, grid, &x_start, &y_start, laenge, how_many_targets);
// richtungswechsler *= -1;
// }
// }
// }
//
// if (DEBUGGER_RANDOM) {
// generate_pipe_x(GRID_GROESSE_X, GRID_GROESSE_Y, grid, &x_start, &y_start, laenge, how_many_targets);
// generate_pipe_y(GRID_GROESSE_X, GRID_GROESSE_Y, grid, &x_start, &y_start, laenge, how_many_targets);
// generate_pipe_x(GRID_GROESSE_X, GRID_GROESSE_Y, grid, &x_start, &y_start, laenge, how_many_targets);
// generate_pipe_y(GRID_GROESSE_X, GRID_GROESSE_Y, grid, &x_start, &y_start, laenge * -0.1, how_many_targets);
// generate_pipe_x(GRID_GROESSE_X, GRID_GROESSE_Y, grid, &x_start, &y_start, laenge * -1.05, how_many_targets);
// generate_pipe_y(GRID_GROESSE_X, GRID_GROESSE_Y, grid, &x_start, &y_start, laenge * -1, how_many_targets);
// generate_pipe_x(GRID_GROESSE_X, GRID_GROESSE_Y, grid, &x_start, &y_start, laenge * 0.1, how_many_targets);
// generate_pipe_y(GRID_GROESSE_X, GRID_GROESSE_Y, grid, &x_start, &y_start, laenge * 0.9, how_many_targets);
// generate_pipe_x(GRID_GROESSE_X, GRID_GROESSE_Y, grid, &x_start, &y_start, laenge, how_many_targets);
}
for (int i = 0; i < GRID_GROESSE_Y; i++) {
free(grid[i]);
}
free(grid);
return 0;
}

11
src/pipes_test.h
View File

@ -1,11 +0,0 @@
#ifndef pipes_test_H_
#define pipes_test_H_
// #ifndef _FILE_NAME_H_
// #define _FILE_NAME_H_
// extern int pipes(int width, int height);
// int pipes_2(int width, int height);
int pipes(int GRIG_GROESSE_X, int GRID_GROESSE_Y);
#endif