#include "allegro5/allegro.h"
#include "GmOfFchsUndHs.h"

//#define Nur1Hase
//#define KeinGras

FILE *Weltdaten;
ALLEGRO_DISPLAY *display;                                   //Pointer aufs Display
sFeld SF[SpielfeldgroesseX][SpielfeldgroesseY];             //Das Spielfeld mit der Größe x*Y
sHase HList[SpielfeldgroesseX*SpielfeldgroesseY*2];         //Eine Liste für die Hasen
sFuchs FList[SpielfeldgroesseX*SpielfeldgroesseY*2];        //Eine Liste für die Füchse
unsigned HCnt = 0;                                          //Ein Zähler für die Hasen
unsigned FCnt = 0;                                          //Ein Zähler für die Füchse
unsigned Tick = 0;


int  main()
{
    Weltdaten = fopen("Weltdaten.CSV", "w");
    if (Weltdaten == NULL)
    {
    printf("Fehler beim Oeffnen der Datei.");
    return 1;
    }

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

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

    display = al_create_display(BildgroesseX, BildgroesseY);

    WeltInit();
    WeltMalen();

    while(HCnt >= 1 || FCnt >= 1)
    {
        WeltAendern();
        HasenAendern();
        FuchsAendern();
        //WeltMalen();
        printf("%u, %u, %u,\n", HCnt, FCnt, Tick);
        fprintf(Weltdaten, "%u, %u, %u,\n", HCnt, FCnt, Tick);
        Tick++;
    }
    fclose(Weltdaten);
    al_rest(1);



    return 0;
}


void killFuchs(unsigned FNr)
{
    while(FNr < FCnt)
    {
        FList[FNr] = FList[FNr+1];
        FNr++;
    }
    FCnt--;
}

void killHase(unsigned HNr)
{
    while(HNr < HCnt)
    {
        HList[HNr] = HList[HNr+1];
        HNr++;
    }
    HCnt--;
}

void WeltAendern()
{
    unsigned x = 0;
    unsigned y = 0;

    while(x < SpielfeldgroesseX)
    {
        while(y < SpielfeldgroesseY)
        {
            if(SF[x][y].ZSA>9 && SF[x][y].ZSA%Graswuchsrythmus == 0)
            {
                SF[x][y].GH++;
                if(SF[x][y].GH >= 10)
                {
                    SF[x][y].GH = 10;
                }
            }
            SF[x][y].ZSA++;
            y++;
        }
        y = 0;
        x++;
    }
    x = 0;
}

void FuchsAendern()
{
    unsigned i = 0;
    unsigned j = 0;

    while(i < FCnt)
    {
        FList[i].Alter++;

        if(FList[i].Alter >= FMaxAlter)
        {
            killFuchs(i);
        }
        if(FList[i].Staerke == 0)
        {
            killFuchs(i);
        }
        else
        {
            if(FList[i].Geschlecht == 0 && FList[i].Staerke >= 4 && FList[i].Hunger <= 6)   //Nach Paarungspartner umsehen,
            {
                while(j < FCnt)
                {
                    if(FList[j].Geschlecht == 1 && FList[j].schwanger == 0 && sqrt(  ( (FList[j].PosX - FList[i].PosX)*(FList[j].PosX - FList[i].PosX) )+( (FList[j].PosY - FList[i].PosY)*(FList[j].PosY - FList[i].PosY) )  ) <= PaarungsweiteFuchs)
                    {
                        FList[i].PosX = FList[j].PosX;
                        FList[i].PosY = FList[j].PosX;
                        FList[j].schwanger = Tick;
                    }
                    j++;
                }
                j = 0;
            }

            if(Tick - FList[i].schwanger >= TragzeitF && FList[i].schwanger != 0)        //Nach100Ticks kommt der Nachwuchs
            {
                FList[i].schwanger = 0;
                FCnt++;
                FList[FCnt].Alter = 0;
                FList[FCnt].Geschlecht = rand()%2;
                FList[FCnt].Hunger = rand()%10;
                FList[FCnt].Mut = rand()%10;
                FList[FCnt].PosX = HList[i].PosX;
                FList[FCnt].PosY = HList[i].PosY;
                FList[FCnt].schwanger = 0;
                FList[FCnt].Staerke = rand()%10;
                FList[FCnt].ZoF = 0;
            }


            if(FList[i].Hunger >= 8)
            {
                while(j < HCnt)
                {
                    if(sqrt(  ( (HList[j].PosX - FList[i].PosX)*(HList[j].PosX - FList[i].PosX) ) + ( (HList[j].PosY - FList[i].PosY)*(HList[j].PosY - FList[i].PosY) ) ) <= SichtweiteFuchs)
                    {                                   //Falls Hasenposition - Fuchsposition innerhalb des Jagdradius (Pythagoras)
                        FList[i].PosX = HList[j].PosX;
                        FList[i].PosY = HList[j].PosY;
                        if(rand()%100 <= Jagdglueck)
                        {
                            FList[i].Staerke += HList[j].Staerke;
                            FList[i].Hunger = 0;
                            killHase(j);
                        }
                        else
                        {
                            HList[j].PosX = rand()%SpielfeldgroesseX;
                            HList[j].PosY = rand()%SpielfeldgroesseY;
                        }
                        j = HCnt;
                    }
                    j++;
                }
                j = 0;
            }


            FList[i].Hunger++;

            if(FList[i].Hunger >= 10)
            {
                FList[i].Hunger = 10;
                FList[i].PosX = (   FList[i].PosX + ( (unsigned)(rand()%10 - 5) )   )%SpielfeldgroesseX;
                FList[i].PosY = (   FList[i].PosY + ( (unsigned)(rand()%10 - 5) )   )%SpielfeldgroesseY;
                FList[i].Staerke--;
            }
        }
        i++;
    }
}

