Merge branch 'jason' into dev

.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,317 @@
+#include "ASCII_art.h"
+#include <stdio.h>
+
+int ASCII_Art(){
+
+    int weitermachen = 0;
+    do {
+        printWelcomeMessage();
+        int auswahl;
+        scanf("%d", &auswahl);
+        auswahlDerArt(auswahl);
+
+
+        printf("Vielen 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 groesse;
+    scanf("%d", &groesse);
+    int arraySize = berechnungDerLaengeDesQuadratArrays(groesse);
+    char Quadrat[arraySize];
+    befuellenDesArraysMitX(Quadrat, arraySize);
+    befuelleArrayMitLeerzeichen(Quadrat, arraySize);
+    befuelleArrayMitZeilenumbruechen(Quadrat,groesse);
+
+    printf("\n%s", Quadrat);
+
+}
+
+void weihnachtsbaum(){
+
+    abfrageDerHoehe();
+    int hoehe;
+    do{
+        // Diese Schleifen erfragen user input solange bis korrekte Werte eingegeben werden
+
+        scanf("%d", &hoehe);
+        if (hoehe < 3){
+            printf("\nDer Weihnachtsbaum muss mindestens 3 Zeilen groß sein!\n");
+            printf("Bitte geben Sie erneut einen Wert ein der mindestens 3 lautet:");
+        }
+    }while(hoehe < 3);
+
+    int maxBreiteDesWeihnachtsbaums = max_breite(hoehe);
+    int mitte_baum = mitteDesBaums(maxBreiteDesWeihnachtsbaums);
+    int groesseDesArrays = (hoehe -1) * maxBreiteDesWeihnachtsbaums;
+    char weihnachtsbaum[groesseDesArrays];
+    befuellenDesWeihnachtsbaumsMitLeerzeichen(weihnachtsbaum, groesseDesArrays);
+    befuellenDesWeihnachtsbaumsMitPlus(weihnachtsbaum, maxBreiteDesWeihnachtsbaums, (hoehe-1));
+    befuellenDesWeihnachtsbaumsMitZeilenumbruechen(weihnachtsbaum, hoehe, 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 hoehe;
+    do{
+        scanf("%d", &hoehe);
+        if(hoehe < 2){
+            printf("Es wurde ein Wert eingegeben, der kleiner ist als 2. Bitte geben Sie erneut eine Zahl ein!\n"
+                   "Eingbe:");
+        }
+    } while(hoehe < 2);
+
+    int arraygroesse = berechnungDerDreieckArraygroesse(hoehe);
+    char dreieck[arraygroesse];
+    befuellenDesDreiecksMitX(dreieck, arraygroesse);
+    befuellenDesDreiecksMitZeilenumbruechen(dreieck, hoehe, arraygroesse);
+    printf("%s", dreieck);
+
+}
+
+void rakete(){
+    raketeBegruessung();
+    int hoehe;
+    do{
+        scanf("%d", &hoehe);
+        if(hoehe < 3){
+            printf("Es wurde ein Wert eingegeben, der kleiner ist als 3. Bitte geben Sie erneut eine Zahl ein!\n"
+                   "Eingbe:");
+        }
+    } while(hoehe < 3);
+}
+
+
+int printWelcomeMessage(){
+    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 befuelleArrayMitLeerzeichen(char quadraT[], int laenge){
+
+
+    for (int i = 0; i < laenge; i++){
+        if(i % 2 != 0){
+            quadraT[i] = ' ';
+        }
+    }
+    quadraT[laenge-1] = '\0';
+}
+
+void befuelleArrayMitZeilenumbruechen(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_breite(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 mengeX = 1;
+
+    for(int i = zeilen; i > 0; i--){
+
+        int position = mitteDesBaums -1;
+
+         while(position < mitteDesBaums-1 + mengeX){
+             arr[position++] = '+';
+         }
+
+        mitteDesBaums += (maxBreite -1);
+         mengeX += 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] = '\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 printWelcomeMessage();
+void auswahlDerArt(int);
+void quadrat();
+int frageNachGroesse();
+int berechnungDerLaengeDesQuadratArrays(int);
+void befuellenDesArraysMitX(char[], int);
+void befuelleArrayMitLeerzeichen(char[],int);
+void befuelleArrayMitZeilenumbruechen(char[],int);
+void weihnachtsbaum();
+int abfrageDerHoehe();
+int max_breite(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

@@ -14,6 +14,7 @@
 #include "SchereSteinPapier.h"
 #include "hangman.h"
 #include "tictactoe.h"
+#include "ASCII_art.h"
 #include "Stefan/slot_machine.h"
 
 
@@ -37,9 +38,10 @@ void openInterface()
                "1: Schere-Stein-Papier\n"
                "2: Hangman\n"
                "3: TicTacToe\n"
-               "4: Slot Machine\n");
+               "4: Slot Machine\n"
+               "5: ASCII - Art\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);
+        scanf("%d", &selection);
 
 
         //todo
@@ -59,9 +61,9 @@ void openInterface()
                 case(4):
                     slotMachine();
                     break;
-                /*case(5):
-                    //Spiel()
-                    break;*/
+                case(5):
+                    ASCII_Art();
+                    break;
             default:
                 break;
         }

src/test/c/Jason/test_ASCII_art.c

@@ -0,0 +1,107 @@
+#include "unity.h"
+#include "ASCII_art.h"
+
+void setUp (void){
+
+}
+
+void tearDown(void){
+
+}
+
+void test_doesWelcomeMessageWork() {
+    //arrange
+    int expectedResult = 0;
+
+    //act
+    int actualResult = printWelcomeMessage();
+    //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";
+
+    // 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";
+
+    // act
+    char message[19];
+    befuellenDesArraysMitX(message, 18);
+    befuelleArrayMitLeerzeichen(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);
+    befuelleArrayMitLeerzeichen(message, 18);
+    befuelleArrayMitZeilenumbruechen(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_korrekteBerechnungAufMaximaleBreiteWeihnachtsbaum() {
+    //arrange
+    int expectedResult = 10;
+
+    //act
+    int actualResult = max_breite(6);
+    //assert
+
+    TEST_ASSERT_EQUAL_INT(expectedResult, actualResult);
+}