Chunkprovider

package northrend.world;

import net.minecraft.block.Block;
import net.minecraft.entity.EnumCreatureType;
import net.minecraft.init.Blocks;
import net.minecraft.util.IProgressUpdate;
import net.minecraft.world.ChunkPosition;
import net.minecraft.world.World;
import net.minecraft.world.chunk.Chunk;
import net.minecraft.world.chunk.IChunkProvider;
import northrend.biome.NBiomeGen;

import javax.vecmath.Vector2d;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class ChunkProviderNorthrend implements IChunkProvider
{
    World world;
    private List spawnList;
    Random dnc = new Random();

    public ChunkProviderNorthrend(World world) {
        this.world = world;
    }

    @Override
    public boolean chunkExists(int var1, int var2) {
        return true;
    }

    private byte[] getHillPeak(int chunkX, int chunkZ) {
        Random r = new Random(world.getSeed() + chunkX * 154 - chunkZ * 162);
        Random hillRandom = new Random(world.getSeed() *(chunkX / 7) * (chunkZ / 6));

        float extraHills = hillRandom.nextFloat();
        //boolean extraHills = f > .5f;

        byte x = (byte)r.nextInt(16);
        byte z = (byte)r.nextInt(16);
        byte height = (byte)((48 + 192 * extraHills) + r.nextInt((int)(5 + extraHills * 11)));
        byte hilly = (byte)((5 + 5 * extraHills) + r.nextInt((int)(5 + 5 * extraHills)));


        return new byte[] {x, z, height, hilly};
    }

    private double getDistance(byte[] a, byte[] b) {
        return Math.sqrt(Math.pow(a[0] - b[0], 2) + Math.pow(a[1] - b[1], 2));
    }

    private byte[] getClosestPeak(byte[][] peaks, int peakId) {
        double closestDistance = 50000;
        int closestPeak = -1;
        for(int j = 0; j < peaks.length; j++) {
            if(peakId != j) {
                int heightDiff = Math.abs(peaks[peakId][2] - peaks[j][2]);
                double distance = getDistance(peaks[peakId], peaks[j]);
                if(distance < closestDistance && distance > 10 && heightDiff < 3){
                    closestDistance = distance;
                    closestPeak = j;
                }
            }
        }
        if(closestPeak == -1)
            return null;
        return peaks[closestPeak];
    }

    private List<byte[]> generateCrests(byte[][] peaks) {
        List<byte[]> crestPeaks = new ArrayList<byte[]>();

        for(int i = 0; i < peaks.length; i++) {
            byte[] closestPeak = getClosestPeak(peaks, i);
            if(closestPeak == null)
                continue;
            int deltaX = peaks[i][0] - closestPeak[0];
            int deltaZ = peaks[i][1] - closestPeak[1];
            int deltaHeight = peaks[i][2] - closestPeak[2];

            int steps = Math.abs(deltaX);
            double stepSizeX = (double)deltaX / steps;
            double stepSizeZ = (double)deltaZ / steps;
            double stepSizeHeight = (double)deltaHeight / steps;
            for(int step = 0; step < steps; step++) {
                byte x = (byte)(peaks[i][0] + stepSizeX * step);
                byte y = (byte)(peaks[i][1] + stepSizeZ * step);
                byte height = (byte)(peaks[i][2] + stepSizeHeight * step);
                byte hillyness = peaks[i][3];

                byte[] arr = {x, y, height, hillyness};

                crestPeaks.add(arr);
            }
        }

        return crestPeaks;
    }

    private byte[][] getPeaks(int chunkX, int chunkZ) {
        int area = 7;
        byte[][] peaks = new byte[(int)Math.pow(area*2 + 1, 2)][];
        int i = 0;
        for(int x = - area; x <= area; x++){
            for(int z = - area; z <= area; z++){
                byte[] peak = getHillPeak(chunkX + x, chunkZ +  z);
                peak[0] += 16 * x;
                peak[1] += 16 * z;
                peaks[i] = peak;
                i++;
            }
        }

       List<byte[]> crests = generateCrests(peaks);

        byte[][] allPeaks = new byte[peaks.length + crests.size()][];

        for(int a = 0; a < peaks.length; a++){
            allPeaks[a] = peaks[a];
        }
        for(int b = 0; b < crests.size(); b++) {
            allPeaks[peaks.length +b] = crests.get(b);
        }

        return allPeaks;
    }

    @Override
    public Chunk provideChunk(int chunkX, int chunkZ) {
        Block[] blocks = new Block[16 * 16 * 256];

        byte[][] peaks = getPeaks(chunkX, chunkZ);

        for(int x = 0; x < 16; x ++) {
            for(int z = 0; z < 16; z ++) {
                byte[] here = new byte[] {(byte)x, (byte)z};

                int maxHeight = 0;

                for(int i = 0; i < peaks.length; i++){
                    double distance = getDistance(peaks[i], here);
                    double hillyness = (int)peaks[i][3] & 0xFF;
                    int hillHeight =  (int)peaks[i][2] &0xFF;
                    //int height = hillHeight - (int)(distance*distance * hillyness / 1000);
                    int height = hillHeight - (int)( distance *hillyness / 10);
                    if(height > maxHeight)
                        maxHeight = height;

                }

                for(int y = 0; y < 256; y++){
                    int block = x * 256 * 16 + z * 256 + y;
                    if(y < maxHeight)
                        blocks[block] = Blocks.stone;
                }
            }
        }

        byte[] metaData = new byte[65536];

        Chunk chunk = new Chunk(world, blocks, metaData, chunkX, chunkZ);
        chunk.generateSkylightMap();
        return chunk;
    }

    @Override
    public Chunk loadChunk(int x, int z) {
        return provideChunk(x, z);
    }

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

    }

    @Override
    public boolean saveChunks(boolean var1, IProgressUpdate var2) {
        return true;
    }

    @Override
    public boolean unloadQueuedChunks() {
        return false;
    }

    @Override
    public boolean canSave() {
        return false;
    }

    @Override
    public String makeString() {
        return "NorthendWorld";
    }

    @Override
    public List getPossibleCreatures(EnumCreatureType var1, int var2, int var3, int var4) {
        if (var1 == EnumCreatureType.creature){
            spawnList = NBiomeGen.biomeGenNorth.getSpawnableList(var1);
            return spawnList;
        }
        return null;
    }
    @Override
    public ChunkPosition func_147416_a(World var1, String var2, int var3, int var4, int var5) {
        return null;
    }

    @Override
    public int getLoadedChunkCount() {
        return 0;
    }

    @Override
    public void recreateStructures(int x, int z) {

    }

    @Override
    public void saveExtraData() {

    }
}