void FPPS(sFuchs *Fuchs)
{
    unsigned j = 0;

    if(Fuchs->Geschlecht == 0 && Fuchs->Staerke >= 6 && Fuchs->Hunger <= 6)   //Nach Paarungspartner umsehen,
        {
            while(j < FCnt)
            {
                if(FList[j].Geschlecht == 1 && FList[j].schwanger == 0 && sqrt(  ( (FList[j].PosX - Fuchs->PosX)*(FList[j].PosX - Fuchs->PosX) )+( (FList[j].PosY - Fuchs->PosY)*(FList[j].PosY - Fuchs->PosY) )  ) <= PaarungsweiteFuchs)
                {
                    Fuchs->PosX = FList[j].PosX;
                    Fuchs->PosY = FList[j].PosX;
                    FList[j].schwanger = Tick;
                }
                j++;
            }
            j = 0;
        }
}


void HasenAendern()
{
    signed xShift = -SichtweiteHase;
    signed yShift = -SichtweiteHase;
    signed subx = 0;
    signed suby = 0;
    unsigned i = 0;
    unsigned j = 0;
    unsigned x = 0;
    unsigned y = 0;
    unsigned BestFeld[3] = {0, 0, 0};

    while(i < HCnt)
    {
        x = HList[i].PosX;
        y = HList[i].PosY;
        HList[i].Alter++;

        if(HList[i].Alter >= HMaxAlter)
        {
            killHase(i);
        }
        if(HList[i].Staerke == 0)
        {
            killHase(i);
        }
        else
        {
        if(HList[i].Geschlecht == 0)
            {
                if(HList[i].Staerke == 10 && HList[i].Hunger <= 3)      //Nach Paarungspartner umsehen
                {
                    while(j < HCnt)
                    {
                        if(HList[j].Geschlecht == 1 && HList[j].schwanger == 0 && sqrt(  ( (HList[j].PosX - HList[i].PosX)*(HList[j].PosX - HList[i].PosX) )+( (HList[j].PosY - HList[i].PosY)*(HList[j].PosY - HList[i].PosY) )  ) <= PaarungsweiteHase)
                        {
                            HList[j].schwanger = Tick;
                        }
                        j++;
                    }
                    j = 0;
                }
            }

            if(Tick - HList[i].schwanger == TragzeitH && HList[i].schwanger != 0)        //Nach100Ticks kommt der Nachwuchs
            {
                HList[i].schwanger = 0;
                HCnt++;
                HList[HCnt].Alter = 0;
                HList[HCnt].Geschlecht = rand()%2;
                HList[HCnt].Hunger = rand()%10;
                HList[HCnt].Mut = rand()%10;
                HList[HCnt].PosX = HList[i].PosX;
                HList[HCnt].PosY = HList[i].PosY;
                HList[HCnt].schwanger = 0;
                HList[HCnt].Staerke = rand()%10;
                HList[HCnt].ZoF = 0;
            }


            if(SF[x][y].GH > 0)              //Wenn Gras da ist, fressen,
            {
                SF[x][y].GH--;
                SF[x][y].ZSA = 0;
                if(HList[i].Hunger > 0)
                {
                    HList[i].Hunger--;
                }
                HList[i].ZoF = 0;

                if(HList[i].Hunger == 0)            //Wenn kein Hunger mehr, Stärke erhöhen
                {
                    HList[i].Staerke++;
                    if(HList[i].Staerke >= 10)
                    {
                        HList[i].Staerke = 10;
                    }
                }
            }
            else
            {
                if(HList[i].Staerke >= 1)           //Solange nicht verhungert
                {

                    HList[i].ZoF++;
                    if(HList[i].ZoF >= 10)
                    {
                        HList[i].Hunger++;
                        if(HList[i].Hunger >= 10)
                        {
                            HList[i].Hunger = 10;
                            HList[i].Staerke--;
                        }
                    }
                    //HList[i].PosX = rand()%SpielfeldgroesseX;
                    //HList[i].PosY = rand()%SpielfeldgroesseY;

                    while(xShift < SichtweiteHase)                  //Nach besserem Feld umsehen
                    {
                        while(yShift < SichtweiteHase)
                        {
                            subx = (x + xShift)%SpielfeldgroesseX;
                            suby = (y + yShift)%SpielfeldgroesseY;
                            if(SF[subx][suby].GH > BestFeld[2])
                            {
                                BestFeld[0] = subx;
                                BestFeld[1] = suby;
                                BestFeld[2] = SF[subx][suby].GH;
                            }
                            yShift++;
                        }
                        yShift = 0;
                        xShift++;
                    }
                    xShift = 0;
                    if(BestFeld[2] >= 1)                    //Wenn Feld mit mehr Gras im Sichtradius gefunden, hingehen
                    {
                        HList[i].PosX = BestFeld[0];
                        HList[i].PosY = BestFeld[1];
                    }
                    else
                    {
                        HList[i].PosX = rand()%SpielfeldgroesseX;       //wenn nicht, auf zufälliges Feld gehen
                        HList[i].PosY = rand()%SpielfeldgroesseY;
                    }
                    BestFeld[0] = 0;
                    BestFeld[1] = 0;
                    BestFeld[2] = 0;
                }
            }
        }
        i++;
    }
    i = 0;
    x = 0;
    y = 0;
}


