#include <stdlib.h>
#include <math.h>

#include <stdio.h>  // fuer Dev-C 

// Globale Variablen 
int 
    iEingangX, iEingangY, // Eingangskoordinaten 
    iAusgangX, iAusgangY,  // Ausgangskoordinaten 
    iCurX, iCurY, // Current X + Y 
    iCurTempX, iCurTempY, // Temp X + Y 
    Dx, Dy, // DeltaX, DeltaY (Maze) 
    iMaxFelder, // Max. Felder 
    iFeld[8], // #, 1, 2, 3, 4, E, A, S 
    iKompass, // Richtung 1=N, 2=O, 3=S, 4=W 
    AusgangGefunden, // 1 = Ausgang gefunden; 0 = Ausgang nicht gefunden 
    AusgangSetzen, // Richtung fuer Ausgang 
    Rueckweg, // 1 = Auf Rueckweg 
    Solutiontrack, // 1 = Aus Loesugspfad 
    iFFeld // Inhalt Richtung freies Feld (Rueckweg) 
;

char
    *Maze // Pointer zum Labyrint 
;

float 
    ranzahl // Randomzahl 
;

    //FILE *Mazedata;

// === Init Unterprogramme 
int EingabeMazedaten(void);
int ErzeugeEinMaze(void);
int ErzeugeEinMaze_ori(void);
int PruefRichungen(int x,int y, int z, int Richtung);
int Ran(void);
int Ranzahl(void);
int ConvXY(int x, int y);
int dezbin(int a);
int bindez(void);
int delFeld(void);
int BegeheMaze(void);
int lxx(void);
int xmx(void);
int xxr(void);
int lmr(void);
int lxr(void);
int xxx(void);
int lmx(void);
int xmr(void);
int MazeAnzeigen(void);
int Richtungen(void);
int Maze2File(void);

// === Hauptprogramm 
int main(void)
{
    int j;

    system ("cls"); // Clear Screen 
    Ran(); // Init Randomzahl 

    printf("\n 'Welcome to MacMaze'\n\n");

    EingabeMazedaten();
    ErzeugeEinMaze();
    Maze2File();
    BegeheMaze();

    // Maze loeschen 
    free (Maze); 

    printf("\n");
    
    return 0;
}


/// === Unterprogramme 
int EingabeMazedaten(void)
{

    // Eingabe Mazedimensionen 
    printf("Laenge (Dx) : ");
    scanf("%d",&Dx);

    printf("Hoehe (Dy): ");
    scanf("%d",&Dy);

    printf("\n");

    // Eingabe der Anfangs- und Endkoordinaten 
    printf("Eingang X: ");
    scanf("%d",&iEingangX);

    printf("Eingang Y: ");
    scanf("%d",&iEingangY);
    printf("\n");

    printf("Ausgang X: ");
    scanf("%d",&iAusgangX);

    printf("Ausgang Y: ");
    scanf("%d",&iAusgangY);
    printf("\n");

}

