Schiffe Versenken

/*
                "Schiffe" versenken
    (Wären das dann nicht eigendlich U-Boote wenn man sie nur sieht wenn sie getroffen wurden?)
         Code geschrieben von Tobias Schmidt

         Legende:
            ~ - Wasser
            S - Schiff
            o - Getroffenes "Schiff"
            x - Fehlgeschlagener Schuss

*/
#include <stdio.h>
#include <stdbool.h>
#include <time.h>
#include <stdlib.h>
#include <unistd.h>

#define sizeX 8
#define sizeY 8
#define maxCachedGegnerZuege 4
#define maxShips 16

// Interne Variablen
#define wasser 0
#define daneben 1
#define treffer 2
#define schiff 3
#define bereits_Daneben 11
#define bereits_Getroffen 22

// Das sieht man später anstatt der Variablen
#define wasser_Icon "~ "
#define daneben_Icon "x "
#define treffer_Icon "O "
#define schiff_Icon "S "
#define bereits_Daneben_Icon "D "
#define bereits_Getroffen_Icon "G "

// Headerkrams

void generiereSpielFeld(int spielFeld[sizeX][sizeY]);
void zeigeSpielFeld(int spielFeld[sizeX][sizeY], bool nurGetroffen);
int macheSpielZug (int spielFeld[sizeX][sizeY], int zugX, int zugY);
bool menschlicherSpielZug(int spielFeld[sizeX][sizeY], bool istSpieler1, int mode, int debugx, int debugy);

bool menschlicherSpielZug(int spielFeld[sizeX][sizeY], bool istSpieler1, int mode, int debugx, int debugy) {
    if (istSpieler1 && mode == 1) printf("\n\t\tDu bist am zug!\n");
    else if (istSpieler1 && mode == 2) printf("\n\t\tSpieler 1 ist am zug!\n");
    else if (!istSpieler1 && mode == 2) printf("\n\t\tSpieler 2 ist am zug!\n");
    else if (istSpieler1 && mode == 3) printf("\n\t\tTestmodus\n");
    if (mode == 3) zeigeSpielFeld(spielFeld, false);
    else zeigeSpielFeld(spielFeld, true);
    int nextx;
    if (debugx == -1){
        do {    // Nested Loop, hurray!
            printf("\n\t Naechster Zug: X Koordinate: ");
            scanf("%d", &nextx);
            nextx--;
            if (nextx > sizeX)
            {
                printf("\tDie X Koordinate ist zu gross!\n");
            } else if (nextx < 0) {
                printf("\tDie X Koordinate ist zu klein!\n");
            } else {
                break;
            }
        } while (1);
    } else nextx = debugx;
    int nexty;
    if (debugy == -1) {
        do {    // Nested Loop again, hurray!
            printf("\n\t Naechster Zug: Y Koordinate: ");
            scanf("%d", &nexty);
            nexty--;
            if (nexty > sizeY)
            {
                printf("\tDie Y Koordinate ist zu gross!");
            } else if (nexty < 0) {
                printf("\tDie Y Koordinate ist zu klein!");
            } else {
                break;
            }

        } while (1);
    } else nexty = debugy;
    if (mode == 3) printf("X: %d - Y: %d", nextx, nexty);
    int state = macheSpielZug(spielFeld, nextx, nexty);
    spielFeld[nextx][nexty] = state;
    if (state == treffer) {
        //spielFeld[nextx][nexty] = treffer;
        printf("\n\t TREFFER! - Gegnerisches Schiff versenkt!\n");
    } else if (state == daneben) {
        //spielFeld[nextx][nexty] = daneben;
        printf("\n\t Daneben! - Leider nur Wasseratome getroffen.!\n");
    } else if (state == bereits_Daneben) {
        printf("\n\t Immernoch Daneben! - Hier ist nach wie vor kein Schiff!\n");
    }
    else if ( state == bereits_Getroffen) {
        printf("\n\t Schiff bereits getroffen! - Die sind doch bereits alle tot!...\n");
    }
    else {
        printf("\n\t Unbekannter Zustand... Der Entwickler ist Doof!\n");
    }
    return 1;
}

int macheSpielZug (int spielFeld[sizeX][sizeY], int zugX, int zugY) {
    int status = spielFeld[zugX][zugX];
    if (status == schiff) {
        return treffer;
    } else if (status == daneben) return bereits_Daneben;
    else if (status == wasser) {
        return daneben;
    } else if (status == treffer) return bereits_Getroffen;
}

