Merge branch 'dev' into stefan

.gitignore

@@ -10,6 +10,7 @@ cmake-build-debug
 past
 CMakeLists.txt
 toDo.md
+.DS_Store
 
 # Prerequisites
 *.d

src/main/c/Jason/ASCII_art.c

@@ -0,0 +1,324 @@
+#include "ASCII_art.h"
+#include <stdio.h>
+
+int ASCII_Art(){
+
+    int weitermachen = 0;
+    do {
+        Willkommensnachricht();
+
+        int auswahl;
+        scanf("%d", &auswahl);
+        auswahlDerArt(auswahl);
+
+
+        printf("\nVielen Dank, dass sie sich ASCII-Art angesehen haben\n"
+               "Wollen Sie weitere ASCII-Art sehen?\n"
+               "(1) Ja\n"
+               "(2) Nein\n"
+               "Eingabe:");
+        scanf("%d", &weitermachen);
+    }while(weitermachen == 1);
+
+    return 0;
+}
+
+void quadrat(){
+
+    frageNachGroesse();
+    int LaengeDerZeilen;
+    scanf("%d", &LaengeDerZeilen);
+    int arraySize = berechnungDerLaengeDesQuadratArrays(LaengeDerZeilen);
+    char Quadrat[arraySize];
+    befuellenDesArraysMitX(Quadrat, arraySize);
+    befuelleDasArrayMitLeerzeichen(Quadrat, arraySize);
+    befuelleDasArrayMitZeilenumbruechen(Quadrat,LaengeDerZeilen);
+
+    printf("\n%s", Quadrat);
+
+}
+
+void Weihnachtsbaum(){
+
+    abfrageDerHoehe();
+    int hoeheVomBaumInklusiveStamm;
+    do{
+        // Diese Schleifen erfragen user input solange bis korrekte Werte eingegeben werden
+
+        scanf("%d", &hoeheVomBaumInklusiveStamm);
+        if (hoeheVomBaumInklusiveStamm < 3){
+            printf("\nDer Weihnachtsbaum muss mindestens 3 Zeilen groß sein!\n");
+            printf("Bitte geben Sie erneut einen Wert ein der mindestens 3 lautet:");
+        }
+    }while(hoeheVomBaumInklusiveStamm < 3);
+
+    int maxBreiteDesWeihnachtsbaums = max_breiteDesBaums(hoeheVomBaumInklusiveStamm);
+    int mitte_baum = mitteDesBaums(maxBreiteDesWeihnachtsbaums);
+    int groesseDesArrays = (hoeheVomBaumInklusiveStamm -1) * maxBreiteDesWeihnachtsbaums;
+    char weihnachtsbaum[groesseDesArrays];
+    befuellenDesWeihnachtsbaumsMitLeerzeichen(weihnachtsbaum, groesseDesArrays);
+    befuellenDesWeihnachtsbaumsMitPlus(weihnachtsbaum, maxBreiteDesWeihnachtsbaums, (hoeheVomBaumInklusiveStamm-1));
+    befuellenDesWeihnachtsbaumsMitZeilenumbruechen(weihnachtsbaum, hoeheVomBaumInklusiveStamm, maxBreiteDesWeihnachtsbaums);
+    char stamm[maxBreiteDesWeihnachtsbaums];
+    befuellenDesStammarraysMitLeerzeichen(stamm, maxBreiteDesWeihnachtsbaums);
+    stammAnRichtigerStelleEinsetzen(stamm, maxBreiteDesWeihnachtsbaums);
+
+    // Felder für Stamm und Baumspitze werden der Einfachheit halber getrennt befüllt und ausgegeben
+    printf("%s\n", weihnachtsbaum);
+    printf("%s", stamm);
+
+}
+
+void dreieck(){
+    dreieckWillkommensnachricht();
+    int hoeheDreieck;
+
+    // Eingabe Auf Definitions
+    do{
+        scanf("%d", &hoeheDreieck);
+        if(hoeheDreieck < 2){
+            printf("Es wurde ein Wert eingegeben, der kleiner ist als 2. Bitte geben Sie erneut eine Zahl ein!\n"
+                   "Eingbe:");
+        }
+    } while(hoeheDreieck < 2);
+
+    int arraygroesse = berechnungDerDreieckArraygroesse(hoeheDreieck);
+    char dreieck[arraygroesse];
+    befuellenDesDreiecksMitX(dreieck, arraygroesse);
+    befuellenDesDreiecksMitZeilenumbruechen(dreieck, hoeheDreieck, arraygroesse);
+    printf("%s", dreieck);
+
+}
+
+void rakete(){
+    raketeBegruessung();
+    int hoeheRakete;
+    do{
+        scanf("%d", &hoeheRakete);
+        if(hoeheRakete < 3){
+            printf("Es wurde ein Wert eingegeben, der kleiner ist als 3. Bitte geben Sie erneut eine Zahl ein!\n"
+                   "Eingbe:");
+        }
+    } while(hoeheRakete < 3);
+
+    printf("\nComing soon ;)\n");
+}
+
+
+int Willkommensnachricht(){
+    printf("Willkommen bei ASCII-Art!\n");
+    printf("Wählen Sie aus welche ASCII-Art Sie sehen wollen!\n");
+    printf("(1) Quadrat\n");
+    printf("(2) Weihnachtsbaum\n");
+    printf("(3) Dreieck\n");
+    printf("(4) Rakete\n");
+
+return 0;
+}
+
+void auswahlDerArt(int pick){
+    switch (pick) {
+        case (1):
+            quadrat();
+            break;
+        case (2):
+            Weihnachtsbaum();
+            break;
+
+        case (3):
+            dreieck();
+            break;
+        case (4):
+            rakete();
+            break;
+        default:
+            break;
+
+    }
+}
+
+int frageNachGroesse(){
+    printf("Sie haben ausgewählt, dass sie ein Quadrat sehen möchten!\n");
+    printf("Geben Sie ein wie lang die Seiten des Quadrats sein sollen:");
+    return 0;
+}
+
+int berechnungDerLaengeDesQuadratArrays(int anzahlDerX){
+
+    int ArraygroesseDesQuadrats;
+    ArraygroesseDesQuadrats = 2 * anzahlDerX * anzahlDerX;
+    // länge des Arrays für ein Quadrat
+
+    return ArraygroesseDesQuadrats;
+}
+
+void befuellenDesArraysMitX(char quadraT[], int laenge){
+
+    for (int i = 0; i < laenge; i++){
+        quadraT[i] = 'X';
+    }
+    quadraT[laenge-1] = '\0';
+
+}
+
+void befuelleDasArrayMitLeerzeichen(char quadraT[], int laenge){
+
+
+    for (int i = 0; i < laenge; i++){
+        if(i % 2 != 0){
+            quadraT[i] = ' ';
+        }
+    }
+
+    // Das \0 muss Extra platziert werden um einen korrekten Ablauf sicherzustellen
+    quadraT[laenge-1] = '\0';
+}
+
+void befuelleDasArrayMitZeilenumbruechen(char quadraT[], int laenge){
+
+    int zeile = 2 * laenge;
+    int laengeGesamt = zeile * laenge;
+    for (int i = 0; i < laengeGesamt; i++){
+        if((i + 1) % zeile == 0){
+            quadraT[i] = '\n';
+        }
+    }
+    quadraT[laengeGesamt-1] = '\0';
+}
+
+int abfrageDerHoehe(){
+    printf("Sie haben den Weihnachtsbaum ausgewählt!\n");
+    printf("Wählen Sie aus wie hoch der Weihnachtsbaum werden soll:");
+
+    return 0;
+}
+
+int max_breiteDesBaums(int zeilen){
+
+    int maximaleBreiteEinerZeile;
+    maximaleBreiteEinerZeile = zeilen + (zeilen - 2);
+    return maximaleBreiteEinerZeile;
+}
+
+int mitteDesBaums(int maxBreite){
+
+    int mitteVonBaum = maxBreite / 2;
+    return mitteVonBaum;
+}
+
+void befuellenDesWeihnachtsbaumsMitLeerzeichen(char arr[],int groesse){
+
+    for(int i = 0; i < groesse; i++){
+        arr[i] = ' ';
+    }
+    arr[groesse - 1] = '\0';
+}
+
+void befuellenDesWeihnachtsbaumsMitPlus(char arr[], int maxBreite, int zeilen){
+
+    int arrayGroesse = maxBreite * zeilen;
+    int mitteDesBaums = maxBreite / 2;
+    int mengeDerXInDerZeile = 1;
+
+    for(int i = zeilen; i > 0; i--){
+
+        int position = mitteDesBaums -1;
+
+         while(position < mitteDesBaums-1 + mengeDerXInDerZeile){
+             arr[position++] = '+';
+         }
+
+        mitteDesBaums += (maxBreite -1);
+         mengeDerXInDerZeile += 2;
+    }
+    arr[arrayGroesse] = '\0';
+}
+
+void befuellenDesWeihnachtsbaumsMitZeilenumbruechen(char arr[], int zeilen, int breite){
+
+    // man muss von der eingegebenen Höhe eins abziehen, weil der Stamm in diesem Array nicht inbegriffen ist
+    int arraygroesse = (zeilen-1) * breite;
+
+    // \n soll am Ende jeder Zeile platziert werden
+
+    for (int i = 0; i < arraygroesse; i++){
+
+        if((i + 1) % breite == 0 ){
+
+            arr[i] = '\n';
+        }
+    }
+    arr[arraygroesse -1] = '\0';
+}
+
+void befuellenDesStammarraysMitLeerzeichen(char arr[], int breite){
+
+    for(int i = 0; i < breite; i++){
+        arr[i] = ' ';
+    }
+}
+
+void stammAnRichtigerStelleEinsetzen(char arr[], int breite){
+
+    int stelleFuerStamm = breite / 2;
+
+    arr[stelleFuerStamm-1] = '+' ;
+
+    arr[breite - 1] = '\0';
+}
+
+void dreieckWillkommensnachricht(){
+    printf("Sie haben das Dreieck Ausgewählt!\n"
+           "Bitte geben Sie ein wie hoch das gewünschte Dreieck sein soll\n"
+           "(Es muss jedoch mindestens 2 hoch sein)\n"
+           "Eingabe:");
+}
+
+int berechnungDerDreieckArraygroesse(int zeilen){
+    int arraygroesseInklusiveEinerreiheOhneXOderBackslashN;
+
+    // Berechnung inklusive der \n
+    zeilen +=1;
+
+    // zum Aufsummieren der nötigen Feldgroesse bietet sich die Gaußsche Summenformel an
+
+    arraygroesseInklusiveEinerreiheOhneXOderBackslashN = zeilen * (zeilen+1) / 2;
+
+    // Das Array beginnt in der ersten Zeile mit 2 Elementen, also muss 1 subtrahiert werden nach Gauß
+    arraygroesseInklusiveEinerreiheOhneXOderBackslashN -= 1;
+
+    return arraygroesseInklusiveEinerreiheOhneXOderBackslashN;
+}
+
+void befuellenDesDreiecksMitX(char arr[], int goresse){
+
+    for(int i = 0; i < goresse; i++){
+
+        arr[i] = 'X';
+
+    }
+    arr[goresse-1] = '\0';
+
+}
+
+void befuellenDesDreiecksMitZeilenumbruechen(char arr[], int gesamtzeilen, int arraygroesse){
+
+    int stelleFuerZeilenumbruch = 1;
+
+    for(int zeile = 1; zeile <= gesamtzeilen; zeile++){
+
+        arr[stelleFuerZeilenumbruch] = '\n';
+
+        stelleFuerZeilenumbruch += (zeile+2);
+
+    }
+    arr[arraygroesse -1] = '\0';
+}
+
+void raketeBegruessung(){
+
+    printf("Sie haben die ASCII-Art Rakete ausgewählt ! Bitte Geben Sie ein wie hoch die Rakete sein soll\n"
+           "(Mindestens 3)\n"
+           "Eingabe:");
+
+}

