#include "Tiger_class.h"
#include <math.h>
#include <time.h>

int norm_pente(float);
int norm_pluie(int);
int sens_pente(float);
int normalisation(int);
BOOL IO_boucle();

ULONG noir=0;
ULONG blanc=0;
ULONG gris1=0;
ULONG gris2=0;
ULONG gris3=0;
ULONG gris4=0;
ULONG gris5=0;
ULONG gris6=0;
ULONG gris7=0;
ULONG gris8=0;
ULONG gris9=0;
ULONG gris10=0;
ULONG gris11=0;
ULONG gris12=0;
ULONG gris13=0;
ULONG gris14=0;

struct Window *win=NULL;
struct RastPort *winport=NULL;
struct RastPort winport_noir;
struct RastPort winport_blanc;
struct RastPort winport_gris1;
struct RastPort winport_gris2;
struct RastPort winport_gris3;
struct RastPort winport_gris4;
struct RastPort winport_gris5;
struct RastPort winport_gris6;
struct RastPort winport_gris7;
struct RastPort winport_gris8;
struct RastPort winport_gris9;
struct RastPort winport_gris10;
struct RastPort winport_gris11;
struct RastPort winport_gris12;
struct RastPort winport_gris13;
struct RastPort winport_gris14;
struct IntuiMessage *msg;

Object *winobj=NULL;

void Startup(void)
{
    pente=0.4;
    pluie=450;
    termite=0;
    rayon=0;
    imax=40;
    jmax=40;
    zoom=1;
    SetGadgetAttrs(Integer2, Window1, NULL, GA_Disabled, TRUE, TAG_DONE);
    SetGadgetAttrs(Integer3, Window1, NULL, GA_Disabled, TRUE, TAG_DONE);
    noir = ObtainBestPen(Screen1->ViewPort.ColorMap, 0x0FFFFFFF, 0x0FFFFFFF, 0x0FFFFFFF, OBP_Precision, PRECISION_EXACT, TAG_DONE);
    blanc = ObtainBestPen(Screen1->ViewPort.ColorMap, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, OBP_Precision, PRECISION_EXACT, TAG_DONE);
    gris1 = ObtainBestPen(Screen1->ViewPort.ColorMap, 0xeFFFFFFF, 0xeFFFFFFF, 0xeFFFFFFF, OBP_Precision, PRECISION_EXACT, TAG_DONE);
    gris2 = ObtainBestPen(Screen1->ViewPort.ColorMap, 0xdfffffff, 0xdfffffff, 0xdfffffff, OBP_Precision, PRECISION_EXACT, TAG_DONE);
    gris3 = ObtainBestPen(Screen1->ViewPort.ColorMap, 0xcfffffff, 0xcfffffff, 0xcfffffff, OBP_Precision, PRECISION_EXACT, TAG_DONE);
    gris4 = ObtainBestPen(Screen1->ViewPort.ColorMap, 0xbfffffff, 0xbfffffff, 0xbfffffff, OBP_Precision, PRECISION_EXACT, TAG_DONE);
    gris5 = ObtainBestPen(Screen1->ViewPort.ColorMap, 0xafffffff, 0xafffffff, 0xafffffff, OBP_Precision, PRECISION_EXACT, TAG_DONE);
    gris6 = ObtainBestPen(Screen1->ViewPort.ColorMap, 0x9fffffff, 0x9fffffff, 0x9fffffff, OBP_Precision, PRECISION_EXACT, TAG_DONE);
    gris7 = ObtainBestPen(Screen1->ViewPort.ColorMap, 0x8fffffff, 0x8fffffff, 0x8fffffff, OBP_Precision, PRECISION_EXACT, TAG_DONE);
    gris8 = ObtainBestPen(Screen1->ViewPort.ColorMap, 0x7fffffff, 0x7fffffff, 0x7fffffff, OBP_Precision, PRECISION_EXACT, TAG_DONE);
    gris9 = ObtainBestPen(Screen1->ViewPort.ColorMap, 0x6fffffff, 0x6fffffff, 0x6fffffff, OBP_Precision, PRECISION_EXACT, TAG_DONE);
    gris10 = ObtainBestPen(Screen1->ViewPort.ColorMap, 0x5fffffff, 0x5fffffff, 0x5fffffff, OBP_Precision, PRECISION_EXACT, TAG_DONE);
    gris11 = ObtainBestPen(Screen1->ViewPort.ColorMap, 0x4fffffff, 0x4fffffff, 0x4fffffff, OBP_Precision, PRECISION_EXACT, TAG_DONE);
    gris12 = ObtainBestPen(Screen1->ViewPort.ColorMap, 0x3fffffff, 0x3fffffff, 0x3fffffff, OBP_Precision, PRECISION_EXACT, TAG_DONE);
    gris13 = ObtainBestPen(Screen1->ViewPort.ColorMap, 0x2fffffff, 0x2fffffff, 0x2fffffff, OBP_Precision, PRECISION_EXACT, TAG_DONE);
    gris14 = ObtainBestPen(Screen1->ViewPort.ColorMap, 0x1fffffff, 0x1fffffff, 0x1fffffff, OBP_Precision, PRECISION_EXACT, TAG_DONE);
    /*printf("%d ", blanc);
    printf("%d ", gris1);
    printf("%d ", gris2);
    printf("%d ", gris3);
    printf("%d ", gris4);
    printf("%d ", gris5);
    printf("%d ", gris6);
    printf("%d ", gris7);
    printf("%d ", gris8);
    printf("%d ", gris9);
    printf("%d ", gris10);
    printf("%d ", gris11);
    printf("%d ", gris12);
    printf("%d ", gris13);
    printf("%d ", gris14);
    printf("%d ", noir);
    //UBYTE couleur [3] = { blanc, blanc, noir };
    UBYTE couleur[17] = { blanc, blanc, gris1, gris2, gris3, gris4, gris5, gris6, gris7, gris8, gris9, gris10, gris11, gris12, gris13, gris14, noir };
    for(int c=0; c<=15; c++)
    {
        printf("%d ", couleur[c]);
    }*/
    //SetGadgetAttrs(Palette1, Window1, NULL, PALETTE_ColourTable, couleur, TAG_DONE);
}

void Window1_CloseWindow_Event(void)
{
    Emperor_QuitProgram();
}

void String1_GadgetUp_Event(void)
{
    pente = atof(Emperor_GetGadgetAttr(String1));
    if (pente<0.1 || pente >1.5)
    {
        Emperor_SetGadgetAttr(String1, "0.0");
        pente=0.0;
    }
}

void Integer1_GadgetUp_Event(void)
{
    pluie = atoi(Emperor_GetGadgetAttr(Integer1));
}

void Integer2_GadgetUp_Event(void)
{
    termite = atoi(Emperor_GetGadgetAttr(Integer2));
}

void Integer3_GadgetUp_Event(void)
{
    rayon = atoi(Emperor_GetGadgetAttr(Integer3));
}

void Integer4_GadgetUp_Event(void)
{
    imax = atoi(Emperor_GetGadgetAttr(Integer4));
}

