#include "allegro5/allegro.h"

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


#define BildgroesseX    800
#define BildgroesseY    800
#define MaxResis 1536

#define MitteX BildgroesseX/2
#define MitteY BildgroesseY/2


typedef struct
{
    double Realteil;
    double Imaginaerteil;
}sCompNmr;

void ComplexMul (sCompNmr A, sCompNmr B, sCompNmr *Ergebnis);
int ResistenceCheck (uint32_t Nmax, sCompNmr C);
int ResistenceCheck2 (uint32_t Nmax, sCompNmr C);


ALLEGRO_DISPLAY *display;
ALLEGRO_DISPLAY *display2;


int main()
{
    sCompNmr C;
    sCompNmr Z;
    sCompNmr Ergebnis;

    double PosX = -0.74776;
    double PosY = 0.0889125;
    double DivX = 0.00025;
    double DivY = 0.00025;

    double yMin = PosY - DivY;        //Der Bereich der komplexen Ebene, der auf der "Leinwand" abgebildet wird
    double yMax = PosY + DivY;
    double xMin = PosX - DivX;
    double xMax = PosX + DivX;

    //int Bildarray[(BildgroesseX*3)][(BildgroesseY*3)];
    int Subpixel = 0;

    int Xakt = 0;
    int Yakt = 0;
    int Resistenz = 0;

    srand(time(NULL));  //Zufallsgenerator initialisieren

    if(!al_init())
    {
        printf("Nich genuch Speicher");
        return EXIT_FAILURE;
    }

    display = al_create_display(BildgroesseX, BildgroesseY);


    while(Xakt < BildgroesseX)
    {
        while(Yakt < BildgroesseY)
        {
            C.Realteil = xMin + ( ( (xMax - xMin) / BildgroesseX ) * Xakt);
            C.Imaginaerteil = yMin + ( ( (yMax - yMin) / BildgroesseY ) * Yakt);

            Resistenz = ResistenceCheck(MaxResis, C);

            if ( Resistenz >= MaxResis )
                {
                    al_draw_pixel (Xakt, Yakt, al_map_rgb(0, 0, 0) );
                }
            else if ( Resistenz <= 255)
                {
                    al_draw_pixel (Xakt, Yakt, al_map_rgb(255, (Resistenz), 0) );
                }
            else if ( Resistenz > 255 & Resistenz <= 511)
                {
                    al_draw_pixel (Xakt, Yakt, al_map_rgb(255-(Resistenz), 255, 0) );
                }
            else if ( Resistenz > 511 & Resistenz <= 767)
                {
                    al_draw_pixel (Xakt, Yakt, al_map_rgb(0, 255, (Resistenz)) );
                }
            else if ( Resistenz > 767 & Resistenz <= 1023)
                {
                    al_draw_pixel (Xakt, Yakt, al_map_rgb(0, 255-(Resistenz), 255) );
                }
            else if ( Resistenz > 1023 & Resistenz <= 1279)
                {
                    al_draw_pixel (Xakt, Yakt, al_map_rgb((Resistenz), 0, 255) );
                }
            else if ( Resistenz > 1279 & Resistenz <= 1535)
                {
                    al_draw_pixel (Xakt, Yakt, al_map_rgb(255, 0, 255-(Resistenz)) );
                }


            Yakt++;
        }
        Yakt = 0;
        al_flip_display();

        Xakt++;
    }
    Xakt = 0;




/*
    while(Xakt < (BildgroesseX*3))
    {
        while(Yakt < (BildgroesseY*3))
        {
            Subpixel = 0;

            C.Realteil = xMin + ( ( (xMax - xMin) / (BildgroesseX*3) ) * ((Xakt*3)-1) );
            C.Imaginaerteil = yMin + ( ( (yMax - yMin) / (BildgroesseY*3) ) * ((Yakt*3)-1) );
            Subpixel += ResistenceCheck(MaxResis, C);

            C.Realteil = xMin + ( ( (xMax - xMin) / (BildgroesseX*3) ) * ((Xakt*3)-1) );
            C.Imaginaerteil = yMin + ( ( (yMax - yMin) / (BildgroesseY*3) ) * ((Yakt*3)) );
            Subpixel += ResistenceCheck(MaxResis, C);

            C.Realteil = xMin + ( ( (xMax - xMin) / (BildgroesseX*3) ) * ((Xakt*3)-1) );
            C.Imaginaerteil = yMin + ( ( (yMax - yMin) / (BildgroesseY*3) ) * ((Yakt*3)+1) );
            Subpixel += ResistenceCheck(MaxResis, C);



            C.Realteil = xMin + ( ( (xMax - xMin) / (BildgroesseX*3) ) * ((Xakt*3)) );
            C.Imaginaerteil = yMin + ( ( (yMax - yMin) / (BildgroesseY*3) ) * ((Yakt*3)-1) );
            Subpixel += ResistenceCheck(MaxResis, C);

            C.Realteil = xMin + ( ( (xMax - xMin) / (BildgroesseX*3) ) * ((Xakt*3)) );
            C.Imaginaerteil = yMin + ( ( (yMax - yMin) / (BildgroesseY*3) ) * ((Yakt*3)) );
            Subpixel += ResistenceCheck(MaxResis, C);

            C.Realteil = xMin + ( ( (xMax - xMin) / (BildgroesseX*3) ) * ((Xakt*3)) );
            C.Imaginaerteil = yMin + ( ( (yMax - yMin) / (BildgroesseY*3) ) * ((Yakt*3)+1) );
            Subpixel += ResistenceCheck(MaxResis, C);



            C.Realteil = xMin + ( ( (xMax - xMin) / (BildgroesseX*3) ) * ((Xakt*3)+1) );
            C.Imaginaerteil = yMin + ( ( (yMax - yMin) / (BildgroesseY*3) ) * ((Yakt*3)-1) );
            Subpixel += ResistenceCheck(MaxResis, C);

            C.Realteil = xMin + ( ( (xMax - xMin) / (BildgroesseX*3) ) * ((Xakt*3)+1) );
            C.Imaginaerteil = yMin + ( ( (yMax - yMin) / (BildgroesseY*3) ) * ((Yakt*3)) );
            Subpixel += ResistenceCheck(MaxResis, C);

            C.Realteil = xMin + ( ( (xMax - xMin) / (BildgroesseX*3) ) * ((Xakt*3)+1) );
            C.Imaginaerteil = yMin + ( ( (yMax - yMin) / (BildgroesseY*3) ) * ((Yakt*3)+1) );
            Subpixel += ResistenceCheck(MaxResis, C);

            Subpixel = Subpixel/9;

            if ( Subpixel >= MaxResis )
                {
                    al_draw_pixel (Xakt, Yakt, al_map_rgb(0, 0, 0) );
                }
            else if ( Subpixel <= 255)
                {
                    al_draw_pixel (Xakt, Yakt, al_map_rgb(255, (Subpixel%255), 0) );
                }
            else if ( Subpixel > 255 && Subpixel <= 511)
                {
                    al_draw_pixel (Xakt, Yakt, al_map_rgb(255-(Subpixel%255), 255, 0) );
                }
            else if ( Subpixel > 511 && Subpixel <= 767)
                {
                    al_draw_pixel (Xakt, Yakt, al_map_rgb(0, 255, (Subpixel%255)) );
                }
            else if ( Subpixel > 767 && Subpixel <= 1023)
                {
                    al_draw_pixel (Xakt, Yakt, al_map_rgb(0, 255-(Subpixel%255), 255) );
                }
            else if ( Subpixel > 1023 && Subpixel <= 1279)
                {
                    al_draw_pixel (Xakt, Yakt, al_map_rgb((Subpixel%255), 0, 255) );
                }
            else if ( Subpixel > 1279 && Subpixel <= 1535)
                {
                    al_draw_pixel (Xakt, Yakt, al_map_rgb(255, 0, 255-(Subpixel%255)) );
                }



            Yakt++;
        }
        Yakt = 0;
        al_flip_display();
        Xakt++;
    }
    Xakt = 0;

*/


    al_flip_display();

    al_rest(1000);


    return 0;
}