src/main/c/Jason/ASCII_art.h

@@ -0,0 +1,30 @@
+#ifndef ASCII_ART_H
+#define ASCII_ART_H
+
+int ASCII_Art();
+int Willkommensnachricht();
+void auswahlDerArt(int);
+void quadrat();
+int frageNachGroesse();
+int berechnungDerLaengeDesQuadratArrays(int);
+void befuellenDesArraysMitX(char[], int);
+void befuelleDasArrayMitLeerzeichen(char[],int);
+void befuelleDasArrayMitZeilenumbruechen(char[],int);
+void Weihnachtsbaum();
+int abfrageDerHoehe();
+int max_breiteDesBaums(int);
+int mitteDesBaums(int);
+void befuellenDesWeihnachtsbaumsMitLeerzeichen(char[],int);
+void befuellenDesWeihnachtsbaumsMitPlus(char[], int, int);
+void befuellenDesWeihnachtsbaumsMitZeilenumbruechen(char[], int, int);
+void befuellenDesStammarraysMitLeerzeichen(char[], int);
+void stammAnRichtigerStelleEinsetzen(char[], int);
+void dreieck();
+void dreieckWillkommensnachricht();
+int berechnungDerDreieckArraygroesse(int);
+void befuellenDesDreiecksMitX(char[], int);
+void befuellenDesDreiecksMitZeilenumbruechen(char[], int, int);
+void rakete();
+void raketeBegruessung();
+
+#endif