void Integer5_GadgetUp_Event(void)
{
    jmax = atoi(Emperor_GetGadgetAttr(Integer5));
}

void Slider1_GadgetUp_Event(void)
{
    STRPTR temp=0;
    temp=Emperor_GetGadgetAttr(Slider1);
    Emperor_SetGadgetAttr(String3, temp);
    zoom=stringtoint(temp)
}

void Button1_GadgetUp_Event(void)
{
    pente=0.4;
    pluie=450;
    imax=40;
    jmax=40;
    zoom=1;
    Emperor_SetGadgetAttr(String1, "0.4");
    SetGadgetAttrs(Integer1, Window1, NULL, INTEGER_Number, 450, TAG_DONE);
    SetGadgetAttrs(Integer4, Window1, NULL, INTEGER_Number, 40, TAG_DONE);
    SetGadgetAttrs(Integer5, Window1, NULL, INTEGER_Number, 40, TAG_DONE);
    SetGadgetAttrs(Slider1, Window1, NULL, SLIDER_Level, 1, TAG_DONE);
}

void Button2_GadgetUp_Event(void)
{
    int ligne1=0, ligne2=0, ligne3=0, ligne4=0, ligne5=0, ligne6=0, ligne7=0,
    ligne8=0, ligne9=0, ligne10=0, ligne11=0, ligne12=0, ligne13=0,
    ligne14=0, ligne15=0, ligne16=0, ligne17=0, ligne18=0, ligne19=0,
    ligne20=0, ligne21=0, ligne22=0, ligne23=0, ligne24=0, i=0, j=0, k=0, l=0,
    rayon_max=0, random=0, valeur_max=0, resolution=0, a=0, b=0, kk=0, max_tick=0,
    temp=0, combien=0, memoire=0, loop_tick=0, temp_tick=0;
    float nelevation=0.0, hauteur=0.0, temp_float=0.0;
    STRPTR tick=0;
    BOOL fermer=FALSE, interrupt=FALSE;
    //FILE *fz;

    valeur_max=15;
    hauteur=5.0;
    resolution=2;
    kmax=3;

    Tableau <Cellule> C(imax, jmax, kmax+1);
    memoire=sizeof(C);
    memoire=memoire*imax*jmax*kmax;
    //printf("mémoire= %d"\n, memoire);

    winobj = (Object*) WindowObject,
            WA_Left,    100,
            WA_Top,     100,
            WA_Width,   (imax*zoom)+40,
            WA_Height,  (jmax*zoom)+40,
            WA_DragBar, TRUE,
            //WA_Title,   "Sortie graphique",
            WA_PubScreen, Screen1,
            //WA_CloseGadget,  TRUE,
            WA_DepthGadget, TRUE,
            //WA_SmartRefresh, TRUE,
            WA_SuperBitMap, TRUE,
            WA_IDCMP,  IDCMP_GADGETDOWN | IDCMP_GADGETUP | IDCMP_GADGETHELP | IDCMP_MENUPICK | IDCMP_MENUHELP | IDCMP_CLOSEWINDOW | IDCMP_ACTIVEWINDOW | IDCMP_INACTIVEWINDOW | IDCMP_RAWKEY | IDCMP_VANILLAKEY | IDCMP_MOUSEBUTTONS | IDCMP_MOUSEMOVE | IDCMP_NEWSIZE | IDCMP_CHANGEWINDOW | IDCMP_SIZEVERIFY | IDCMP_REFRESHWINDOW | IDCMP_INTUITICKS,
            WA_RMBTrap, TRUE,
    EndWindow;

    win = RA_OpenWindow (winobj);
    winport = win->RPort;
    winport_noir = *win->RPort;
    winport_blanc = *win->RPort;
    winport_gris1 = *win->RPort;
    winport_gris2 = *win->RPort;
    winport_gris3 = *win->RPort;
    winport_gris4 = *win->RPort;
    winport_gris5 = *win->RPort;
    winport_gris6 = *win->RPort;
    winport_gris7 = *win->RPort;
    winport_gris8 = *win->RPort;
    winport_gris9 = *win->RPort;
    winport_gris10 = *win->RPort;
    winport_gris11 = *win->RPort;
    winport_gris12 = *win->RPort;
    winport_gris13 = *win->RPort;
    winport_gris14 = *win->RPort;
    SetAPen( &winport_noir, noir );
    SetAPen( &winport_blanc, blanc );
    SetAPen( &winport_gris1, gris1 );
    SetAPen( &winport_gris2, gris2 );
    SetAPen( &winport_gris3, gris3 );
    SetAPen( &winport_gris4, gris4 );
    SetAPen( &winport_gris5, gris5 );
    SetAPen( &winport_gris6, gris6 );
    SetAPen( &winport_gris7, gris7 );
    SetAPen( &winport_gris8, gris8 );
    SetAPen( &winport_gris9, gris9 );
    SetAPen( &winport_gris10, gris10 );
    SetAPen( &winport_gris11, gris11 );
    SetAPen( &winport_gris12, gris12 );
    SetAPen( &winport_gris13, gris13 );
    SetAPen( &winport_gris14, gris14 );

/*appel au constructeur*/

    for(k=0; k<=kmax; k++)
    {
        for(j=0; j<jmax; j++)
        {
            for(i=0; i<imax; i++)
            {
                C(i,j,k);
            }
        }
    }

/*remplissage aléatoire de la génération 0*/

    srand((unsigned) time(NULL));
    for(j=0; j<jmax; j++)
    {
        for(i=0; i<imax; i++)
        {
            random=rand()%valeur_max;
            C(i,j,0).set_valeur(random);
        }
    }

/*termitisation et élévation*/

    /*rayon_max=(int)rayon;
    for(int t=0; t<termite; t++)
    {
        temp=0, kk=0;;
        temp=imax-(2*rayon_max);              //prendre les coordonnées i et j
        random=rand()%temp;                   //aléatoirement pour chaque termitière
        i=random+rayon_max;
        temp=jmax-(2*rayon_max);
        random=rand()%temp;
        j=random+rayon_max;
        random=rand()%kmax;
        for(k=random; k<=kmax; k++)                           //termitière apparaît à un moment k aléatoire
        {                                                     //mais ne dépasse pas la limite kmax
            if(k!=random && (k%10)==0 && kk<rayon_max)        //tous les 10 ans le rayon augmente jusquà concurrence du rayon max
            {                                                 //
                kk++;
            }
            C(i,j,k).set_termite(TRUE);                          //activer le bit termite
            C(i,j,k).set_elevation((hauteur*(rayon_max-rayon))/    //elevation dépend du rayon
            (3*resolution));                                       //et de la resolution
            C(i,j,k).set_age_termite(k-random);                          //l'âge...
            C(i,j,k).set_Crayon(kk);
            rayon=C(i,j,k).retour_Crayon();
            if(rayon>0 && kk<=rayon_max)                        //balaie les environs
            {
                for(b=j-(int)rayon; b<=j+(int)rayon; b++)       //de j
                {
                    for(a=i-(int)rayon; a<=i+(int)rayon; a++)   //et de i
                    {
                        C(a,b,k).set_influence(TRUE);              //dans ces environs, activer l'influence
                        int temp1=a-i;
                        int temp2=b-j;
                        if(temp1>0)
                            temp1=temp1*(-1);
                        if(temp2>0)
                            temp2=temp2*(-1);
                        float temp3=temp1+temp2+(2*(int)rayon);
                        if(temp3==0)
                            temp3=1;
                        nelevation=(temp3);                      //on dirait que ça ne sert a rien?
                        if(a!=i || b!=j)                         //la nouvelle élévation dépend de
                        {                                        //l'éloignement, de la résolution et de la hauteur d'origine
                            C(a,b,k).set_elevation((hauteur*(rayon_max-rayon))/(5*resolution));
                        }
                    }
                }
            }
            if(kk==rayon_max)
            {
                C(i,j,k).set_termite(FALSE);
            }
        }
    }*/

/*calcul des pentes et MNA*/

    for(k=0; k<=kmax; k++)
    {
        for(j=0; j<jmax; j++)
        {
            for(i=0; i<imax; i++)
            {
                C(i,j,k).set_pente(pente);
                C(i,j,k).set_altitude(j, resolution);
                if(C(i,j,k).retour_influence()==1)
                {
                    temp_float=0.0;
                    temp_float=C(i,j,k).retour_altitude()-C(i,j-1,k)
                    .retour_altitude();
                    C(i,j,k).set_pente(temp_float);
                }
                if(C(i,j-1,k).retour_influence()==TRUE &&
                C(i,j,k).retour_influence()==FALSE)
                {
                    temp_float=0.0;
                    temp_float=C(i,j,k).retour_altitude()-
                    C(i,j-1,k).retour_altitude();
                    C(i,j,k).set_pente(temp_float);
                }
            }
        }
    }
    /*if(choix=="o")
    {
        int choix_gen[101]={0}, buffer=0;
        char *MNA=0;
        float minimum=0.0, maximum=0.0, difference=0.0;
        minimum=10000.0;                           //sinon minimum reste à 0
        for(k=0; k<=kmax; k++)
        {
            for(j=0; j<jmax; j++)
            {
                for(i=0; i<imax; i++)
                {
                    temp_float=C(i,j,k).retour_altitude();
                    if(temp_float>maximum)
                        maximum=temp_float;
                    if(temp_float<minimum)
                        minimum=temp_float;
                }
            }
        }
        difference=maximum-minimum;

        for(i=0; i<=kmax; i++)
        {
            choix_gen[i]=i;
        }
        for(l=0; l<kmax; l++)
        {
            k=choix_gen[l];
            MNA=new char[10];
            strcpy(MNA, pioche_MNA(k));
            fz = fopen(MNA, "w");
            fputs ("P2\n", fz);
            fputs ("# ", fz);
            fputs(MNA, fz);
            fputs ("  \n", fz);
            fputs (inttostring(imax), fz);
            fputs ("  ", fz);
            fputs (inttostring(jmax), fz);
            fputs ("  \n255\n", fz);
            for(j=0; j<jmax; j++)
            {
                for(i=0; i<imax; i++)
                {
                    fputs(inttostring(int(((C(i,j,k).retour_altitude()-minimum)/difference)*255)), fz);
                    fputs("  ", fz);
                }
                fputs(" \n", fz);
            }
            delete [] MNA;
            fclose(fz);
        }
    }*/

/*début de la fonction de transition*/

    if(kmax!=0)
    {
        int n=0, jj=0, ii=0, concave=0, convexe=0, concave_max=0,
        convexe_max=0, montant=0, montant_max=0, descendant=0,
        descendant_max=0, concavexite=0, modification=0, somme1=0,
        nvaleur=0, generation=0;
        max_tick=200;
        ligne1=ligne2=ligne3=ligne4=ligne5=ligne6=ligne7=
        ligne8=ligne9=ligne10=ligne11=ligne12=ligne13=
        ligne14=ligne15=-1;
        ligne16=ligne17=ligne18=ligne19=ligne20=ligne21=
        ligne22=ligne23=ligne24=1;

        for(k=0; k<kmax; k++)
        {
            k=0;
            for(j=0; j<jmax; j++)
            {
                for(i=0;i<imax; i++)
                {
                    if(concave!=0 || convexe!=0 || concavexite!=0 || montant!=0 || descendant!=0)
                    {
                        concave=convexe=concavexite=montant=descendant=0;
                    }
                    //modification=norm_pente(pente);
                    if(j==0)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            for(n=0; n<=14; n++)
                            {
                                C(ii,(j-1)-n,k).set_altitude(C(ii,j-n,k)
                                .retour_altitude()+(pente/resolution));
                            }
                        }
                    }
                    if(j==1)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            for(n=0; n<=13; n++)
                            {
                                C(ii,(j-2)-n,k).set_altitude(C(ii,(j-1)-n,k)
                                .retour_altitude()+(pente/resolution));
                            }
                        }
                    }
                    if(j==2)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            for(n=0; n<=12; n++)
                            {
                                C(ii,(j-3)-n,k).set_altitude(C(ii,(j-2)-n,k)
                                .retour_altitude()+(pente/resolution));
                            }
                        }
                    }
                    if(j==3)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            for(n=0; n<=11; n++)
                            {
                                C(ii,(j-4)-n,k).set_altitude(C(ii,(j-3)-n,k)
                                .retour_altitude()+(pente/resolution));
                            }
                        }
                    }
                    if(j==4)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            for(n=0; n<=10; n++)
                            {
                                C(ii,(j-5)-n,k).set_altitude(C(ii,(j-4)-n,k)
                                .retour_altitude()+(pente/resolution));
                            }
                        }
                    }
                    if(j==5)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            for(n=0; n<=9; n++)
                            {
                                C(ii,(j-6)-n,k).set_altitude(C(ii,(j-5)-n,k)
                                .retour_altitude()+(pente/resolution));
                            }
                        }
                    }
                    if(j==6)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            for(n=0; n<=8; n++)
                            {
                                C(ii,(j-7)-n,k).set_altitude(C(ii,(j-6)-n,k)
                                .retour_altitude()+(pente/resolution));
                            }
                        }
                    }
                    if(j==7)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            for(n=0; n<=7; n++)
                            {
                                C(ii,(j-8)-n,k).set_altitude(C(ii,(j-7)-n,k)
                                .retour_altitude()+(pente/resolution));
                            }
                        }
                    }
                    if(j==8)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            for(n=0; n<=6; n++)
                            {
                                C(ii,(j-9)-n,k).set_altitude(C(ii,(j-8)-n,k)
                                .retour_altitude()+(pente/resolution));
                            }
                        }
                    }
                    if(j==9)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            for(n=0; n<=5; n++)
                            {
                                C(ii,(j-10)-n,k).set_altitude(C(ii,(j-9)-n,k)
                                .retour_altitude()+(pente/resolution));
                            }
                        }
                    }
                    if(j==10)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            for(n=0; n<=4; n++)
                            {
                                C(ii,(j-11)-n,k).set_altitude(C(ii,(j-10)-n,k)
                                .retour_altitude()+(pente/resolution));
                            }
                        }
                    }
                    if(j==11)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            for(n=0; n<=3; n++)
                            {
                                C(ii,(j-12)-n,k).set_altitude(C(ii,(j-11)-n,k)
                                .retour_altitude()+(pente/resolution));
                            }
                        }
                    }
                    if(j==12)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            for(n=0; n<=2; n++)
                            {
                                C(ii,(j-13)-n,k).set_altitude(C(ii,(j-12)-n,k)
                                .retour_altitude()+(pente/resolution));
                            }
                        }
                    }
                    if(j==13)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            for(n=0; n<=1; n++)
                            {
                                C(ii,(j-14)-n,k).set_altitude(C(ii,(j-13)-n,k)
                                .retour_altitude()+(pente/resolution));
                            }
                        }
                    }
                    if(j==14)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            for(n=0; n<=0; n++)
                            {
                                C(ii,(j-15)-n,k).set_altitude(C(ii,(j-14)-n,k)
                                .retour_altitude()+(pente/resolution));
                            }
                        }
                    }
                    if(j==jmax-1)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            for(n=0; n<=14; n++)
                            {
                                C(ii,(j+1)+n,k).set_altitude(C(ii,j+n,k)
                                .retour_altitude()-(pente/resolution));
                            }
                        }
                    }
                    if(j==jmax-2)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            for(n=0; n<=13; n++)
                            {
                                C(ii,(j+2)+n,k).set_altitude(C(ii,(j+1)+n,k)
                                .retour_altitude()-(pente/resolution));
                            }
                        }
                    }
                    if(j==jmax-3)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            for(n=0; n<=12; n++)
                            {
                                C(i,(j+3)+n,k).set_altitude(C(ii,(j+2)+n,k)
                                .retour_altitude()-(pente/resolution));
                            }
                        }
                    }
                    if(j==jmax-4)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            for(n=0; n<=11; n++)
                            {
                                C(i,(j+4)+n,k).set_altitude(C(ii,(j+3)+n,k)
                                .retour_altitude()-(pente/resolution));
                            }
                        }
                    }
                    if(j==jmax-5)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            for(n=0; n<=10; n++)
                            {
                                C(i,(j+5)+n,k).set_altitude(C(ii,(j+4)+n,k)
                                .retour_altitude()-(pente/resolution));
                            }
                        }
                    }
                    if(j==jmax-6)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            for(n=0; n<=9; n++)
                            {
                                C(i,(j+6)+n,k).set_altitude(C(ii,(j+5)+n,k)
                                .retour_altitude()-(pente/resolution));
                            }
                        }
                    }
                    if(j==jmax-7)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            for(n=0; n<=8; n++)
                            {
                                C(i,(j+7)+n,k).set_altitude(C(ii,(j+6)+n,k)
                                .retour_altitude()-(pente/resolution));
                            }
                        }
                    }
                    if(j==jmax-8)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            for(n=0; n<=7; n++)
                            {
                                C(i,(j+8)+n,k).set_altitude(C(ii,(j+7)+n,k)
                                .retour_altitude()-(pente/resolution));
                            }
                        }
                    }
                    if(j==jmax-9)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            for(n=0; n<=6; n++)
                            {
                                C(i,(j+9)+n,k).set_altitude(C(ii,(j+8)+n,k)
                                .retour_altitude()-(pente/resolution));
                            }
                        }
                    }
                    if(j==jmax-10)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            for(n=0; n<=5; n++)
                            {
                                C(i,(j+10)+n,k).set_altitude(C(ii,(j+9)+n,k)
                                .retour_altitude()-(pente/resolution));
                            }
                        }
                    }
                    if(j==jmax-11)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            for(n=0; n<=4; n++)
                            {
                                C(i,(j+11)+n,k).set_altitude(C(ii,(j+10)+n,k)
                                .retour_altitude()-(pente/resolution));
                            }
                        }
                    }
                    if(j==jmax-12)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            for(n=0; n<=3; n++)
                            {
                                C(i,(j+12)+n,k).set_altitude(C(ii,(j+11)+n,k)
                                .retour_altitude()-(pente/resolution));
                            }
                        }
                    }
                    if(j==jmax-13)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            for(n=0; n<=2; n++)
                            {
                                C(i,(j+13)+n,k).set_altitude(C(ii,(j+12)+n,k)
                                .retour_altitude()-(pente/resolution));
                            }
                        }
                    }
                    if(j==jmax-14)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            for(n=0; n<=1; n++)
                            {
                                C(i,(j+14)+n,k).set_altitude(C(ii,(j+13)+n,k)
                                .retour_altitude()-(pente/resolution));
                            }
                        }
                    }
                    if(j==jmax-15)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            for(n=0; n<=0; n++)
                            {
                                C(i,(j+15)+n,k).set_altitude(C(ii,(j+14)+n,k)
                                .retour_altitude()-(pente/resolution));
                            }
                        }
                    }

                    if(j<(jmax-1-rayon_max))
                    {
                        for(jj=j; jj>=j-rayon_max+1; jj--)
                        {
                            if(C(i,jj,k).retour_altitude()>C(i,jj-1,k)
                            .retour_altitude())
                            {
                                montant++;
                                if(montant_max<montant)
                                {
                                    montant_max=montant;
                                }
                            }
                            if(C(i,jj,k).retour_altitude()<C(i,jj-1,k)
                            .retour_altitude())
                            {
                                descendant++;
                                if(descendant_max<descendant)
                                {
                                    descendant_max=descendant;
                                }
                            }
                        }

                        for(jj=j; jj<=j+rayon_max-1; jj++)
                        {
                            if(C(i,jj,k).retour_altitude()<C(i,jj+1,k)
                            .retour_altitude())
                            {
                                montant++;
                                if(montant_max<montant)
                                {
                                    montant_max=montant;
                                }
                            }
                            if(C(i,jj,k).retour_altitude()>C(i,jj+1,k)
                            .retour_altitude())
                            {
                                descendant++;
                                if(descendant_max<descendant)
                                {
                                    descendant_max=descendant;
                                }
                            }
                        }
                    }

                    if(montant>0 && montant<=descendant)
                    {
                        concavexite=1;
                    }
                    if(montant>descendant)
                    {
                        concavexite=-1;
                    }
                    if(montant<=descendant && C(i,j,k).retour_influence()!=0)
                    {
                        concavexite=-1;
                    }

                    somme1=

                    C(i-1,j-15,k).retour_valeur()*(ligne1)*(sens_pente(C(i-1,j-15,k).retour_pente()))+
                    C(i,j-15,k).retour_valeur()*(ligne1)*(sens_pente(C(i,j-15,k).retour_pente()))+
                    C(i+1,j-15,k).retour_valeur()*(ligne1)*(sens_pente(C(i+1,j-15,k).retour_pente()))+

                    C(i-1,j-14,k).retour_valeur()*(ligne2)*(sens_pente(C(i-1,j-14,k).retour_pente()))+
                    C(i,j-14,k).retour_valeur()*(ligne2)*(sens_pente(C(i,j-14,k).retour_pente()))+
                    C(i+1,j-14,k).retour_valeur()*(ligne2)*(sens_pente(C(i+1,j-14,k).retour_pente()))+

                    C(i-1,j-13,k).retour_valeur()*(ligne3)*(sens_pente(C(i-1,j-13,k).retour_pente()))+
                    C(i,j-13,k).retour_valeur()*(ligne3)*(sens_pente(C(i,j-13,k).retour_pente()))+
                    C(i+1,j-13,k).retour_valeur()*(ligne3)*(sens_pente(C(i+1,j-13,k).retour_pente()))+

                    C(i-1,j-12,k).retour_valeur()*(ligne4)*(sens_pente(C(i-1,j-12,k).retour_pente()))+
                    C(i,j-12,k).retour_valeur()*(ligne4)*(sens_pente(C(i,j-12,k).retour_pente()))+
                    C(i+1,j-12,k).retour_valeur()*(ligne4)*(sens_pente(C(i+1,j-12,k).retour_pente()))+

                    C(i-1,j-11,k).retour_valeur()*(ligne5)*(sens_pente(C(i-1,j-11,k).retour_pente()))+
                    C(i,j-11,k).retour_valeur()*(ligne5)*(sens_pente(C(i,j-11,k).retour_pente()))+
                    C(i+1,j-11,k).retour_valeur()*(ligne5)*(sens_pente(C(i+1,j-11,k).retour_pente()))+

                    C(i-1,j-10,k).retour_valeur()*(ligne6)*(sens_pente(C(i-1,j-10,k).retour_pente()))+
                    C(i,j-10,k).retour_valeur()*(ligne6)*(sens_pente(C(i,j-10,k).retour_pente()))+
                    C(i+1,j-10,k).retour_valeur()*(ligne6)*(sens_pente(C(i+1,j-10,k).retour_pente()))+

                    C(i-1,j-9,k).retour_valeur()*(ligne7)*(sens_pente(C(i-1,j-9,k).retour_pente()))+
                    C(i,j-9,k).retour_valeur()*(ligne7)*(sens_pente(C(i,j-9,k).retour_pente()))+
                    C(i+1,j-9,k).retour_valeur()*(ligne7)*(sens_pente(C(i+1,j-9,k).retour_pente()))+

                    C(i-1,j-8,k).retour_valeur()*(ligne8)*(sens_pente(C(i-1,j-8,k).retour_pente()))+
                    C(i,j-8,k).retour_valeur()*(ligne8)*(sens_pente(C(i,j-8,k).retour_pente()))+
                    C(i+1,j-8,k).retour_valeur()*(ligne8)*(sens_pente(C(i+1,j-8,k).retour_pente()))+

                    C(i-1,j-7,k).retour_valeur()*(ligne9)*(sens_pente(C(i-1,j-7,k).retour_pente()))+
                    C(i,j-7,k).retour_valeur()*(ligne9)*(sens_pente(C(i,j-7,k).retour_pente()))+
                    C(i+1,j-7,k).retour_valeur()*(ligne9)*(sens_pente(C(i+1,j-7,k).retour_pente()))+

                    C(i-1,j-6,k).retour_valeur()*(ligne10)*(sens_pente(C(i-1,j-6,k).retour_pente()))+
                    C(i,j-6,k).retour_valeur()*(ligne10)*(sens_pente(C(i,j-6,k).retour_pente()))+
                    C(i+1,j-6,k).retour_valeur()*(ligne10)*(sens_pente(C(i+1,j-6,k).retour_pente()))+

                    C(i-1,j-5,k).retour_valeur()*(ligne11)*(sens_pente(C(i-1,j-5,k).retour_pente()))+
                    C(i,j-5,k).retour_valeur()*(ligne11)*(sens_pente(C(i,j-5,k).retour_pente()))+
                    C(i+1,j-5,k).retour_valeur()*(ligne11)*(sens_pente(C(i+1,j-5,k).retour_pente()))+

                    C(i-1,j-4,k).retour_valeur()*(ligne12+norm_pente(C(i-1,j-4,k).retour_pente()))*(sens_pente(C(i-1,j-4,k).retour_pente()))+
                    C(i,j-4,k).retour_valeur()*(ligne12+norm_pente(C(i,j-4,k).retour_pente()))*(sens_pente(C(i,j-4,k).retour_pente()))+
                    C(i+1,j-4,k).retour_valeur()*(ligne12+norm_pente(C(i+1,j-4,k).retour_pente()))*(sens_pente(C(i+1,j-4,k).retour_pente()))+

                    C(i-1,j-3,k).retour_valeur()*(ligne13+norm_pente(C(i-1,j-3,k).retour_pente()))*(sens_pente(C(i-1,j-5,k).retour_pente()))+
                    C(i,j-3,k).retour_valeur()*(ligne13+norm_pente(C(i,j-3,k).retour_pente()))*(sens_pente(C(i,j-5,k).retour_pente()))+
                    C(i+1,j-3,k).retour_valeur()*(ligne13+norm_pente(C(i+1,j-3,k).retour_pente()))*(sens_pente(C(i+1,j-5,k).retour_pente()))+

                    C(i-1,j-2,k).retour_valeur()*(ligne14+norm_pente(C(i-1,j-2,k).retour_pente()))*(sens_pente(C(i-1,j-4,k).retour_pente()))+
                    C(i,j-2,k).retour_valeur()*(ligne14+norm_pente(C(i,j-2,k).retour_pente()))*(sens_pente(C(i-1,j-4,k).retour_pente()))+
                    C(i+1,j-2,k).retour_valeur()*(ligne14+norm_pente(C(i+1,j-2,k).retour_pente()))*(sens_pente(C(i-1,j-4,k).retour_pente()))+

                    C(i-1,j-1,k).retour_valeur()*(0)+
                    C(i,j-1,k).retour_valeur()*(ligne15+norm_pente(C(i,j-1,k).retour_pente()))*(sens_pente(C(i-1,j-4,k).retour_pente()))+
                    C(i+1,j-1,k).retour_valeur()*(0)+

                    C(i-1,j,k).retour_valeur()*(ligne16+norm_pente(C(i-1,j,k).retour_pente()))*(sens_pente(C(i-1,j-4,k).retour_pente()))+
                    C(i+1,j,k).retour_valeur()*(ligne16+norm_pente(C(i+1,j,k).retour_pente()))*(sens_pente(C(i-1,j-4,k).retour_pente()))+

                    C(i-1,j+1,k).retour_valeur()*(ligne17+norm_pente(C(i-1,j+1,k).retour_pente()))*(sens_pente(C(i-1,j-4,k).retour_pente()))+
                    C(i,j+1,k).retour_valeur()*(ligne17+norm_pente(C(i,j+1,k).retour_pente()))*(sens_pente(C(i-1,j-4,k).retour_pente()))+
                    C(i+1,j+1,k).retour_valeur()*(ligne17+norm_pente(C(i+1,j+1,k).retour_pente()))*(sens_pente(C(i-1,j-4,k).retour_pente()))+

                    C(i-1,j+2,k).retour_valeur()*(ligne18+norm_pente(C(i-1,j+2,k).retour_pente()))*(sens_pente(C(i-1,j-4,k).retour_pente()))+
                    C(i,j+2,k).retour_valeur()*(ligne18+norm_pente(C(i,j+2,k).retour_pente()))*(sens_pente(C(i-1,j-4,k).retour_pente()))+
                    C(i+1,j+2,k).retour_valeur()*(ligne18+norm_pente(C(i+1,j+2,k).retour_pente()))*(sens_pente(C(i-1,j-4,k).retour_pente()))+

                    C(i-1,j+3,k).retour_valeur()*(ligne19+norm_pente(C(i-1,j+3,k).retour_pente()))*(sens_pente(C(i-1,j-4,k).retour_pente()))+
                    C(i,j+3,k).retour_valeur()*(ligne19+norm_pente(C(i,j+3,k).retour_pente()))*(sens_pente(C(i-1,j-4,k).retour_pente()))+
                    C(i+1,j+3,k).retour_valeur()*(ligne19+norm_pente(C(i+1,j+3,k).retour_pente()))*(sens_pente(C(i-1,j-4,k).retour_pente()))+

                    C(i-1,j+4,k).retour_valeur()*(ligne20)*(sens_pente(C(i-1,j+4,k).retour_pente()))+
                    C(i,j+4,k).retour_valeur()*(ligne20)*(sens_pente(C(i,j+4,k).retour_pente()))+
                    C(i+1,j+4,k).retour_valeur()*(ligne20)*(sens_pente(C(i+1,j+4,k).retour_pente()))+

                    C(i-1,j+5,k).retour_valeur()*(ligne21)*(sens_pente(C(i-1,j+5,k).retour_pente()))+
                    C(i,j+5,k).retour_valeur()*(ligne21)*(sens_pente(C(i,j+5,k).retour_pente()))+
                    C(i+1,j+5,k).retour_valeur()*(ligne21)*(sens_pente(C(i+1,j+5,k).retour_pente()))+

                    C(i-1,j+6,k).retour_valeur()*(ligne22)*(sens_pente(C(i-1,j+6,k).retour_pente()))+
                    C(i,j+6,k).retour_valeur()*(ligne22)*(sens_pente(C(i,j+6,k).retour_pente()))+
                    C(i+1,j+6,k).retour_valeur()*(ligne22)*(sens_pente(C(i+1,j+6,k).retour_pente()))+

                    C(i-1,j+7,k).retour_valeur()*(ligne23)*(sens_pente(C(i-1,j+7,k).retour_pente()))+
                    C(i,j+7,k).retour_valeur()*(ligne23)*(sens_pente(C(i,j+7,k).retour_pente()))+
                    C(i+1,j+7,k).retour_valeur()*(ligne23)*(sens_pente(C(i+1,j+7,k).retour_pente()))+

                    C(i-1,j+8,k).retour_valeur()*(ligne24)*(sens_pente(C(i-1,j+8,k).retour_pente()))+
                    C(i,j+8,k).retour_valeur()*(ligne24)*(sens_pente(C(i,j+8,k).retour_pente()))+
                    C(i+1,j+8,k).retour_valeur()*(ligne24)*(sens_pente(C(i+1,j+8,k).retour_pente()));

                    nvaleur=C(i,j,k).retour_valeur()+normalisation(somme1)+
                    norm_pluie(pluie)+concavexite;
                    C(i,j,k+1).set_valeur(nvaleur);                    

                    if(C(i,j,k).retour_termite()==1)
                    {
                        C(i,j,k).set_valeur(0);
                    }

                    if(C(i,j,k+1).retour_valeur()<0)
                        C(i,j,k+1).set_valeur(0);
                    if(C(i,j,k+1).retour_valeur()>valeur_max)
                        C(i,j,k+1).set_valeur(valeur_max);
                    if(j==0)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            C(ii,j-15,k).set_altitude(C(ii,j-16,k).retour_altitude()-(pente/resolution));
                            for(n=0; n<=13; n++)
                            {
                                C(ii,(j-14)+n,k).set_altitude(C(ii,(j-15)+n,k).retour_altitude()-(pente/resolution));
                            }
                        }
                    }
                    if(j==1)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            C(ii,j-15,k).set_altitude(C(ii,j-16,k).retour_altitude()-(pente/resolution));
                            for(n=0; n<=12; n++)
                            {
                                C(ii,(j-14)+n,k).set_altitude(C(ii,(j-15)+n,k).retour_altitude()-(pente/resolution));
                            }
                        }
                    }
                    if(j==2)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            C(ii,j-15,k).set_altitude(C(ii,j-16,k).retour_altitude()-(pente/resolution));
                            for(n=0; n<=11; n++)
                            {
                                C(ii,(j-14)+n,k).set_altitude(C(ii,(j-15)+n,k).retour_altitude()-(pente/resolution));
                            }
                        }
                    }
                    if(j==3)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            C(ii,j-15,k).set_altitude(C(ii,j-16,k).retour_altitude()-(pente/resolution));
                            for(n=0; n<=10; n++)
                            {
                                C(ii,(j-14)+n,k).set_altitude(C(ii,(j-15)+n,k).retour_altitude()-(pente/resolution));
                            }
                        }
                    }
                    if(j==4)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            C(ii,j-15,k).set_altitude(C(ii,j-16,k).retour_altitude()-(pente/resolution));
                            for(n=0; n<=9; n++)
                            {
                                C(ii,(j-14)+n,k).set_altitude(C(ii,(j-15)+n,k).retour_altitude()-(pente/resolution));
                            }
                        }
                    }
                    if(j==5)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            C(ii,j-15,k).set_altitude(C(ii,j-16,k).retour_altitude()-(pente/resolution));
                            for(n=0; n<=8; n++)
                            {
                                C(ii,(j-14)+n,k).set_altitude(C(ii,(j-15)+n,k).retour_altitude()-(pente/resolution));
                            }
                        }
                    }
                    if(j==6)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            C(ii,j-15,k).set_altitude(C(ii,j-16,k).retour_altitude()-(pente/resolution));
                            for(n=0; n<=7; n++)
                            {
                                C(ii,(j-14)+n,k).set_altitude(C(ii,(j-15)+n,k).retour_altitude()-(pente/resolution));
                            }
                        }
                    }
                    if(j==7)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            C(ii,j-15,k).set_altitude(C(ii,j-16,k).retour_altitude()-(pente/resolution));
                            for(n=0; n<=6; n++)
                            {
                                C(ii,(j-14)+n,k).set_altitude(C(ii,(j-15)+n,k).retour_altitude()-(pente/resolution));
                            }
                        }
                    }
                    if(j==8)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            C(ii,j-15,k).set_altitude(C(ii,j-16,k).retour_altitude()-(pente/resolution));
                            for(n=0; n<=5; n++)
                            {
                                C(ii,(j-14)+n,k).set_altitude(C(ii,(j-15)+n,k).retour_altitude()-(pente/resolution));
                            }
                        }
                    }
                    if(j==9)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            C(ii,j-15,k).set_altitude(C(ii,j-16,k).retour_altitude()-(pente/resolution));
                            for(n=0; n<=4; n++)
                            {
                                C(ii,(j-14)+n,k).set_altitude(C(ii,(j-15)+n,k).retour_altitude()-(pente/resolution));
                            }
                        }
                    }
                    if(j==10)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            C(ii,j-15,k).set_altitude(C(ii,j-16,k).retour_altitude()-(pente/resolution));
                            for(n=0; n<=3; n++)
                            {
                                C(ii,(j-14)+n,k).set_altitude(C(ii,(j-15)+n,k).retour_altitude()-(pente/resolution));
                            }
                        }
                    }
                    if(j==11)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            C(ii,j-15,k).set_altitude(C(ii,j-16,k).retour_altitude()-(pente/resolution));
                            for(n=0; n<=2; n++)
                            {
                                C(ii,(j-14)+n,k).set_altitude(C(ii,(j-15)+n,k).retour_altitude()-(pente/resolution));
                            }
                        }
                    }
                    if(j==12)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            C(ii,j-15,k).set_altitude(C(ii,j-16,k).retour_altitude()-(pente/resolution));
                            for(n=0; n<=1; n++)
                            {
                                C(ii,(j-14)+n,k).set_altitude(C(ii,(j-15)+n,k).retour_altitude()-(pente/resolution));
                            }
                        }
                    }
                    if(j==13)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            C(ii,j-15,k).set_altitude(C(ii,j-16,k).retour_altitude()-(pente/resolution));
                            for(n=0; n<=0; n++)
                            {
                                C(ii,(j-14)+n,k).set_altitude(C(ii,(j-15)+n,k).retour_altitude()-(pente/resolution));
                            }
                        }
                    }
                    if(j==14)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            C(ii,j-15,k).set_altitude(C(ii,j-16,k).retour_altitude()-(pente/resolution));
                        }
                    }
                    if(j==jmax-1)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            for(n=0; n<=14; n++)
                            {
                                C(ii,(j+15)-n,k).set_altitude(C(ii,(j+16)-n,k).retour_altitude()+(pente/resolution));
                            }
                        }
                    }
                    if(j==jmax-2)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            for(n=0; n<=13; n++)
                            {
                                C(ii,(j+15)-n,k).set_altitude(C(ii,(j+16)-n,k).retour_altitude()+(pente/resolution));
                            }
                        }
                    }
                    if(j==jmax-3)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            for(n=0; n<=12; n++)
                            {
                                C(ii,(j+15)-n,k).set_altitude(C(ii,(j+16)-n,k).retour_altitude()+(pente/resolution));
                            }
                        }
                    }
                    if(j==jmax-4)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            for(n=0; n<=11; n++)
                            {
                                C(ii,(j+15)-n,k).set_altitude(C(ii,(j+16)-n,k).retour_altitude()+(pente/resolution));
                            }
                        }
                    }
                    if(j==jmax-5)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            for(n=0; n<=10; n++)
                            {
                                C(ii,(j+15)-n,k).set_altitude(C(ii,(j+16)-n,k).retour_altitude()+(pente/resolution));
                            }
                        }
                    }
                    if(j==jmax-6)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            for(n=0; n<=9; n++)
                            {
                                C(ii,(j+15)-n,k).set_altitude(C(ii,(j+16)-n,k).retour_altitude()+(pente/resolution));
                            }
                        }
                    }
                    if(j==jmax-7)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            for(n=0; n<=8; n++)
                            {
                                C(ii,(j+15)-n,k).set_altitude(C(ii,(j+16)-n,k).retour_altitude()+(pente/resolution));
                            }
                        }
                    }
                    if(j==jmax-8)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            for(n=0; n<=7; n++)
                            {
                                C(ii,(j+15)-n,k).set_altitude(C(ii,(j+16)-n,k).retour_altitude()+(pente/resolution));
                            }
                        }
                    }
                    if(j==jmax-9)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            for(n=0; n<=6; n++)
                            {
                                C(ii,(j+15)-n,k).set_altitude(C(ii,(j+16)-n,k).retour_altitude()+(pente/resolution));
                            }
                        }
                    }
                    if(j==jmax-10)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            for(n=0; n<=5; n++)
                            {
                                C(ii,(j+15)-n,k).set_altitude(C(ii,(j+16)-n,k).retour_altitude()+(pente/resolution));
                            }
                        }
                    }
                    if(j==jmax-11)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            for(n=0; n<=4; n++)
                            {
                                C(ii,(j+15)-n,k).set_altitude(C(ii,(j+16)-n,k).retour_altitude()+(pente/resolution));
                            }
                        }
                    }
                    if(j==jmax-12)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            for(n=0; n<=3; n++)
                            {
                                C(ii,(j+15)-n,k).set_altitude(C(ii,(j+16)-n,k).retour_altitude()+(pente/resolution));
                            }
                        }
                    }
                    if(j==jmax-13)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            for(n=0; n<=2; n++)
                            {
                                C(ii,(j+15)-n,k).set_altitude(C(ii,(j+16)-n,k).retour_altitude()+(pente/resolution));
                            }
                        }
                    }
                    if(j==jmax-14)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            for(n=0; n<=1; n++)
                            {
                                C(ii,(j+15)-n,k).set_altitude(C(ii,(j+16)-n,k).retour_altitude()+(pente/resolution));
                            }
                        }
                    }
                    if(j==jmax-15)
                    {
                        for(ii=0; ii<imax; ii++)
                        {
                            for(n=0; n<=0; n++)

                            {
                                C(ii,(j+15)-n,k).set_altitude(C(ii,(j+16)-n,k).retour_altitude()+(pente/resolution));
                            }
                        }
                    }

                    switch(C(i,j,k).retour_valeur())
                    {
                        case(0):
                        {
                            RectFill ( &winport_blanc, (i*zoom)+20, (j*zoom)+20, (i*zoom)+zoom+20, (j*zoom)+zoom+20);
                        }
                            break;
                        case(1):
                        {
                            RectFill ( &winport_gris1, (i*zoom)+20, (j*zoom)+20, (i*zoom)+zoom+20, (j*zoom)+zoom+20);
                        }
                            break;
                        case(2):
                        {
                            RectFill ( &winport_gris2, (i*zoom)+20, (j*zoom)+20, (i*zoom)+zoom+20, (j*zoom)+zoom+20);
                        }
                            break;
                        case(3):
                        {
                            RectFill ( &winport_gris3, (i*zoom)+20, (j*zoom)+20, (i*zoom)+zoom+20, (j*zoom)+zoom+20);
                        }
                            break;
                        case(4):
                        {
                            RectFill ( &winport_gris4, (i*zoom)+20, (j*zoom)+20, (i*zoom)+zoom+20, (j*zoom)+zoom+20);
                        }
                            break;
                        case(5):
                        {
                            RectFill ( &winport_gris5, (i*zoom)+20, (j*zoom)+20, (i*zoom)+zoom+20, (j*zoom)+zoom+20);
                        }
                            break;
                        case(6):
                        {
                            RectFill ( &winport_gris6, (i*zoom)+20, (j*zoom)+20, (i*zoom)+zoom+20, (j*zoom)+zoom+20);
                        }
                            break;
                        case(7):
                        {
                            RectFill ( &winport_gris7, (i*zoom)+20, (j*zoom)+20, (i*zoom)+zoom+20, (j*zoom)+zoom+20);
                        }
                            break;
                        case(8):
                        {
                            RectFill ( &winport_gris8, (i*zoom)+20, (j*zoom)+20, (i*zoom)+zoom+20, (j*zoom)+zoom+20);
                        }
                            break;
                        case(9):
                        {
                            RectFill ( &winport_gris9, (i*zoom)+20, (j*zoom)+20, (i*zoom)+zoom+20, (j*zoom)+zoom+20);
                        }
                            break;
                        case(10):
                        {
                            RectFill ( &winport_gris10, (i*zoom)+20, (j*zoom)+20, (i*zoom)+zoom+20, (j*zoom)+zoom+20);
                        }
                            break;
                        case(11):
                        {
                            RectFill ( &winport_gris11, (i*zoom)+20, (j*zoom)+20, (i*zoom)+zoom+20, (j*zoom)+zoom+20);
                        }
                            break;
                        case(12):
                        {
                            RectFill ( &winport_gris12, (i*zoom)+20, (j*zoom)+20, (i*zoom)+zoom+20, (j*zoom)+zoom+20);
                        }
                            break;
                        case(13):
                        {
                            RectFill ( &winport_gris13, (i*zoom)+20, (j*zoom)+20, (i*zoom)+zoom+20, (j*zoom)+zoom+20);
                        }
                            break;
                        case(14):
                        {
                            RectFill ( &winport_gris14, (i*zoom)+20, (j*zoom)+20, (i*zoom)+zoom+20, (j*zoom)+zoom+20);
                        }
                            break;
                        case(15):
                        {
                            RectFill ( &winport_noir, (i*zoom)+20, (j*zoom)+20, (i*zoom)+zoom+20, (j*zoom)+zoom+20);
                        }
                            break;
                        default:
                            break;
                    }

                    interrupt=IO_boucle();
                    if(interrupt)
                    {
                        printf("interruption\n");
                        goto interruption;
                    }
                }
            }
            generation++;
            Emperor_SetGadgetAttr(String2, inttostring(generation));
            for(j=0; j<jmax; j++)
            {
                for(i=0; i<imax; i++)
                {
                    C(i,j,k)=C(i,j,k+1);
                }
            }
        }
    }
    interruption:
    SetGadgetAttrs(Button3, Window1, NULL, GA_Selected, FALSE, TAG_DONE);
    DoMethod(winobj, WM_CLOSE);
    win=NULL;
    winobj=NULL;
}

