/*
*    KLASSE TERRAIN
*
*    platziert ein random generiertes Terrain
*    ein 2d array kann mit random werten gefüllt werden
*    kontrast erhöht werden
*    gesmoothed werden
*    als 2d oder 3d dargestellt werden
*
*    TerrainPalette    Array fuer Terrain grid
*    breiteT           Breite des Arrays
*    hoeheT            Hoehe des Arrays
*
*    initTerrain();    berechne ein random generiertes Terrain
*    drawTerrain();    zeichne Terrain
*    fillArray();      berechnet random Werte für das Terrain grid
*    smoothen();       vermindert den Kontrast des Terrains
*    moreContrast();   erhöht den Kontrast des Terrains
*
*/

class Terrain
{
    int[][] TerrainPalette;
    int breiteT;
    int hoeheT;
    
    Terrain(int[][] fa, int b, int h)                          // Konstruktor
    {
        TerrainPalette=fa;
        breiteT=b;
        hoeheT=h;
    }
    
    
    // Methode - berechne ein random generiertes Terrain 
    void initTerrain()
    {
        TerrainPalette=fillArray(TerrainPalette,breiteT, hoeheT);
        
        for (int i=0;i<12;i++)    //glaette das Terrain
        {
            TerrainPalette=smoothen(TerrainPalette,breiteT, hoeheT);
        }
        
        for (int i=0;i<90;i++)    //erhoehe den Kontrast
        {
            TerrainPalette=moreContrast(TerrainPalette,breiteT, hoeheT);
        }
        
        for (int i=0;i<20;i++)    //glaette das Terrain
        {
            TerrainPalette=smoothen(TerrainPalette,breiteT, hoeheT);
        }
    }
    
    
    // Methode - zeichne Terrain 
    void draw2DTerrain()
    {
        noStroke();
        fill(0);
        rect(0,0,screen_x,screen_y);
        for(int i = randArr; i < breiteT-randArr; i++)
        {
            for (int j = randArr; j < hoeheT-randArr; j++)
            {
                noStroke();
                fill (0.8*TerrainPalette[i][j],TerrainPalette[i][j],0.05*TerrainPalette[i][j]);
                rect (i*kg,j*kg,kg,kg);
            }
        }
    }
    
    
    // Methode - berechnet random Werte für das Terrain grid 
    int[][] fillArray(int[][] var, int b, int h)
    {
        for (int i=0; i<b; i++)
        {
            for (int j=0; j<h; j++)
            {
                var [i][j]=(int)random(0,220);
            }
        }
        return  var;
    }
    
    
    // Methode - vermindert den Kontrast des Terrains 
    int[][] smoothen(int[][] var, int b, int h)
    {
        for (int i=0; i< (b*h/3); i++)
        {
            float summ;
            int x = (int)random(1,b-1);
            int y = (int)random(1,h-1);
            summ = ((var[x-1][y]+var[x+1][y]+var[x][y+1]+var[x][y-1])/4);
            var[x][y]= (int)summ;
        }
        return  var;
    }
    
    
    // Methode - erhöht den Kontrast des Terrains 
    int[][] moreContrast (int[][] var, int b, int h)
    {
        for (int i=0;i<((b*h)/3);i++)
        {
            int x = (int)random(6,b-6);
            int y = (int)random(6,h-6);
            int abstx = (int)random(-3,3);
            int absty = (int)random(-3,3);
            for( int j=0;j<3;j++)
            {
                if ((var[x][y]-var[x+abstx][y+absty])>100 ||(var[x][y]-var[x+abstx][y+absty])<-100 )
                {
                    var[x][y]=(var[x][y]+50);
                    var[x+(abstx*2)][y+(absty*2)]=(var[x+(abstx*2)][y+(absty*2)]-5);
                    var[x][y]=min(var[x][y],255);
                    var[x+(abstx*2)][y+(absty*2)]=max(0,var[x+(abstx*2)][y+(absty*2)]);
                }
            }
        }
        return var;
    }
    
    // Methode - zeichne das terrain in 3d
    void draw3DTerrain()
    {
        pushMatrix();
        translate(0, height/1.6, -height/2);
        noStroke();
        rotateX(-45);
        scale(kg);
        float yHeight;
        
        beginShape(QUADS);
        
        for(int i = randArr; i < breiteT-randArr; i++)
        {
            for (int j = randArr; j < hoeheT-randArr; j++)
            {
                //if(ifaceAktiv==true)
                //{
                    fill (0.8*TerrainPalette[i][j],TerrainPalette[i][j],0.05*TerrainPalette[i][j]);
                    yHeight = -0.08*TerrainPalette[i][j];
                    vertex( i-1.2, yHeight, j+1.2);              //Voxxelartige Zeichnung, dh kleine quadratische Flächen auf der Höhe von TerrainPalette[][]
                    vertex( i-1.2, yHeight, j-1.2);              //wenn auch Fläche nicht geschlossen, Resultat besser als Version unten
                    vertex( i+1.2, yHeight, j-1.2);
                    vertex( i+1.2, yHeight, j+1.2);
                    
                    /*}else{
                    vertex( i, -0.08*TerrainPalette[i][j+1], j+1);                  //variante wie das terrain gezeichnet wird
                    vertex( i, -0.08*TerrainPalette[i][j], j);                      // polygonartige zeichnung, dh punkt zu punkt geschlossene fläche
                    vertex( i+1, -0.08*TerrainPalette[i+1][j], j);                  //berücksichtigung der nächsten höhe aus TerrainPalette[][]
                    vertex( i+1, -0.08*TerrainPalette[i+1][j+1], j+1);
                }*/
                
            }
        }
        endShape();
        
        beginShape(QUADS);
        int i, j;
        float u, v;
        float h;
        float s;
        
        for (int x=0; x < (int)blumenListe.size(); x++)
        {
            i = (int)(((BlumenObj)blumenListe.get(x)).getX()/kg);
            j = (int)(((BlumenObj)blumenListe.get(x)).getY()/kg);
            s = 0.18 * ((BlumenObj)blumenListe.get(x)).getAge();
            h = -0.1*TerrainPalette[i][j];
            
            if (s>=0.8){ s = 0.8;}
            
            fill(255,210,0);//Blumen Blaetter
            u = i+0.8; v = j+0.8;
            vertex( u-s, h, v+s); vertex( u-s, h, v-s); vertex( u+s, h, v-s); vertex( u+s, h, v+s);
            u = i+0.8; v = j-0.8;
            vertex( u-s, h, v+s); vertex( u-s, h, v-s); vertex( u+s, h, v-s); vertex( u+s, h, v+s);
            u = i-0.8; v = j-0.8;
            vertex( u-s, h, v+s); vertex( u-s, h, v-s); vertex( u+s, h, v-s); vertex( u+s, h, v+s);
            u = i-0.8; v = j+0.8;
            vertex( u-s, h, v+s); vertex( u-s, h, v-s); vertex( u+s, h, v-s); vertex( u+s, h, v+s);
            
            fill(255,0,0);  //Blumen Bluete
            h -= 0.01;
            vertex( i-s, h, j+s); vertex( i-s, h, j-s); vertex( i+s, h, j-s); vertex( i+s, h, j+s);
            
        }
        
        endShape();
        
        popMatrix();
    }
    
}