src/main/c/main.c

@@ -16,6 +16,8 @@
 #include "tictactoe.h"
 #include "slot_machine.h"
 #include "blackjack.h"
+#include "Jason/ASCII_art.h"
+
 
 
 void openInterface();
@@ -39,9 +41,18 @@ void openInterface()
                "2: Hangman\n"
                "3: TicTacToe\n"
                "4: Slot Machine\n"
+               "5: ASCII - Art\n"
                "6: Blackjack\n");
         printf("\nBitte waehle die Zahl des entsprechenden Spiels aus, um damit zu starten.\nAm Ende eines Spiels kannst du mit der Taste 0 wieder zurueck zum Hauptmenue kommen.\nIm Hauptmenue beendest du mit der Auswahl 0 das Programm \n\n");
-        scanf_s("%d", &selection);
+        #ifdef __APPLE__
+            scanf("%d", &selection);
+        #elif defined(__linux__)
+            scanf("%d", &selection);
+        #else
+            scanf_s("%d", &selection);
+        #endif
+
+
 
 
         //todo
@@ -62,7 +73,7 @@ void openInterface()
                     slotMachine();
                     break;
                 case(5):
-                    //Spiel()
+                    ASCII_Art();
                     break;
                 case(6):
                     blackjack();

src/test/c/Jason/test_ASCII_art.c