void Menu_Information1_MenuPick_Event(void)
{
}

void Menu_Quit1_MenuPick_Event(void)
{
}

void Window1_Iconify_Event(void)
{
    Emperor_IconifyWindow_Window1();
}

void Window1_Uniconify_Event(void)
{
    Emperor_UniconifyWindow_Window1();
}
void Shutdown(void)
{
    ReleasePen(Screen1->ViewPort.ColorMap, noir);
    ReleasePen(Screen1->ViewPort.ColorMap, blanc);
    ReleasePen(Screen1->ViewPort.ColorMap, gris1);
    ReleasePen(Screen1->ViewPort.ColorMap, gris2);
    ReleasePen(Screen1->ViewPort.ColorMap, gris3);
    ReleasePen(Screen1->ViewPort.ColorMap, gris4);
    ReleasePen(Screen1->ViewPort.ColorMap, gris5);
    ReleasePen(Screen1->ViewPort.ColorMap, gris6);
    ReleasePen(Screen1->ViewPort.ColorMap, gris7);
    ReleasePen(Screen1->ViewPort.ColorMap, gris8);
    ReleasePen(Screen1->ViewPort.ColorMap, gris9);
    ReleasePen(Screen1->ViewPort.ColorMap, gris10);
    ReleasePen(Screen1->ViewPort.ColorMap, gris11);
    ReleasePen(Screen1->ViewPort.ColorMap, gris12);
    ReleasePen(Screen1->ViewPort.ColorMap, gris13);
    ReleasePen(Screen1->ViewPort.ColorMap, gris14);
}