void WeltMalen()
{
    unsigned i = 0;
    unsigned x = 0;
    unsigned y = 0;
    unsigned subx = 0;
    unsigned suby = 0;

    while(x < SpielfeldgroesseX)
    {
        while(y < SpielfeldgroesseY)
        {
            while(subx < FeldgroesseX)
            {
                while(suby < FeldgroesseY)
                {
                    al_draw_pixel( (x*FeldgroesseX)+subx, (y*FeldgroesseY)+suby, al_map_rgb(0, SF[x][y].GH*25, 0));
                    suby++;
                }
                suby = 0;
                subx++;
            }
            subx = 0;
            y++;
        }
        y = 0;
        x++;
    }
    x = 0;

    while(i < HCnt)
    {
        while(subx < FeldgroesseX/2)
        {
            while(suby < FeldgroesseY/2)
            {
                al_draw_pixel( (HList[i].PosX*FeldgroesseX)+subx, (HList[i].PosY*FeldgroesseY)+suby, al_map_rgb(0, 0, (HList[i].Staerke*25)));
                suby++;
            }
            suby = 0;
            subx++;
        }
        subx = 0;
        i++;
    }
    i = 0;

    while(i < FCnt)
    {
        while(subx < FeldgroesseX/2)
        {
            while(suby < FeldgroesseY/2)
            {
                al_draw_pixel( (FList[i].PosX*FeldgroesseX)+(FeldgroesseX/2)+subx, (FList[i].PosY*FeldgroesseY)+(FeldgroesseY/2)+suby, al_map_rgb((FList[i].Staerke*25), 0, 0));
                suby++;
            }
            suby = 0;
            subx++;
        }
        subx = 0;
        i++;
    }
    i = 0;


    while(x < SpielfeldgroesseX)
    {
         while(y < BildgroesseY)
        {
            al_draw_pixel((x*FeldgroesseX), y, al_map_rgb(127, 127, 127));
            y++;
        }
        y = 0;
        x++;
    }
    x = 0;


    while(y < SpielfeldgroesseY)
    {
         while(x < BildgroesseX)
        {
            al_draw_pixel(x, (y*FeldgroesseY), al_map_rgb(127, 127, 127));
            x++;
        }
        x = 0;
        y++;
    }
    y = 0;


    al_flip_display();
}


