forked from zwickethomas/Photonics-Helfer
cleanup
This commit is contained in:
MuedeHydra
parent
dc829019bc
commit
4dba346f0c
@ -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", ¤t);
|
||||
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;
|
||||
}
|
||||
@ -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
|
||||
@ -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;
|
||||
}
|
||||
@ -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
|
||||
@ -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!");
|
||||
}
|
||||
}
|
||||
@ -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
|
||||
@ -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
|
||||
@ -1,6 +0,0 @@
|
||||
#ifndef KBHIT_LINUX_H_
|
||||
#define KBHIT_LINUX_H_
|
||||
|
||||
int kbhit();
|
||||
|
||||
#endif
|
||||
109
src/pipes2.c
109
src/pipes2.c
@ -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
10
src/pipes2.h
@ -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
|
||||
@ -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;
|
||||
}
|
||||
@ -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
384
src/pipes_test.c
@ -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;
|
||||
}
|
||||
|
||||
@ -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
|
||||
Loading…
x
Reference in New Issue
Block a user