// ====
int ErzeugeEinMaze(void)
{
    int j, k, m, x, DirOK[5], iSuchRF[4], itmp, iWeg;
    int iRestElemente, Richtung, iErgebnis;
    char *Printzeile;

    // Ausgabedatei Mazedata 
    //Mazedata = fopen("mazedata.txt","wt");

    AusgangGefunden = 0;
    AusgangSetzen = 0;
    iMaxFelder = Dx * Dy;

    iRestElemente = iMaxFelder;
    iCurX = iEingangX;
    iCurY = iEingangY;

    //fprintf(Mazedata, "=== Mazedata ===\n");
    //fprintf(Mazedata, "Eingang: X=%d, Y=%d\n",iEingangX,iEingangY);
    //fprintf(Mazedata, "Ausgang: X=%d, Y=%d\n",iAusgangX,iAusgangY);

    Rueckweg = 0;
    Solutiontrack = 1;

    // Labyrint im Speicher erzeugen 
    Maze = (char *) malloc (Dx * Dy);
    if (Maze == NULL)
        printf("Fehler bei Erzeugung Maze !\n");

    // Labyrint mit Waenden fuellen 
    for (x = 0; x < iMaxFelder; x++)
    {
        //  Maze[x] = 1;
        delFeld(); 
        iFeld[0] = 1;
        itmp = bindez();
        Maze[x] = itmp;
    }

    // Eingang setzen 
    // #, 1, 2, 3, 4, E, A, S 
    delFeld(); 
    iFeld[5] = 1;
    itmp = bindez();
    Maze[ConvXY(iEingangX,iEingangY)] = itmp;

    // Ausgang setzen 
    // #, 1, 2, 3, 4, E, A, S 
    delFeld(); 
    iFeld[6] = 1;
    itmp = bindez();
    Maze[ConvXY(iAusgangX, iAusgangY)] = itmp;
    Richtung = 0;
    
    
    iRestElemente = iRestElemente - 1;
    
    
    // Auf die Suche, fertig.. :) 
    while (iRestElemente > 0 )
    {

        // fprintf(Mazedata, "\nPosition x=%d, y=%d\n", iCurX, iCurY);
        // fprintf(Mazedata, "Suchrichtung: %d\n",Richtung);
        
        // DirOK loeschen 
        for (k=0; k<5; k++)
            DirOK[k] = 0;

        // In welchen Richtungen darf gesucht werden ? 
        switch (Richtung)
        {
            case 0:
                // Anfangswerte (Eingang) 
                iSuchRF[1] = 2; iSuchRF[2] = 1; iSuchRF[3] = 4; // iSuchRF[0] = 3; 
                break;
            case 1: // Richtung Norden 
                iSuchRF[1] = 2; iSuchRF[2] = 1; iSuchRF[3] = 4;
                break;
            case 2: // Richtung Osten 
                iSuchRF[1] = 3; iSuchRF[2] = 2; iSuchRF[3] = 1;
                break;
            case 3: // Richtung Sueden 
                iSuchRF[1] = 4; iSuchRF[2] = 3; iSuchRF[3] = 2;
                break;
            case 4: // Richtung Westen 
                iSuchRF[1] = 1; iSuchRF[2] = 4; iSuchRF[3] = 3;
                break;        
        }

        if (Rueckweg == 1)
        {
            iWeg = 1; // Rueckweg 
            iFFeld = 0;
            // fprintf(Mazedata, "Suchstatus: Rueckweg\n");
        }
        else
        {
            iWeg = 0; // Normale Suche 
            // fprintf(Mazedata, "Suchstatus: Normale Suche\n");   
        }

        // Pruefen ob Zelle benutzt werden kann 
        for (j=1, k=0; j<4; j++)
        { 
            switch (iSuchRF[j])
            {
            case 1:
                // fprintf(Mazedata,"1 ..");
                iErgebnis = PruefRichungen(iCurX, iCurY+1, iWeg, iSuchRF[j]);
                if (AusgangSetzen == 5)
                    AusgangSetzen = iSuchRF[j];
                break;
            case 2:
                // fprintf(Mazedata,"2 ..");
                iErgebnis = PruefRichungen(iCurX+1, iCurY, iWeg, iSuchRF[j]);
                if (AusgangSetzen == 5)
                    AusgangSetzen = iSuchRF[j];
                break;
            case 3:
                // fprintf(Mazedata,"3 ..");
                iErgebnis = PruefRichungen(iCurX, iCurY-1, iWeg, iSuchRF[j]);
                if (AusgangSetzen == 5)
                    AusgangSetzen = iSuchRF[j];
                break;
            case 4:
                // fprintf(Mazedata,"4 ..");
                iErgebnis = PruefRichungen(iCurX-1, iCurY, iWeg, iSuchRF[j]);
                if (AusgangSetzen == 5)
                    AusgangSetzen = iSuchRF[j];
                break;
            }
            if (iErgebnis == 1)
            {
                // OK, Feld kann benutzt werden 
                k++;
                DirOK[k] = iSuchRF[j];
                DirOK[0] = k;
                // fprintf(Mazedata," kann benutzt werden !\n");
            }
            else
            {
                // fprintf(Mazedata," kann NICHT benutzt werden !\n");
            }
        }

        
        if (Rueckweg == 1 && iFFeld != 0)
        {
            // Leeres Feld benutzen 
            DirOK[0] = 1;
            DirOK[1] = iFFeld;

            // Rueckweg beendet 
            // fprintf(Mazedata,"Rueckweg beenden!\n");
            Rueckweg = 0;
        }

        else if (DirOK[0] == 0) // Keine freien Felder verfuegbar 
        {
            // = > Rueckweg ! 
            Rueckweg = 1;
            
            // fprintf(Mazedata,"Richtung umdrehen!\n");
        
            // Richtung umdrehen 
            switch (Richtung)
            {
                case 1: Richtung = 3; break;
                case 2: Richtung = 4; break;
                case 3: Richtung = 1; break;
                case 4: Richtung = 2; break;                                           
            }
            
            // fprintf(Mazedata,"Rueckweg!\n");
        }

        else if (AusgangSetzen != 0)
        {
            // Ausgang gefunden 
            DirOK[0] = 1;
            DirOK[1] = AusgangSetzen;
            
            // fprintf(Mazedata,"Ausgang setzen!\n");
        
        }    
    
        if (DirOK[0] > 0)
        {   
            // < DirOK[0] > moegliche Richtungen 
            // -> Richtungsauswahl per Zufallszahl 
         
            // Suche 
            if (Rueckweg == 1)
                Richtung = DirOK[1];
            else
                Richtung = DirOK[ (int) ((ranzahl * DirOK[0]) + 1)];
            
            // fprintf(Mazedata,"DirOK[%d], %d, %d, %d, %d\n", DirOK[0], DirOK[1], DirOK[2], DirOK[3], DirOK[4]);
            // fprintf(Mazedata,"Richtung: %d\n", Richtung);
            
            switch (Richtung)
            {
            case 1: // Richtung NORDEN 

                if (Rueckweg == 0) iRestElemente--;

                iCurTempX = iCurX;
            	iCurTempY = iCurY + 1; 

            	Ranzahl(); // Neue Zufallszahl 

            	// Alte Zelle 
            	dezbin(Maze[ConvXY(iCurX,iCurY)]);
            	iFeld[0] = 0;
            	iFeld[1] = 1;
               	itmp = bindez();
            	Maze[ConvXY(iCurX,iCurY)] = itmp;

            	// Neue Zelle	
            	dezbin(Maze[ConvXY(iCurTempX,iCurTempY)]);
            	iFeld[0] = 0;
            	iFeld[3] = 1;
            	itmp = bindez();
            	Maze[ConvXY(iCurTempX,iCurTempY)] = itmp;
            	break;

            case 2: // Richtung OSTEN 

                if (Rueckweg == 0) iRestElemente--;

                iCurTempX = iCurX + 1;
                iCurTempY = iCurY;

                Ranzahl(); // Neue Zufallszahl 

                // Alte Zelle 
                dezbin(Maze[ConvXY(iCurX,iCurY)]);
                iFeld[0] = 0;
                iFeld[2] = 1;
                itmp = bindez();
                Maze[ConvXY(iCurX,iCurY)] = itmp;

                // Neue Zelle	
                dezbin(Maze[ConvXY(iCurTempX,iCurTempY)]);
                iFeld[0] = 0;
            	iFeld[4] = 1;
            	itmp = bindez();
            	Maze[ConvXY(iCurTempX,iCurTempY)] = itmp;
            	break;

            case 3: // Richtung SUEDEN 

                if (Rueckweg == 0) iRestElemente--;

                iCurTempX = iCurX;
            	iCurTempY = iCurY - 1;

            	Ranzahl(); // Neue Zufallszahl 

            	// Alte Zelle 
            	dezbin(Maze[ConvXY(iCurX,iCurY)]);
            	iFeld[0] = 0;
            	iFeld[3] = 1;
            	itmp = bindez();
            	Maze[ConvXY(iCurX,iCurY)] = itmp;

            	// Neue Zelle	
            	dezbin(Maze[ConvXY(iCurTempX,iCurTempY)]);
            	iFeld[0] = 0;
            	iFeld[1] = 1;
            	itmp = bindez();
            	Maze[ConvXY(iCurTempX,iCurTempY)] = itmp;
            	break;

            case 4: // Richtung WESTEN 

                if (Rueckweg == 0) iRestElemente--;

                iCurTempX = iCurX - 1;
            	iCurTempY = iCurY;

            	Ranzahl(); // Neue Zufallszahl 

            	// Alte Zelle 
            	dezbin(Maze[ConvXY(iCurX,iCurY)]);
            	iFeld[0] = 0;
            	iFeld[4] = 1;
            	itmp = bindez();
            	Maze[ConvXY(iCurX,iCurY)] = itmp;

            	// Neue Zelle	
            	dezbin(Maze[ConvXY(iCurTempX,iCurTempY)]);
            	iFeld[0] = 0;
            	iFeld[2] = 1;
            	itmp = bindez();
            	Maze[ConvXY(iCurTempX,iCurTempY)] = itmp;
            	break;
            }

            if (AusgangSetzen == 0)
            {
                iCurX = iCurTempX;
                iCurY = iCurTempY; 
            }
            else
                AusgangSetzen = 0;

        }
    
    }

    //fclose (Mazedata);
}

