tcr/server/src/main/java/server/worldgen/replacer/ReplacerMesa.java

package server.worldgen.replacer;

import java.util.Arrays;

import common.block.natural.BlockColoredClay;
import common.dimension.Dimension;
import common.init.Blocks;
import common.rng.Random;
import common.world.State;
import server.dimension.GeneratorData;
import server.rng.PerlinGen;
import server.world.WorldServer;
import server.worldgen.ChunkPrimer;

public class ReplacerMesa extends ReplacerBiome
{
    private final State[] layers;
    private PerlinGen baseBryceGen;
    private PerlinGen highBryceGen;
    private PerlinGen clayColorGen;
    private PerlinGen soilGen;
    private PerlinGen peakGen;
    private final State surface;
    
    public ReplacerMesa(State surface) {
        this.layers = new State[64];
        Arrays.fill(this.layers, Blocks.hardened_clay.getState());
        this.surface = surface;
	}
    
    public State getTop() {
		return Blocks.dirt.getState();
	}
    
    public State getSurface() {
		return this.surface;
	}

	public void init(Random rand, Dimension dim, GeneratorData gen) {
		super.init(rand, dim, gen);
        this.clayColorGen = new PerlinGen(rand, 1);
        this.baseBryceGen = new PerlinGen(rand, 4);
        this.highBryceGen = new PerlinGen(rand, 1);
        this.soilGen = new PerlinGen(rand, 8);
        this.peakGen = new PerlinGen(rand, 8);
        this.setupLayers(rand);
	}

    private State getBlockAt(int x, int y, int z)
    {
        int i = (int)Math.round(this.clayColorGen.generate((double)x * 1.0D / 512.0D, (double)x * 1.0D / 512.0D) * 2.0D);
        return this.layers[(y + i + 64) % 64];
    }

    public void genTerrainBlocks(WorldServer world, Random rand, ChunkPrimer primer, int x, int z, double noise)
    {
        boolean soil = this.soilGen.generate((double)((x & ~15) | (z & 15)) * 0.5D, (double)((z & ~15) | (x & 15)) * 0.5D) > 0.1;
    	boolean peak = this.peakGen.generate((double)((x & ~15) | (z & 15)) * 0.5D, (double)((z & ~15) | (x & 15)) * 0.5D) > 0.1;
        
        double d4 = 0.0D;

        if (peak)
        {
            int i = (x & -16) + (z & 15);
            int j = (z & -16) + (x & 15);
            double d0 = Math.min(Math.abs(noise), this.baseBryceGen.generate((double)i * 0.25D, (double)j * 0.25D));

            if (d0 > 0.0D)
            {
                double d1 = 0.001953125D;
                double d2 = Math.abs(this.highBryceGen.generate((double)i * d1, (double)j * d1));
                d4 = d0 * d0 * 2.5D;
                double d3 = Math.ceil(d2 * 50.0D) + 14.0D;

                if (d4 > d3)
                {
                    d4 = d3;
                }

                d4 = d4 + 64.0D;
            }
        }

        int bx = x & 15;
        int by = z & 15;
        State surface = Blocks.beige_clay.getState();
        State top = Blocks.beige_clay.getState();
        int rng = (int)(noise / 3.0D + 3.0D + rand.doublev() * 0.25D);
        boolean hard = Math.cos(noise / 3.0D * Math.PI) > 0.0D;
        int sel = -1;
        boolean base = false;

        for (int i1 = primer.height - 1; i1 >= 0; --i1)
        {
            if (primer.get(by, i1, bx).getBlock() == Blocks.air && i1 < (int)d4)
            {
                primer.set(by, i1, bx, this.filler);
            }

            State iblockstate1 = primer.get(by, i1, bx);

            if (iblockstate1.getBlock() == Blocks.air)
            {
                sel = -1;
            }
            else if (iblockstate1.getBlock() == this.fillerBlock)
            {
                if (sel == -1)
                {
                    base = false;

                    if (rng <= 0)
                    {
                        surface = null;
                        top = this.filler;
                    }
                    else if (i1 >= this.seaLevel - 4 && i1 <= this.seaLevel + 1)
                    {
                        surface = Blocks.beige_clay.getState();
                        top = Blocks.beige_clay.getState();
                    }

                    if (i1 < this.seaLevel && (surface == null || surface.getBlock() == Blocks.air))
                    {
                        surface = this.liquid;
                    }

                    sel = rng + Math.max(0, i1 - this.seaLevel);

                    if (i1 < this.seaLevel - 1)
                    {
                        primer.set(by, i1, bx, top);

                        if (top.getBlock() instanceof BlockColoredClay)
                        {
                            primer.set(by, i1, bx, Blocks.light_brown_clay.getState());
                        }
                    }
                    else if (soil && i1 > 86 + rng * 2)
                    {
                        if (hard)
                        {
                            primer.set(by, i1, bx, Blocks.coarse_dirt.getState());
                        }
                        else
                        {
                            primer.set(by, i1, bx, Blocks.dirt.getState());
                        }
                    }
                    else if (i1 <= this.seaLevel + 3 + rng)
                    {
                        primer.set(by, i1, bx, this.surface);
                        base = true;
                    }
                    else
                    {
                        State iblockstate4;

                        if (i1 >= 64 && i1 <= 127)
                        {
                            if (hard)
                            {
                                iblockstate4 = Blocks.hardened_clay.getState();
                            }
                            else
                            {
                                iblockstate4 = this.getBlockAt(x, i1, z);
                            }
                        }
                        else
                        {
                            iblockstate4 = Blocks.light_brown_clay.getState();
                        }

                        primer.set(by, i1, bx, iblockstate4);
                    }
                }
                else if (sel > 0)
                {
                    --sel;

                    if (base)
                    {
                        primer.set(by, i1, bx, Blocks.light_brown_clay.getState());
                    }
                    else
                    {
                        State iblockstate2 = this.getBlockAt(x, i1, z);
                        primer.set(by, i1, bx, iblockstate2);
                    }
                }
            }
        }
    }

