package net.minecraft.src;
import java.util.Random;

public class ChunkProviderFlatLand
implements IChunkProvider
{

	public ChunkProviderFlatLand(World world)
	{
		 worldObj = world;
		 Random = new Random();
		 noise1gen = new NoiseGeneratorOctaves(Random, 4);
	}


	public boolean chunkExists(int i, int j) {

		return true;
	}


	public Chunk provideChunk(int i, int j) {


		byte abyte0[] = new byte[32768];

        generateTerrain(i, j, abyte0);
        generatetop(abyte0);
        Chunk chunk = new Chunk(worldObj, abyte0, i, j);
        chunk.func_1024_c();
        return chunk;
	}
	public void generatetop(byte[] abyte0)
{
	  for(int k = 0; k < 16; k++)
      {
          for(int l = 0; l < 16; l++)
          {
        	  int j1 = 0;

          for(int k1 = 127; k1 >= 0; k1--)
          {
        	  int l1 = (l * 16 + k) * 128 + k1;
              byte byte2 = abyte0[l1];

              if(byte2 != Block.stone.blockID)
              {
            	  j1 = 0;
                  continue;
              }



                  if(j1 < 3)
                  {
                      abyte0[l1] = (byte)Block.dirt.blockID;;
                  }

                  if( j1 == 0)
                  {
                      abyte0[l1] = (byte)Block.grass.blockID;;
                  }



              j1++;
          }
          }
      }
}
	private void generateTerrain(int i, int j, byte[] abyte0) {
		 byte byte0 = 2;
	        int k = byte0 + 1;
	        byte byte1 = 33;
	        int l = byte0 + 1;
	        noisearray = GenerateNoise(noisearray, i * byte0, 0, j * byte0, k, byte1, l);
	        for(int i1 = 0; i1 < byte0; i1++)
	        {
	            for(int j1 = 0; j1 < byte0; j1++)
	            {
	                for(int k1 = 0; k1 < 32; k1++)
	                {
	                    double d = 0.25D;
	                    double d1 = noisearray[((i1 + 0) * l + (j1 + 0)) * byte1 + (k1 + 0)];
	                    double d2 = noisearray[((i1 + 0) * l + (j1 + 1)) * byte1 + (k1 + 0)];
	                    double d3 = noisearray[((i1 + 1) * l + (j1 + 0)) * byte1 + (k1 + 0)];
	                    double d4 = noisearray[((i1 + 1) * l + (j1 + 1)) * byte1 + (k1 + 0)];
	                    double d5 = (noisearray[((i1 + 0) * l + (j1 + 0)) * byte1 + (k1 + 1)] - d1) * d;
	                    double d6 = (noisearray[((i1 + 0) * l + (j1 + 1)) * byte1 + (k1 + 1)] - d2) * d;
	                    double d7 = (noisearray[((i1 + 1) * l + (j1 + 0)) * byte1 + (k1 + 1)] - d3) * d;
	                    double d8 = (noisearray[((i1 + 1) * l + (j1 + 1)) * byte1 + (k1 + 1)] - d4) * d;
	                    for(int l1 = 0; l1 < 4; l1++)
	                    {
	                        double d9 = 0.125D;
	                        double d10 = d1;
	                        double d11 = d2;
	                        double d12 = (d3 - d1) * d9;
	                        double d13 = (d4 - d2) * d9;
	                        for(int i2 = 0; i2 < 8; i2++)
	                        {
	                            int j2 = i2 + i1 * 8 << 11 | 0 + j1 * 8 << 7 | k1 * 4 + l1;
	                            char c = '\200';
	                            double d14 = 0.125D;
	                            double d15 = d10;
	                            double d16 = (d11 - d10) * d14;
	                            for(int k2 = 0; k2 < 8; k2++)
	                            {
	                                int l2 = 0;
	                                if(d15 > 0.2D)
	                                {
	                                    l2 = Block.stone.blockID;
	                                }
	                                abyte0[j2] = (byte)l2;
	                                j2 += c;
	                                d15 += d16;
	                            }

	                            d10 += d12;
	                            d11 += d13;
	                        }

	                        d1 += d5;
	                        d2 += d6;
	                        d3 += d7;
	                        d4 += d8;
	                    }

	                }

	            }

	        }
	}

	public Chunk prepareChunk(int i, int j) {
		  return provideChunk(i, j);
	}


	public void populate(IChunkProvider var1, int var2, int var3) {

	      int var6 = 0;
	      int var7;

	      for(var7 = 0; var7 < var6; ++var7) {
	         var7 = var6 + 8;
	         var6 = var7 + 4;
	         var6 = var7 + 8;
	         (new TestGenGlowstone()).generate(this.worldObj, Random, var7, var6, var7);
	      }
	}
	  private double[] GenerateNoise(double ad[], int i, int j, int k, int l, int i1, int j1)
	    {
	        if(ad == null)
	        {
	            ad = new double[l * i1 * j1];
	        }

	        noise1 = noise1gen.generateNoiseOctaves(noise1, i, j, k, l, i1, j1, 1D, 3D, 1D);


	        int k1 = 0;


	        for(int j2 = 0; j2 < l; j2++)
	        {

	            for(int l2 = 0; l2 < j1; l2++)
	            {

	                for(int j3 = 0; j3 < i1; j3++)
	                {
	                   if( j3 < 30)
	                   {


	                   }
	                	ad[k1] =noise1[k1];

	                    k1++;
	                }





	            }

	        }

	        return ad;
	    }

	public boolean saveChunks(boolean flag, IProgressUpdate iprogressupdate) {

		  return true;
	}


	public boolean unload100OldestChunks() {
	    return false;
	}


	public boolean canSave() {
		 return true;
	}


	public String makeString() {
		 return "RandomLevelSource";
	}
	private Random Random;

	 private double noisearray[];

	private World worldObj;

	double noise1[];
	private NoiseGeneratorOctaves noise1gen;

}