// ====
int PruefRichungen(int x,int y, int z, int Richtung)
{
    int antwort;

    // Mazezelle analysieren 
    // Antwort = 0 falls Zelle nicht existiert 
    // #, 1, 2, 3, 4, E, A, S 
    // 20, 21, 22, 23, 24, 25, 26, 27 

    // z = Suchmodus ( 0 = Normale Suche, 1 = Rueckweg) 

    antwort = 0;
    // Werden Grenzen ueberschritten ? 
    if (x < 1 || x > Dx || y < 1 || y > Dy)
    {
        // fprintf(Mazedata," ( Grenze erreicht (x=%d,y=%d) )",x,y);
        antwort = 0;
    }
    else
    {    
        switch (z)
        {
            case 0: // Normale Suche 
    
                // Ist Feld bereits belegt ? 
                // if (Maze[ConvXY(x,y)] != 1) 
                dezbin(Maze[ConvXY(x,y)]);
                if (iFeld[0] == 0)
                {
                    // Ist Feld der Ausgang ? 
                    if (x == iAusgangX && y == iAusgangY)
                    {
                        if (AusgangGefunden == 0 && AusgangSetzen == 0)
                        {
                            AusgangGefunden = 1;
                            AusgangSetzen = 5;
                            antwort = 1;
                        }
                    }
                    else
                        antwort = 0;
                }
                else
                    antwort = 1;                   
                break;

            case 1: // Rueckweg - Freies Feld 
                // Ist Feld frei ? 
                // if (Maze[ConvXY(x,y)] != 1) 
                dezbin(Maze[ConvXY(x,y)]);
                if (iFeld[0] == 1)
                {
                    // fprintf(Mazedata," (Freies Feld auf X=%d, Y=%d gefunden!)", x, y);
                    antwort = 1; 
                    iFFeld = Richtung;
                }
                else
                {
                // Oder ist Tuer vorhanden ?
                // Verbindungstuer (!) 
                dezbin(Maze[ConvXY(x,y)]);
                switch (Richtung)
                {
                case 1:
                    if (iFeld[3] == 1)
                        antwort = 1;
                        // fprintf(Mazedata," (Verbindungstuer (x=%d,y=%d) - Richtung : 3!)", x, y);
                    break;
                case 2:
                    if (iFeld[4] == 1)
                        antwort = 1;
                        // fprintf(Mazedata," (Verbindungstuer (x=%d,y=%d) - Richtung : 4!)", x, y);
                    break;
                case 3:
                    if (iFeld[1] == 1)
                        antwort = 1;                    
                        // fprintf(Mazedata," (Verbindungstuer (x=%d,y=%d) - Richtung : 1!)", x, y);
                    break;
                case 4:
                    if (iFeld[2] == 1)
                        antwort = 1;
                        // fprintf(Mazedata," (Verbindungstuer (x=%d,y=%d) - Richtung : 2!)", x, y);
                    break;
                }
               
                break;
            }
        }
    }
    return (antwort); // 1 = OK 
}