int norm_pluie(int pluie)      //normaliser la pluviométrie
{
    int pluie_int=0;
    if(pluie<300)
        pluie_int=(-1);
    if((pluie>=300) && (pluie<=600))
        pluie_int=0;
    if(pluie>600)
        pluie_int=1;
    return pluie_int;
}

int norm_pente(float pente)             //normaliser la pente
{
    int pente_int=0;
    if(pente<0.29)
        pente_int=1;
    if((pente>=0.29) && (pente<=0.89))
        pente_int=0;
    if(pente>0.89)
        pente_int=(-1);
    return pente_int;
}

int sens_pente(float pente)
{
    int sens=0;
    if(pente>0)
        sens=1;
    else
        sens=-1;
    return sens;
}

int normalisation(int somme1)      //bloquer l'augmentation
{
    int somme2=0;
    if(somme1>=1)
        somme2=2;
    else
        somme2=somme1;
    if(somme2<=-1)
        somme2=-2;
    return somme2;
}

BOOL IO_boucle()
{
    BOOL pause=FALSE, fermer=FALSE;
    Emperor_Input=0L;
    do
    {
        while((Emperor_Input = RA_HandleInput(WindowObject1, &Emperor_Code)) != WMHI_LASTMSG)
        {
            //printf("input reçu: %d\n", Emperor_Input);
            switch(Emperor_Input & WMHI_CLASSMASK)
            {
                case WMHI_GADGETUP:
                    switch(Emperor_Input & WMHI_GADGETMASK)
                    {
                        case 20:
                            //Button3_GadgetUp_Event();
                            //printf("case pause: %d\n", pause);
                            if(pause==TRUE)
                            {
                                pause=FALSE;
                            }
                            else
                            {
                                pause=TRUE;
                            }
                            //printf("case pause: %d\n", pause);
                            break;
                        case 21:
                            //Button6_GadgetUp_Event();
                            //printf("case fermer: %d\n");
                            fermer=TRUE;
                            return fermer;
                            break;
                        default:
                            pause=FALSE;
                            break;
                    }
                case WMHI_MOUSEMOVE:
                    printf("%d ", win->MouseX, " en x");
                    printf("%d ", win->MouseY, " en y");
                    break;
                case WMHI_MOUSEBUTTONS:
                    printf("souris ");
                    break;
                default:
                    break;
            }
        }
    }
    while(pause==TRUE);
}

void Button3_GadgetUp_Event(void)
{
}
void Button4_GadgetUp_Event(void)
{
}