@@ -0,0 +1,182 @@
+#include "unity.h"
+#include "ASCII_art.h"
+
+void setUp (void){
+
+}
+
+void tearDown(void){
+
+}
+
+void test_funktioniertDieWillkommensnachricht() {
+    //arrange
+    int expectedResult = 0;
+
+    //act
+    int actualResult = Willkommensnachricht();
+    //assert
+
+    TEST_ASSERT_EQUAL_INT(expectedResult, actualResult);
+}
+
+void test_funktioniertDieAbfrageDerGroesse() {
+    //arrange
+    int expectedResult = 0;
+
+    //act
+    int actualResult = frageNachGroesse();
+    //assert
+
+    TEST_ASSERT_EQUAL_INT(expectedResult, actualResult);
+}
+
+void test_korrekteBerechnungDerArrayGroesse() {
+    //arrange
+    int expectedResult = 200;
+
+    //act
+    int actualResult = berechnungDerLaengeDesQuadratArrays(10);
+    //assert
+
+    TEST_ASSERT_EQUAL_INT(expectedResult, actualResult);
+}
+
+void test_stringAbgleich(void){
+    // arrange
+    char expectedMessage[] = "XXXXXXX";
+
+    // Dieser Test überprüft, ob das Feld für die Baumkrone korrekt mit X befüllt wird
+
+    // act
+    char message[9];
+    befuellenDesArraysMitX(message, 8);
+
+
+    // assert
+    TEST_ASSERT_EQUAL_STRING(expectedMessage, message);
+}
+
+void test_stringAbgleichMitLeerzeichen(void){
+    // arrange
+    char expectedMessage[] = "X X X X X X X X X";
+
+    // Hier wird überprüft ob die Baumkrone wie erwartet mit X und Leerzeichen befüllt wird
+
+    // act
+    char message[19];
+    befuellenDesArraysMitX(message, 18);
+    befuelleDasArrayMitLeerzeichen(message, 18);
+
+
+    // assert
+    TEST_ASSERT_EQUAL_STRING(expectedMessage, message);
+}
+
+void test_stringAbgleichMitLeerzeichenUndZeilenumbruch(void){
+    // arrange
+    char expectedMessage[] = "X X X\nX X X\nX X X";
+
+    // act
+    char message[19];
+    befuellenDesArraysMitX(message, 18);
+    befuelleDasArrayMitLeerzeichen(message, 18);
+    befuelleDasArrayMitZeilenumbruechen(message, 3);
+
+
+    // assert
+    TEST_ASSERT_EQUAL_STRING(expectedMessage, message);
+}
+
+void test_erscheintDieAbfrageFuerWeihnachtsbaum() {
+    //arrange
+    int expectedResult = 0;
+
+    //act
+    int actualResult = abfrageDerHoehe();
+    //assert
+
+    TEST_ASSERT_EQUAL_INT(expectedResult, actualResult);
+}
+
+void test_korrekteBerechnungAufMaximaleBreiteDesWeihnachtsbaums() {
+    //arrange
+    int expectedResult = 10;
+
+    //act
+    int actualResult = max_breiteDesBaums(6);
+    //assert
+
+    TEST_ASSERT_EQUAL_INT(expectedResult, actualResult);
+}
+
+void test_korrekteBerechnungAufMaximaleGroesseDesDreiecks() {
+    //arrange
+    int expectedResult = 65;
+
+    //act
+    int actualResult = berechnungDerDreieckArraygroesse(10);
+    //assert
+
+    TEST_ASSERT_EQUAL_INT(expectedResult, actualResult);
+}
+
+void test_korrekteBerechnungAufMaximaleGroesseDesDreiecksBeiGrossenZahlen() {
+    //arrange
+    int expectedResult = 50015000;
+
+    // Hier sollte auf overflow überprüft werden bei großen Zahlen
+
+    //act
+    int actualResult = berechnungDerDreieckArraygroesse(10000);
+    //assert
+
+    TEST_ASSERT_EQUAL_INT(expectedResult, actualResult);
+}
+
+void test_wirdKleinesDreieckKorrektBefuellt(void){
+    // arrange
+    char expectedMessage[] = "X\nXX";
+
+
+    // act
+    char message[6];
+
+    befuellenDesDreiecksMitX(message, 5);
+    befuellenDesDreiecksMitZeilenumbruechen(message, 2, 5);
+
+
+    // assert
+    TEST_ASSERT_EQUAL_STRING(expectedMessage, message);
+}
+
+void test_wirdKleinesBaumkroneKorrektBefuelld(void){
+    // arrange
+    char expectedMessage[] = " + \n+++";
+
+    // act
+    char message[9];
+
+    befuellenDesWeihnachtsbaumsMitLeerzeichen(message, 8);
+    befuellenDesWeihnachtsbaumsMitPlus(message, 4, (3-1));
+    befuellenDesWeihnachtsbaumsMitZeilenumbruechen(message, 3, 4);
+
+
+    // assert
+    TEST_ASSERT_EQUAL_STRING(expectedMessage, message);
+}
+
+void test_wirdBaumstammAnRichtigerStelleEingesetzt(void){
+    // arrange
+    char expectedMessage[] = "  +  ";
+
+    // act
+    char message[7];
+
+    befuellenDesStammarraysMitLeerzeichen(message, 6);
+    stammAnRichtigerStelleEinsetzen(message, 6);
+
+
+    // assert
+    TEST_ASSERT_EQUAL_STRING(expectedMessage, message);
+}