int Ran()
{
    FILE *Datei;
    int j, jran, seed;
    float f;

    // Init Random 
    Datei = fopen("ran.dat","rt");
    if (Datei == NULL)
    {
        printf("Ran Zahl: ");
    	scanf("%d",&jran);

        Datei = fopen("ran.dat","wt");
        // fprintf(Datei, "%i",jran);
        fclose (Datei);
    }
    else
    {
	   Datei = fopen("ran.dat","rt");
	   fscanf(Datei,"%i",&jran);
        fclose (Datei);
    }

    seed = jran;
    srand(seed);
    jran = rand()%100000;

    Datei = fopen("ran.dat","wt");
    // fprintf(Datei, "%i",jran);
    fclose (Datei);

    ranzahl = jran/3.14159265358;
    ranzahl = ranzahl - (int) ranzahl;

    return 0;

}

int Ranzahl(void)
{
    int j;

        ranzahl = ranzahl * 997;
        ranzahl = ranzahl - (int) ranzahl;
}

int ConvXY(int x, int y)
{
    int k;

    k = (Dx*(y-1)) + x - 1;

    return k;

}

int dezbin(int a)
{
    int i, rest;

    rest = a;

    // Umwandlung Dezimalzahl in Binaerzahl 
    for (i=7; i>=0; i--)
    {        
        if (rest - (int) pow(2,i) >= 0)
        {
            iFeld[i] = 1;
            rest = rest - (int) pow(2,i);
        }
        else
        {
            iFeld[i] = 0;
        }
    }        
}