/*
    Z = C² + Z
    (aReal + aImagin)*(bReal + bImagin) = aReal*bReal + (aReal*bImagin) + (aImagin*bReal) + (aImagin*bImagin)
*/

void ComplexMul (sCompNmr A, sCompNmr B, sCompNmr *Ergebnis)
{
    Ergebnis->Realteil = (A.Realteil * B.Realteil) - (A.Imaginaerteil * B.Imaginaerteil);
    Ergebnis->Imaginaerteil = (A.Realteil * B.Imaginaerteil) + (A.Imaginaerteil * B.Realteil);
}

int ResistenceCheck (uint32_t Nmax, sCompNmr C)
{
    uint32_t N = 0;
    sCompNmr Z;
    sCompNmr Ergebnis;

    Z.Realteil = 0.0;
    Z.Imaginaerteil = 0.0;

    Ergebnis.Realteil = 0;
    Ergebnis.Imaginaerteil = 0;

    while ( ( (Z.Realteil * Z.Realteil) + (Z.Imaginaerteil * Z.Imaginaerteil) <= 4 ) & (N < Nmax) )  //Solange BetragZ kleiner 4 und nicht häufiger als Nmax durchgelaufen
    {
        ComplexMul (Z, Z, &Ergebnis);
        Z.Realteil = Ergebnis.Realteil + C.Realteil;
        Z.Imaginaerteil = Ergebnis.Imaginaerteil + C.Imaginaerteil;
        N++;
    }
    //printf("Resistenz von (%f + %f i) ist %d \n \n", C.Realteil, C.Imaginaerteil, N);
    return N;
}