    private void setupLayers(Random random)
    {
        for (int l1 = 0; l1 < 64; ++l1)
        {
            l1 += random.roll(5);

            if (l1 < 64)
            {
                this.layers[l1] = Blocks.light_brown_clay.getState();
            }
        }

        int i2 = random.range(2, 5);

        for (int i = 0; i < i2; ++i)
        {
            int j = random.roll(3);
            int k = random.zrange(64);

            for (int l = 0; k + l < 64 && l < j; ++l)
            {
                this.layers[k + l] = Blocks.white_clay.getState();
            }
        }

        int j2 = random.range(2, 5);

        for (int k2 = 0; k2 < j2; ++k2)
        {
            int i3 = random.range(2, 4);
            int l3 = random.zrange(64);

            for (int i1 = 0; l3 + i1 < 64 && i1 < i3; ++i1)
            {
                this.layers[l3 + i1] = Blocks.dark_brown_clay.getState();
            }
        }

        int l2 = random.range(2, 5);

        for (int j3 = 0; j3 < l2; ++j3)
        {
            int i4 = random.roll(3);
            int k4 = random.zrange(64);

            for (int j1 = 0; k4 + j1 < 64 && j1 < i4; ++j1)
            {
                this.layers[k4 + j1] = Blocks.dark_red_clay.getState();
            }
        }

        int k3 = random.range(3, 5);
        int j4 = 0;

        for (int l4 = 0; l4 < k3; ++l4)
        {
            int i5 = 1;
            j4 += random.range(4, 19);

            for (int k1 = 0; j4 + k1 < 64 && k1 < i5; ++k1)
            {
                this.layers[j4 + k1] = Blocks.beige_clay.getState();

                if (j4 + k1 > 1 && random.chance())
                {
                    this.layers[j4 + k1 - 1] = Blocks.light_gray_clay.getState();
                }

                if (j4 + k1 < 63 && random.chance())
                {
                    this.layers[j4 + k1 + 1] = Blocks.light_gray_clay.getState();
                }
            }
        }
    }
}