int bindez(void)
{
    // Umwandlung Binaerzahl in Dezimalzahl 

    int i, j, sum, temp;

    sum = 0;
    for (i=0; i<8; i++)
    {
        if (iFeld[i] == 1)
        {
            temp = (int) pow(2,i);
            sum = sum + temp;
        }        
    }
    return (sum);
}

int delFeld(void)
{
int j;
    for (j=0; j<8; j++)
        iFeld[j] = 0;
}

int lxx(void)
{
    printf("################\n");
    printf("#  #############\n");
    printf("#  #############\n");
    printf("#  #############\n");
    printf("#  #############\n");
    printf("#  #############\n");
    printf("#  #############\n");
    printf("################\n");
}

int xmx(void)
{
    printf("################\n");
    printf("#####      #####\n");
    printf("#####      #####\n");
    printf("#####      #####\n");
    printf("#####      #####\n");
    printf("#####      #####\n");
    printf("#####      #####\n");
    printf("################\n");
}

int xxr(void)
{
    printf("################\n");
    printf("#############  #\n");
    printf("#############  #\n");
    printf("#############  #\n");
    printf("#############  #\n");
    printf("#############  #\n");
    printf("#############  #\n");
    printf("################\n");
}

int lmr(void)
{
    printf("################\n");
    printf("#  ##      ##  #\n");
    printf("#  ##      ##  #\n");
    printf("#  ##      ##  #\n");
    printf("#  ##      ##  #\n");
    printf("#  ##      ##  #\n");
    printf("#  ##      ##  #\n");
    printf("################\n");
}

int lxr(void)
{
    printf("################\n");
    printf("#  ##########  #\n");
    printf("#  ##########  #\n");
    printf("#  ##########  #\n");
    printf("#  ##########  #\n");
    printf("#  ##########  #\n");
    printf("#  ##########  #\n");
    printf("################\n");
}

int xxx(void)
{
    printf("################\n");
    printf("################\n");
    printf("################\n");
    printf("################\n");
    printf("################\n");
    printf("################\n");
    printf("################\n");
    printf("################\n");
}

int lmx(void)
{
    printf("################\n");
    printf("#  ##      #####\n");
    printf("#  ##      #####\n");
    printf("#  ##      #####\n");
    printf("#  ##      #####\n");
    printf("#  ##      #####\n");
    printf("#  ##      #####\n");
    printf("################\n");
}

int xmr(void)
{
    printf("################\n");
    printf("#####      ##  #\n");
    printf("#####      ##  #\n");
    printf("#####      ##  #\n");
    printf("#####      ##  #\n");
    printf("#####      ##  #\n");
    printf("#####      ##  #\n");
    printf("################\n");
}

int Richtungen(void)
{
    char tuer[3];
    
    delFeld();
    dezbin(Maze[ConvXY(iCurX,iCurY)]);
    
    // Richtungen (Tueren) anzeigen 
    tuer[0] = tuer[1] = tuer[2] = 'x';
    switch (iKompass)
    {
        case 1:
            if (iFeld[4] == 1) tuer[0] = 'l';
            if (iFeld[1] == 1) tuer[1] = 'm';
            if (iFeld[2] == 1) tuer[2] = 'r';
            break;
        case 2:
            if (iFeld[1] == 1) tuer[0] = 'l';
            if (iFeld[2] == 1) tuer[1] = 'm';
            if (iFeld[3] == 1) tuer[2] = 'r';
            break;
        case 3:
            if (iFeld[2] == 1) tuer[0] = 'l';
            if (iFeld[3] == 1) tuer[1] = 'm';
            if (iFeld[4] == 1) tuer[2] = 'r';
            break;
        case 4:
            if (iFeld[3] == 1) tuer[0] = 'l';
            if (iFeld[4] == 1) tuer[1] = 'm';
            if (iFeld[1] == 1) tuer[2] = 'r';
            break;
    }

    if (tuer[0] == 'l' && tuer[1] == 'm' && tuer[2] == 'r') lmr();
    else if (tuer[0] == 'l' && tuer[1] == 'm' && tuer[2] == 'x') lmx();
    else if (tuer[0] == 'l' && tuer[1] == 'x' && tuer[2] == 'r') lxr();
    else if (tuer[0] == 'l' && tuer[1] == 'x' && tuer[2] == 'x') lxx();
    else if (tuer[0] == 'x' && tuer[1] == 'm' && tuer[2] == 'r') xmr();
    else if (tuer[0] == 'x' && tuer[1] == 'm' && tuer[2] == 'x') xmx();
    else if (tuer[0] == 'x' && tuer[1] == 'x' && tuer[2] == 'r') xxr();
    else if (tuer[0] == 'x' && tuer[1] == 'x' && tuer[2] == 'x') xxx();

}