int ResistenceCheck2 (uint32_t Nmax, sCompNmr C)
{
    uint32_t N = 0;
    sCompNmr Z;
    sCompNmr COri;
    sCompNmr Ergebnis;

    Z.Realteil = 0.707;
    Z.Imaginaerteil = -0.152;

    COri.Realteil = C.Realteil;
    COri.Imaginaerteil = C.Imaginaerteil;

    Ergebnis.Realteil = 0;
    Ergebnis.Imaginaerteil = 0;

    while ( ( (Z.Realteil * Z.Realteil) + (Z.Imaginaerteil * Z.Imaginaerteil) <= 4 ) & (N < Nmax) )  //Solange BetragZ kleiner 4 und nicht häufiger als Nmax durchgelaufen
    {
        ComplexMul (Z, Z, &Ergebnis);
        Z.Realteil = Ergebnis.Realteil + C.Realteil;
        Z.Imaginaerteil = Ergebnis.Imaginaerteil + C.Imaginaerteil;
        C.Imaginaerteil = Z.Imaginaerteil;
        C.Realteil = Z.Realteil;
        N++;
    }

    //printf("Resistenz2 von (%f + %f i) ist %d \n \n", COri.Realteil, COri.Imaginaerteil, N);
    return N;
}










/*
#include "allegro5/allegro.h"

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

#define SPIELFELDX 800
#define SPIELFELDY 600

#define HMaxAlter 5000

typedef struct
{
    unsigned Alter;
    unsigned Geschlecht;
    unsigned Nr;
    unsigned schwanger;

    double Atrak;
    double Geschw;
    double Grundstaerke;
    double Hunger;
    double PosX;
    double PosY;
    double Staerke;
}sHase;

typedef struct
{
    unsigned Alter;
    unsigned Geschlecht;
    unsigned Nr;
    unsigned schwanger;

    double Atrak;
    double Geschw;
    double Grundstaerke;
    double Hunger;
    double PosX;
    double PosY;
    double Staerke;
}sFuchs;

int HasenSaehen(sHase *HasenLst, unsigned HaseNr, unsigned *HasenCntPt, unsigned *HTotalCntPt, unsigned *NewReallocValPt);
int killHase(sHase *HasenLst, unsigned HaseNr,  unsigned *HasenCntPt, unsigned *NewReallocValPt);
void PrntHaseLst (sHase *aktHase, unsigned *HasenCntPt);

unsigned ReallRetryCnt = 0;

int main()
{
    sHase *HasenLst;
    sHase *aktHase;
    unsigned HasenCnt = 0;
    unsigned HTotalCnt = 0;
    unsigned i = 0;
    unsigned j = 0;
    unsigned z = 0;
    unsigned NewReallocVal = 10;

    HasenLst = (sHase*)calloc((HasenCnt+10),sizeof(sHase));
    if(NULL == HasenLst)
    {
        for(ReallRetryCnt = 0; ReallRetryCnt < 10; ReallRetryCnt++)
        {
            HasenLst = (sHase*)calloc((HasenCnt+10),sizeof(sHase));
        }
        printf("kein verbundenener Speicher verfuegbar 1\n");
        return EXIT_FAILURE;
    }

    srand(time(NULL));  //Zufallsgenerator initialisieren

    for (i = 0; i < 50; i++)
    {
        aktHase = &HasenLst[HasenCnt];
        HasenSaehen(HasenLst, i, &HasenCnt, &HTotalCnt, &NewReallocVal);
        printf("%u, %u, %f, %f,\n\n", aktHase->Nr, aktHase->Geschlecht, aktHase->Hunger, aktHase->Staerke);
    }

    aktHase = &HasenLst[0];
    PrntHaseLst(aktHase, &HasenCnt);

    j = rand()%HasenCnt;
    printf("\nes werden %u Hasen entfernt\n",j);
    for (i = 0; i < j; i++)
    {
        z = rand()%HasenCnt;
        printf("Hase Nr %u wurde entfernt\n", z);
        aktHase = &HasenLst[z];
        killHase(HasenLst, z, &HasenCnt, &NewReallocVal);
    }

    aktHase = &HasenLst[0];
    PrntHaseLst(aktHase, &HasenCnt);

    return 0;
}

int HasenSaehen(sHase *HasenLst, unsigned HaseNr, unsigned *HasenCntPt, unsigned *HTotalCntPt, unsigned *NewReallocValPt)
{
    sHase *aktHase = &HasenLst[HaseNr];

    aktHase->Alter          = rand()%HMaxAlter;
    aktHase->Atrak          = (rand()%1000000000)/10000.0;
    aktHase->Geschlecht     = rand()%2;
    aktHase->Geschw         = (rand()%1000000000)/10000.0;
    aktHase->Grundstaerke   = (rand()%1000000000)/10000.0;
    aktHase->Nr             = *HTotalCntPt;
    aktHase->Hunger         = (rand()%1000000000)/10000.0;
    aktHase->PosX           = (rand()%(SPIELFELDX*1000))/1000.0;
    aktHase->PosY           = (rand()%(SPIELFELDY*1000))/1000.0;
    aktHase->schwanger      = 0;
    aktHase->Staerke        = (rand()%1000000000)/10000.0;

    *HasenCntPt += 1;
    *HTotalCntPt += 1;

    if(*HasenCntPt >= *NewReallocValPt)
    {
        *NewReallocValPt += 10;
        HasenLst = (sHase*) realloc(HasenLst, *NewReallocValPt * sizeof(sHase));
        if(NULL == HasenLst)
        {
            for(ReallRetryCnt = 0; ReallRetryCnt < 10; ReallRetryCnt++)
            {
                HasenLst = (sHase*) realloc(HasenLst, *NewReallocValPt * sizeof(sHase));
                if(NULL != HasenLst)
                {
                    printf("Speicherplatz fuer 10 neue Hasen erschaffen\n");
                    break;
                }
                else
                {
                    printf("kein verbundenener Speicher verfuegbar 2\n");
                    return EXIT_FAILURE;
                }
            }

        }
        else
        {
            printf("Speicherplatz fuer 10 neue Hasen erschaffen\n");
        }
    }
    return 0;
}

int killHase(sHase *HasenLst, unsigned HaseNr,  unsigned *HasenCntPt, unsigned *NewReallocValPt)
{
    sHase *aktHase = &HasenLst[HaseNr];
    unsigned i;


    *HasenCntPt -= 1;
    for (i = HaseNr; i < *HasenCntPt; i++)
    {
        aktHase->Nr = (aktHase+1)->Nr;
        aktHase->Geschlecht = (aktHase+1)->Geschlecht;
        aktHase->Hunger = (aktHase+1)->Hunger;
        aktHase->Staerke = (aktHase+1)->Staerke;


        if (*HasenCntPt <= (*NewReallocValPt-20))
        {
            *NewReallocValPt -= 10;
            HasenLst = (sHase*) realloc(HasenLst, *NewReallocValPt * sizeof(sHase));
            if(NULL == HasenLst)
            {
                for(ReallRetryCnt = 0; ReallRetryCnt < 10; ReallRetryCnt++)
                {
                    HasenLst = (sHase*) realloc(HasenLst, *NewReallocValPt * sizeof(sHase));
                    if(NULL != HasenLst)
                    {
                        printf("Speicherplatz fuer 10 tote Hasen vernichtet\n");
                        break;
                    }
                    else
                    {
                        printf("kein verbundenener Speicher verfuegbar 2\n");
                        return EXIT_FAILURE;
                    }
                }
            }
            else
            {
                printf("Speicherplatz fuer 10 tote Hasen vernichtet\n");
            }
        }


        aktHase = aktHase + 1;
    }
    return 0;
}


//Hasenliste ausgeben
void PrntHaseLst (sHase *aktHase, unsigned *HasenCntPt)
{
    unsigned i;

    for (i = 0; i < *HasenCntPt; i++)
    {
        printf("Hase %u: %u, %u, %f, %f\n", i, aktHase->Nr, aktHase->Geschlecht, aktHase->Hunger, aktHase->Staerke);
        aktHase += 1;
    }
}
*/