src/test/c/Tim/test_hangman.c

@@ -95,59 +95,59 @@ void test_wordGuessed_differentCaps()
 void test_letterGuessed_differentCaps_small_big()
 {
     //arrange
-    char x ='F';
-    char y[] ="Kartoffel";
+    char bigLetter ='F';
+    char wordWithSmallLetter[] ="Kartoffel";
     int length = 9;
     //assert
-    TEST_ASSERT_TRUE(letterGuessed(x,y,length));
+    TEST_ASSERT_TRUE(letterGuessed(bigLetter,wordWithSmallLetter,length));
 }
 
 void test_letterGuessed_differentCaps_big_small()
 {
     //arrange
-    char x ='k';
-    char y[] ="Kartoffel";
+    char smallLetter ='k';
+    char wordWithBigLetter[] ="Kartoffel";
     int length = 9;
     //assert
-    TEST_ASSERT_TRUE(letterGuessed(x,y,length));
+    TEST_ASSERT_TRUE(letterGuessed(smallLetter,wordWithBigLetter,length));
 }
 void test_letterGuessed_sameCaps_small()
 {
     //arrange
-    char x ='f';
-    char y[] ="Kartoffel";
+    char smallLetter ='f';
+    char wordWithSmallLetter[] ="Kartoffel";
     int length = 9;
     //assert
-    TEST_ASSERT_TRUE(letterGuessed(x,y,length));
+    TEST_ASSERT_TRUE(letterGuessed(smallLetter,wordWithSmallLetter,length));
 }
 void test_letterGuessed_differentLetter_small()
 {
     //arrange
-    char x ='p';
+    char randomSmallLetter ='p';
     char y[] ="Kartoffel";
     int length = 9;
     //assert
-    TEST_ASSERT_FALSE(letterGuessed(x,y,length));
+    TEST_ASSERT_FALSE(letterGuessed(randomSmallLetter,y,length));
 }
 void test_letterGuessed_differentLetter_big()
 {
     //arrange
-    char x ='P';
+    char randomBigLetter ='P';
     char y[] ="Kartoffel";
     int length = 9;
     //assert
-    TEST_ASSERT_FALSE(letterGuessed(x,y,length));
+    TEST_ASSERT_FALSE(letterGuessed(randomBigLetter,y,length));
 }
 
 
 void test_letterGuessed_sameCaps_big()
 {
     //arrange
-    char x ='K';
-    char y[] ="Kartoffel";
+    char bigLetter ='K';
+    char wordWithBigLetter[] ="Kartoffel";
     int length = 9;
     //assert
-    TEST_ASSERT_TRUE(letterGuessed(x,y,length));
+    TEST_ASSERT_TRUE(letterGuessed(bigLetter,wordWithBigLetter,length));
 }
 
 void test_noTrysLeft_x_equals_POSSIBLE_TRYS()