int MazeAnzeigen(void)
{
    char *Printzeile1, *Printzeile2;
    int j, k, m, x, y, taste, ipointer;

    // Printzeilen im Speicher erzeugen 
    Printzeile1 = (char *) malloc (Dx+(Dx-1)+2+1);
    if (Printzeile1 == NULL)
        printf("Fehler bei Erzeugung PRINTZEILE1 !\n");
    Printzeile2 = (char *) malloc (Dx+(Dx-1)+2+1);
    if (Printzeile2 == NULL)
        printf("Fehler bei Erzeugung PRINTZEILE2 !\n");

    // Clear Screen 
    system ("cls");
    
    // Printzeilen loeschen 
    for (j = 0; j< Dx+(Dx-1)+2; j++)
    {
        Printzeile1[j] = ' '; 
        Printzeile2[j] = ' '; 
    }
    Printzeile1 [j] = '\0';
    Printzeile2 [j] = '\0';

    // Oberste Wand ziehen 
    for (j = 0; j< Dx+(Dx-1)+2; j++)
        Printzeile1[j] = '#';
    printf("%s\n",Printzeile1);
    
    for (y=Dy; y>0; y--)
    {
        ipointer = 0;
        for (j = 0; j< Dx+(Dx-1)+2; j++)
        {
             // Printzeilen loeschen 
            Printzeile1[j] = ' ';
            Printzeile2[j] = ' ';
        }
        Printzeile1 [j] = '\0';
        Printzeile2 [j] = '\0';
        
        Printzeile1[ipointer] = '#';
        Printzeile2[ipointer] = '#';
        ipointer++;
        for (x=1; x<=Dx; x++)
        {
            dezbin(Maze[ConvXY(x,y)]);
            if (iFeld[0] == 1)
                Printzeile1[ipointer] = '#';
            else if (iFeld[5] == 1)
                Printzeile1[ipointer] = 'E';
            else if (iFeld[6] == 1)
                Printzeile1[ipointer] = 'A';
            else
                Printzeile1[ipointer] = ' ';

            // Eigene Position anzeigen 
            if (x == iCurX && y == iCurY)
                Printzeile1[ipointer] = 'X';                

            if (iFeld[3] == 1)
                Printzeile2[ipointer] = ' ';
            else
                Printzeile2[ipointer] = '#';

            ipointer++;

            if (iFeld[2] == 1)
                Printzeile1[ipointer] = ' ';
            else
                Printzeile1[ipointer] = '#';
                
            Printzeile2[ipointer] = '#';
            
            ipointer++;
        }
        printf("%s\n",Printzeile1);
        printf("%s\n",Printzeile2);
    }
    
    taste = 1;
//    {
        scanf("%d",&taste);
//     } while ( taste > 3 )

    free (Printzeile1);
    free (Printzeile2);
}