void WeltInit()
{
    unsigned x = 0;
    unsigned y = 0;
    unsigned i = 0;

    while(x < SpielfeldgroesseX)
    {
        while(y < SpielfeldgroesseY)
        {
            #ifdef KeinGras
            SF[x][y].GH = 0;
            SF[x][y].ZSA = 0;
            #endif // KeinGras

            #ifndef KeinGras
            SF[x][y].GH = rand()%10;                 //Grashöhe zufällig zwischen 0 und 9 setzen
            if(SF[x][y].GH == 0)                     //Falls kein Gras gewachsen,
            {
                SF[x][y].ZSA = rand()%10;   //bestimmen, wie lange das Feld schon ohne Gras ist
            }
            #endif // KeinGras


            #ifdef Nur1Hase
            if(HCnt < HLim)
            {
            #endif // Nur1Hase
                if(rand()%100 < 9)                              //1%Chance auf einen Hasen auf dem Feld
                {
                    HList[HCnt].Geschlecht = rand()%2;
                    if(HList[HCnt].Geschlecht == 1)             //Falls Weibchen eine 1Promille-Chance würfeln, ob trächtig
                    {
                        if(rand()%1000 < 1)
                        {
                            HList[HCnt].schwanger = Tick;       //Zeitpunkt merken, wann trächtig geworden
                        }
                    }

                    HList[HCnt].Hunger = rand()%10;             //Hunger bestimmt Risikobereitschaft vom Hasen

                    HList[HCnt].Mut = rand()%10;                //Wird vom Hunger beeinflusst,

                    HList[HCnt].PosX = x;
                    HList[HCnt].PosY = y;

                    HList[HCnt].Staerke = rand()%10;

                    HList[HCnt].Alter = rand()%HMaxAlter;

                    HCnt++;
                }
            #ifdef Nur1Hase
            }
            #endif // Nur1Hase

            if(rand()%1000 < 5)                              //1%Chance auf einen Fuchs auf dem Feld
            {
                FList[FCnt].Geschlecht = rand()%2;
                if(FList[FCnt].Geschlecht == 1)             //Falls Weibchen eine 1Promille-Chance würfeln, ob trächtig
                {
                    if(rand()%1000 < 1)
                    {
                        FList[FCnt].schwanger = Tick;       //Zeitpunkt merken, wann trächtig geworden
                    }
                }

                FList[FCnt].Hunger = rand()%10;             //Hunger bestimmt Risikobereitschaft vom Fuchs

                FList[FCnt].Mut = rand()%10;                //Wird vom Hunger beeinflusst,

                FList[FCnt].PosX = x;
                FList[FCnt].PosY = y;

                FList[FCnt].Staerke = rand()%10;

                FList[FCnt].Alter = rand()%FMaxAlter;

                FCnt++;
            }



            y++;
        }
        y = 0;
        x++;
    }


    while(i < HCnt)
    {
        printf("Hase Nr:%u ist ", i);
        if(HList[i].Geschlecht == 1)
        {
            printf("weiblich ");
        }
        else
        {
            printf("männlich ");
        }
        printf("und auf Feld X: %u Y: %u\n\n", HList[i].PosX, HList[i].PosY);
        i++;
    }
    i = 0;

        while(i < FCnt)
    {
        printf("Fuchs Nr:%u ist ", i);
        if(FList[i].Geschlecht == 1)
        {
            printf("weiblich ");
        }
        else
        {
            printf("männlich ");
        }
        printf("und auf Feld X: %u Y: %u\n\n", FList[i].PosX, FList[i].PosY);
        i++;
    }
    i = 0;
}