void generiereSpielFeld(int spielFeld[sizeX][sizeY]) {
    int totalShipps = 0;
    for (int e = 0; e<maxShips; e++) {
        int x = rand() % sizeX;
        int y = rand() % sizeY;
        if (spielFeld[x][y] != schiff) spielFeld[x][y] = schiff;
        else x--;
    }
}

void zeigeSpielFeld(int spielFeld[sizeX][sizeY], bool nurGetroffen)
{
    for (int x = 0; x < sizeX; x++)
    {
        for (int y = 0; y < sizeY; y++)
        {
            // AußenBorder Start
            if (x == 0 && y == 0){
                printf("# X ");
                for (int k = 0; k < sizeX; k++)
                {
                    printf("%d ", k+1);
                }
                printf("\nY\n1   ");
            }
            if (x != 0 && y == 0)
            {
                printf("%d   ", x + 1);
            }
            // AußenBorder Ende
            // Spielfeld Zeichnen Start
            int toPrint = spielFeld[y][x];
            if (nurGetroffen){
                if(toPrint == schiff) toPrint = 0;
            }

            switch (toPrint)
            {
                case wasser:    printf(wasser_Icon); break;
                case daneben:   printf(daneben_Icon); break;
                case treffer:   printf(treffer_Icon); break;
                case schiff:    printf(schiff_Icon); break;
            }
            //printf("%d|%d ", x, y);
            // Spielfeld Zeichnen Ende

        }
        printf("\n");
    }
}

int main() {
    // Variablen Initialisieren
    int spielFeldPlayer[sizeX][sizeY] = { 0 };
    int spielFeldGegner[sizeX][sizeY] = { 0 };
    int letzteGegnerZuege[maxCachedGegnerZuege][2];
    int mode = 0; // Modi: 0 - Ungenutzt, 1 - gegen KI, 2 - 2 Spieler, 3 - test modus (versteckt)
    bool spieler1AmZug = true;
    bool spielVerlassen = false;
    int debugx = 0;
    int debugy = 0;
    srand(time(NULL)); // Wir setzten einen Seed für den Zufallsgenerator.

    printf("**********************************\n");
    printf("* \"Schiffe\" versenken! Oder so...*\n");
    printf("**********************************\n\n");
    printf("\t\t Hauptmenue:\n");
    printf("\t1) Neues Spiel (gegen KI)\n");
    printf("\t2) Neues Spiel (2 Spieler Modus)\n");
    printf("\t3) Testmodus\n");
    printf("\t4) Autofill\n");
    printf("\n\t0) Spiel Beenden\n");
    printf("\n\tAuswaehlen: ");
    int hauptMenue = 1;
    scanf("%d", &hauptMenue);

    switch (hauptMenue)
    {
        case 1: mode = 1; break;
        case 2: mode = 2; break;
        case 3: mode = 3; break;
        case 4: mode = 4; break;
        case 0: return 0; break; // break ist echt voll super sinnvoll hier. Echt jetzt... nicht ...
    }
    generiereSpielFeld(spielFeldGegner);
    if(mode != 3 && mode != 4){
        printf("Generiere Spielfelder:");
        printf("\n\t- Spieler 1 Komplett -");
        generiereSpielFeld(spielFeldPlayer); // Wir generieren für den Spieler das Spielfeld
        if (mode == 1) printf("\n\t- KI-Gegner Komplett - \n");
        else printf("\n\t- Spieler 2 Komplett - \n");
        generiereSpielFeld(spielFeldGegner); // Wir generieren für den (KI-)Gegner das Spielfeld
    } else printf("\n");
    do {
        if (spieler1AmZug)
        {
            if (mode == 4) {
                menschlicherSpielZug(spielFeldGegner, spieler1AmZug, mode, debugx, debugy);
                if (debugx < 8) debugx++;
                else {
                    debugx = 0;
                    debugy++;
                }
                if (debugy == 8)  {
                    spielVerlassen = !spielVerlassen;
                    break;
                }
                sleep(1);

            } else {
                menschlicherSpielZug(spielFeldGegner, spieler1AmZug, mode, -1, -1); // Wir laden das gegnerische Spielfeld. Wir wollen ja nicht unsere eigenen Schiffe wegmachen
                if (mode != 3) spieler1AmZug = !spieler1AmZug;
            }
        } else {
            if (mode == 1) {
                // KI Spielzug
            } else {
                menschlicherSpielZug(spielFeldPlayer, spieler1AmZug, mode, -1, -1); // Mode ist total sinnlos hier... | Wir das das Spielfeld von Spieler 1.
                spieler1AmZug = !spieler1AmZug;
            }
        }
    } while(!spielVerlassen);
    return 0;
}