int BegeheMaze(void)
{
    int iEingabe;

    iCurX = iEingangX;
    iCurY = iEingangY;
    iKompass = 1; //  Zuerst immer nach Norden schauen 

    while ((int) iEingabe != 0 )
    {
        system ("cls"); // Clear Screen 

        // Kompass anzeigen 
        printf("Kompass: ");
        switch (iKompass)
        {
        case 1:
            printf("Norden\n");
            break;        
        case 2:
            printf("Osten\n");
            break;
        case 3:
            printf("Sueden\n");
            break;
        case 4:
            printf("Westen\n");
            break;
        }
    
        // Tueren anzeigen 
        Richtungen();

        //printf("\n");
        printf("Location: ");
        // Location pruefen 
        if (iCurX == iEingangX && iCurY == iEingangY)
            printf("Eingang\n");
        else if (iCurX == iAusgangX && iCurY == iAusgangY)
            printf("Ausgang\n");
        else
            printf("X%d/Y%d\n",iCurX, iCurY);
            
        //printf("\n");
        //printf("(L=1, M=2, R=3)\n\n");
        printf("Richtung : ");

//       {
          scanf("%d",&iEingabe);
//          printf("Eingabe: %d",iEingabe);
//       } while ( iEingabe > 3 )

        switch (iEingabe)
        {
        case 1:
            iKompass--;
            if (iKompass == 0) iKompass = 4;
            break;
        case 2:
            iKompass = iKompass; // Richtung bleibt 
        
            // Vorwaerts gehen (nur wenn Tuer vorhanden ist !) 
            delFeld();
            dezbin(Maze[ConvXY(iCurX,iCurY)]);
    
            switch (iKompass)
            {
            case 1:
                if (iFeld[1] == 1) iCurY++;
                break;
            case 2:
                if (iFeld[2] == 1) iCurX++;
                break;
            case 3:
                if (iFeld[3] == 1) iCurY--;
                break;
            case 4:
                if (iFeld[4] == 1) iCurX--;
                break;        
            }
            break;
        case 3:
            iKompass++;
            if (iKompass == 5) iKompass = 1;    
            break;
        case 9:
            // Maze anzeigen 
            MazeAnzeigen();
            break;
        }
    }
}

int Maze2File(void)
{
    char *Printzeile1, *Printzeile2;
    int j, k, m, x, y, taste, ipointer;

    FILE *Mazefile;

    Mazefile = fopen("maze.txt","wt");

    // Printzeilen im Speicher erzeugen 
    Printzeile1 = (char *) malloc (Dx+(Dx-1)+2+1);
    if (Printzeile1 == NULL)
        printf("MAZEFILE: Fehler bei Erzeugung PRINTZEILE1 !\n");
    Printzeile2 = (char *) malloc (Dx+(Dx-1)+2+1);
    if (Printzeile2 == NULL)
        printf("MAZEFILE: Fehler bei Erzeugung PRINTZEILE2 !\n");

    // Printzeilen loeschen 
    for (j = 0; j< Dx+(Dx-1)+2; j++)
    {
        Printzeile1[j] = ' '; 
        Printzeile2[j] = ' '; 
    }
    Printzeile1 [j] = '\0';
    Printzeile2 [j] = '\0';

    // Oberste Wand ziehen 
    for (j = 0; j< Dx+(Dx-1)+2; j++)
        Printzeile1[j] = '#';
    fprintf(Mazefile, "%s\n",Printzeile1);
    
    for (y=Dy; y>0; y--)
    {
        ipointer = 0;
        for (j = 0; j< Dx+(Dx-1)+2; j++)
        {
             // Printzeilen loeschen 
            Printzeile1[j] = ' ';
            Printzeile2[j] = ' ';
        }
        Printzeile1 [j] = '\0';
        Printzeile2 [j] = '\0';
        
        Printzeile1[ipointer] = '#';
        Printzeile2[ipointer] = '#';
        ipointer++;
        for (x=1; x<=Dx; x++)
        {
            dezbin(Maze[ConvXY(x,y)]);
            if (iFeld[0] == 1)
                Printzeile1[ipointer] = '#';
            else if (iFeld[5] == 1)
                Printzeile1[ipointer] = 'E';
            else if (iFeld[6] == 1)
                Printzeile1[ipointer] = 'A';
            else
                Printzeile1[ipointer] = '_';               

            if (iFeld[3] == 1)
                Printzeile2[ipointer] = '_';
            else
                Printzeile2[ipointer] = '#';

            ipointer++;

            if (iFeld[2] == 1)
                Printzeile1[ipointer] = '_';
            else
                Printzeile1[ipointer] = '#';
                
            Printzeile2[ipointer] = '#';
            
            ipointer++;
        }
        fprintf(Mazefile, "%s\n",Printzeile1);
        fprintf(Mazefile, "%s\n",Printzeile2);
    }
    
    free (Printzeile1);
    free (Printzeile2);
    
    fclose (Mazefile);
}