Что-то не так с измерением

[DJ_RTyTb]

Несколько дней пытаюсь создать измерение, но постоянно что-то идёт не так. Сейчас застрял на этой ошибке: java.lang.InstantiationException.
Кастомизацией измерения я, пока что, даже и не начинал заниматься, мне бы создать хоть что-то работающее... Поэтому весь код основан на ванильных/интернетных ресурсах. Пока что я хочу понять, как работают измерения (ну или хотя бы почему у меня ничего не работает).

WorldProvider:

public abstract class DarkRainbowWorldProvider extends WorldProvider{
   
    public void registerWorldChunkManager(){
        this.dimensionId = DimensionRegister.DRW_DIM_ID;
        this.worldChunkMgr = new WorldChunkManagerHell(BiomeGenBase.birchForest, 0.1F);
    }
   
    public IChunkProvider createChunkGenerator(){
        return new DarkRainbowChunkGenerator(this.worldObj, this.worldObj.getSeed() - 2067);
    }
}

Регистрация:

public class DimensionRegister
{
    public static void register()
    {
        registerDRWWorld();
    }

    public static int DRW_PROVIDER_ID = 41823;
    public static int DRW_DIM_ID = 41823;
    public static String DRW_DIM_NAME = "DarkRainbowDimantion";
    public static long DRW_DIM_SEED = 6637334307563055196L;

    public static void registerDRWWorld()
    {
        DimensionManager.registerProviderType(DRW_PROVIDER_ID, DarkRainbowWorldProvider.class, false);
        DimensionManager.registerDimension(DRW_DIM_ID, DRW_PROVIDER_ID);
    }
}

ChunkGenerator:

public class DarkRainbowChunkGenerator implements IChunkProvider{
   
    /** The biomes that are used to generate the chunk */
    private BiomeGenBase[] biomesForGeneration;

    double[] field_147427_d;
    double[] field_147428_e;
    double[] field_147425_f;
    double[] field_147426_g;
   
    private final float[] parabolicField;
   
    private WorldType field_147435_p;
   
    public NoiseGeneratorOctaves noiseGen6;
   
    private Random rand;
   
    private double[] stoneNoise = new double[256];
   
    /** Reference to the World object. */
    private World worldObj;
   
    /** Holds ravine generator */
    private MapGenBase ravineGenerator = new MapGenRavine();
    private MapGenBase caveGenerator = new MapGenCaves();
    private MapGenScatteredFeature scatteredFeatureGenerator = new MapGenScatteredFeature();


    private NoiseGeneratorOctaves field_147431_j;
    private NoiseGeneratorOctaves field_147432_k;
    private NoiseGeneratorOctaves field_147429_l;
    private NoiseGeneratorPerlin field_147430_m;

    private final double[] field_147434_q;
   
    public DarkRainbowChunkGenerator(World world, long l/[I], boolean bool[/I]/){
        super();
        this.worldObj = world;
        //this.mapFeaturesEnabled = bool;
        this.field_147435_p = world.getWorldInfo().getTerrainType();
        this.rand = new Random(l);
        this.field_147431_j = new NoiseGeneratorOctaves(this.rand, 16);
        this.field_147432_k = new NoiseGeneratorOctaves(this.rand, 16);
        this.field_147429_l = new NoiseGeneratorOctaves(this.rand, 8);
        this.field_147430_m = new NoiseGeneratorPerlin(this.rand, 4);
        //this.noiseGen5 = new NoiseGeneratorOctaves(this.rand, 10);
        this.noiseGen6 = new NoiseGeneratorOctaves(this.rand, 16);
        //this.mobSpawnerNoise = new NoiseGeneratorOctaves(this.rand, 8);
        this.field_147434_q = new double[825];
        this.parabolicField = new float[25];

        for (int var5 = -2; var5 <= 2; ++var5)
        {
            for (int var6 = -2; var6 <= 2; ++var6)
            {
                float var7 = 10.0F / MathHelper.sqrt_float((float)(var5 * var5 + var6 * var6) + 0.2F);
                this.parabolicField[var5 + 2 + (var6 + 2) * 5] = var7;
            }
        }
    }

    /**
     * Checks to see if a chunk exists at x, y
     */
    public boolean chunkExists(int p_73149_1_, int p_73149_2_)
    {
        return true;
    }

    /**
     * Will return back a chunk, if it doesn't exist and its not a MP client it will generates all the blocks for the
     * specified chunk from the map seed and chunk seed
     */
    public Chunk provideChunk(int p_73154_1_, int p_73154_2_)
    {
        this.rand.setSeed((long)p_73154_1_ * 341873128712L + (long)p_73154_2_ * 132897987541L);
        Block[] var3 = new Block[65536];
        byte[] var4 = new byte[65536];
        this.func_147424_a(p_73154_1_, p_73154_2_, var3);
        this.biomesForGeneration = this.worldObj.getWorldChunkManager().loadBlockGeneratorData(this.biomesForGeneration, p_73154_1_ * 16, p_73154_2_ * 16, 16, 16);
        this.func_147422_a(p_73154_1_, p_73154_2_, var3, var4, this.biomesForGeneration);
        this.caveGenerator.func_151539_a(this, this.worldObj, p_73154_1_, p_73154_2_, var3);
        this.ravineGenerator.func_151539_a(this, this.worldObj, p_73154_1_, p_73154_2_, var3);

        /*if (this.mapFeaturesEnabled)
        {
            this.mineshaftGenerator.func_151539_a(this, this.worldObj, p_73154_1_, p_73154_2_, var3);
            this.villageGenerator.func_151539_a(this, this.worldObj, p_73154_1_, p_73154_2_, var3);
            this.strongholdGenerator.func_151539_a(this, this.worldObj, p_73154_1_, p_73154_2_, var3);
            this.scatteredFeatureGenerator.func_151539_a(this, this.worldObj, p_73154_1_, p_73154_2_, var3);
        }*/

        Chunk var5 = new Chunk(this.worldObj, var3, var4, p_73154_1_, p_73154_2_);
        byte[] var6 = var5.getBiomeArray();

        for (int var7 = 0; var7 < var6.length; ++var7)
        {
            var6[var7] = (byte)this.biomesForGeneration[var7].biomeID;
        }

        var5.generateSkylightMap();
        return var5;
    }
   
    public void func_147424_a(int p_147424_1_, int p_147424_2_, Block[] p_147424_3_)
    {
        byte var4 = 63;
        this.biomesForGeneration = this.worldObj.getWorldChunkManager().getBiomesForGeneration(this.biomesForGeneration, p_147424_1_ * 4 - 2, p_147424_2_ * 4 - 2, 10, 10);
        this.func_147423_a(p_147424_1_ * 4, 0, p_147424_2_ * 4);

        for (int var5 = 0; var5 < 4; ++var5)
        {
            int var6 = var5 * 5;
            int var7 = (var5 + 1) * 5;

            for (int var8 = 0; var8 < 4; ++var8)
            {
                int var9 = (var6 + var8) * 33;
                int var10 = (var6 + var8 + 1) * 33;
                int var11 = (var7 + var8) * 33;
                int var12 = (var7 + var8 + 1) * 33;

                for (int var13 = 0; var13 < 32; ++var13)
                {
                    double var14 = 0.125D;
                    double var16 = this.field_147434_q[var9 + var13];
                    double var18 = this.field_147434_q[var10 + var13];
                    double var20 = this.field_147434_q[var11 + var13];
                    double var22 = this.field_147434_q[var12 + var13];
                    double var24 = (this.field_147434_q[var9 + var13 + 1] - var16) * var14;
                    double var26 = (this.field_147434_q[var10 + var13 + 1] - var18) * var14;
                    double var28 = (this.field_147434_q[var11 + var13 + 1] - var20) * var14;
                    double var30 = (this.field_147434_q[var12 + var13 + 1] - var22) * var14;

                    for (int var32 = 0; var32 < 8; ++var32)
                    {
                        double var33 = 0.25D;
                        double var35 = var16;
                        double var37 = var18;
                        double var39 = (var20 - var16) * var33;
                        double var41 = (var22 - var18) * var33;

                        for (int var43 = 0; var43 < 4; ++var43)
                        {
                            int var44 = var43 + var5 * 4 << 12 | 0 + var8 * 4 << 8 | var13 * 8 + var32;
                            short var45 = 256;
                            var44 -= var45;
                            double var46 = 0.25D;
                            double var50 = (var37 - var35) * var46;
                            double var48 = var35 - var50;

                            for (int var52 = 0; var52 < 4; ++var52)
                            {
                                if ((var48 += var50) > 0.0D)
                                {
                                    p_147424_3_[var44 += var45] = Blocks.stone;
                                }
                                else if (var13 * 8 + var32 < var4)
                                {
                                    p_147424_3_[var44 += var45] = Blocks.water;
                                }
                                else
                                {
                                    p_147424_3_[var44 += var45] = null;
                                }
                            }

                            var35 += var39;
                            var37 += var41;
                        }

                        var16 += var24;
                        var18 += var26;
                        var20 += var28;
                        var22 += var30;
                    }
                }
            }
        }
    }
   
    private void func_147423_a(int p_147423_1_, int p_147423_2_, int p_147423_3_)
    {
        double var4 = 684.412D;
        double var6 = 684.412D;
        double var8 = 512.0D;
        double var10 = 512.0D;
        this.field_147426_g = this.noiseGen6.generateNoiseOctaves(this.field_147426_g, p_147423_1_, p_147423_3_, 5, 5, 200.0D, 200.0D, 0.5D);
        this.field_147427_d = this.field_147429_l.generateNoiseOctaves(this.field_147427_d, p_147423_1_, p_147423_2_, p_147423_3_, 5, 33, 5, 8.555150000000001D, 4.277575000000001D, 8.555150000000001D);
        this.field_147428_e = this.field_147431_j.generateNoiseOctaves(this.field_147428_e, p_147423_1_, p_147423_2_, p_147423_3_, 5, 33, 5, 684.412D, 684.412D, 684.412D);
        this.field_147425_f = this.field_147432_k.generateNoiseOctaves(this.field_147425_f, p_147423_1_, p_147423_2_, p_147423_3_, 5, 33, 5, 684.412D, 684.412D, 684.412D);
        boolean var45 = false;
        boolean var44 = false;
        int var12 = 0;
        int var13 = 0;
        double var14 = 8.5D;

        for (int var16 = 0; var16 < 5; ++var16)
        {
            for (int var17 = 0; var17 < 5; ++var17)
            {
                float var18 = 0.0F;
                float var19 = 0.0F;
                float var20 = 0.0F;
                byte var21 = 2;
                BiomeGenBase var22 = this.biomesForGeneration[var16 + 2 + (var17 + 2) * 10];

                for (int var23 = -var21; var23 <= var21; ++var23)
                {
                    for (int var24 = -var21; var24 <= var21; ++var24)
                    {
                        BiomeGenBase var25 = this.biomesForGeneration[var16 + var23 + 2 + (var17 + var24 + 2) * 10];
                        float var26 = var25.rootHeight;
                        float var27 = var25.heightVariation;

                        /*if (this.field_147435_p == WorldType.field_151360_e && var26 > 0.0F)
                        {
                            var26 = 1.0F + var26 * 2.0F;
                            var27 = 1.0F + var27 * 4.0F;
                        }*/

                        float var28 = this.parabolicField[var23 + 2 + (var24 + 2) * 5] / (var26 + 2.0F);

                        if (var25.rootHeight > var22.rootHeight)
                        {
                            var28 /= 2.0F;
                        }

                        var18 += var27 * var28;
                        var19 += var26 * var28;
                        var20 += var28;
                    }
                }

                var18 /= var20;
                var19 /= var20;
                var18 = var18 * 0.9F + 0.1F;
                var19 = (var19 * 4.0F - 1.0F) / 8.0F;
                double var46 = this.field_147426_g[var13] / 8000.0D;

                if (var46 < 0.0D)
                {
                    var46 = -var46 * 0.3D;
                }

                var46 = var46 * 3.0D - 2.0D;

                if (var46 < 0.0D)
                {
                    var46 /= 2.0D;

                    if (var46 < -1.0D)
                    {
                        var46 = -1.0D;
                    }

                    var46 /= 1.4D;
                    var46 /= 2.0D;
                }
                else
                {
                    if (var46 > 1.0D)
                    {
                        var46 = 1.0D;
                    }

                    var46 /= 8.0D;
                }

                ++var13;
                double var47 = (double)var19;
                double var48 = (double)var18;
                var47 += var46 * 0.2D;
                var47 = var47 * 8.5D / 8.0D;
                double var29 = 8.5D + var47 * 4.0D;

                for (int var31 = 0; var31 < 33; ++var31)
                {
                    double var32 = ((double)var31 - var29) * 12.0D * 128.0D / 256.0D / var48;

                    if (var32 < 0.0D)
                    {
                        var32 *= 4.0D;
                    }

                    double var34 = this.field_147428_e[var12] / 512.0D;
                    double var36 = this.field_147425_f[var12] / 512.0D;
                    double var38 = (this.field_147427_d[var12] / 10.0D + 1.0D) / 2.0D;
                    double var40 = MathHelper.denormalizeClamp(var34, var36, var38) - var32;

                    if (var31 > 29)
                    {
                        double var42 = (double)((float)(var31 - 29) / 3.0F);
                        var40 = var40 * (1.0D - var42) + -10.0D * var42;
                    }

                    this.field_147434_q[var12] = var40;
                    ++var12;
                }
            }
        }
    }
   
    public void func_147422_a(int p_147422_1_, int p_147422_2_, Block[] p_147422_3_, byte[] p_147422_4_, BiomeGenBase[] p_147422_5_)
    {
        double var6 = 0.03125D;
        this.stoneNoise = this.field_147430_m.func_151599_a(this.stoneNoise, (double)(p_147422_1_ * 16), (double)(p_147422_2_ * 16), 16, 16, var6 * 2.0D, var6 * 2.0D, 1.0D);

        for (int var8 = 0; var8 < 16; ++var8)
        {
            for (int var9 = 0; var9 < 16; ++var9)
            {
                BiomeGenBase var10 = p_147422_5_[var9 + var8 * 16];
                var10.genTerrainBlocks(this.worldObj, this.rand, p_147422_3_, p_147422_4_, p_147422_1_ * 16 + var8, p_147422_2_ * 16 + var9, this.stoneNoise[var9 + var8 * 16]);
                //var10.func_150573_a(this.worldObj, this.rand, p_147422_3_, p_147422_4_, p_147422_1_ * 16 + var8, p_147422_2_ * 16 + var9, this.stoneNoise[var9 + var8 * 16]);
               
            }
        }
    }

    /**
     * loads or generates the chunk at the chunk location specified
     */
    public Chunk loadChunk(int p_73158_1_, int p_73158_2_)
    {
        return this.provideChunk(p_73158_1_, p_73158_2_);
    }

    /**
     * Populates chunk with ores etc etc
     */
    public void populate(IChunkProvider p_73153_1_, int p_73153_2_, int p_73153_3_)
    {
        BlockFalling.fallInstantly = true;
        int var4 = p_73153_2_ * 16;
        int var5 = p_73153_3_ * 16;
        BiomeGenBase var6 = this.worldObj.getBiomeGenForCoords(var4 + 16, var5 + 16);
        this.rand.setSeed(this.worldObj.getSeed());
        long var7 = this.rand.nextLong() / 2L * 2L + 1L;
        long var9 = this.rand.nextLong() / 2L * 2L + 1L;
        this.rand.setSeed((long)p_73153_2_ * var7 + (long)p_73153_3_ * var9 ^ this.worldObj.getSeed());
        boolean var11 = false;

        /*if (this.mapFeaturesEnabled)
        {
            this.mineshaftGenerator.generateStructuresInChunk(this.worldObj, this.rand, p_73153_2_, p_73153_3_);
            var11 = this.villageGenerator.generateStructuresInChunk(this.worldObj, this.rand, p_73153_2_, p_73153_3_);
            this.strongholdGenerator.generateStructuresInChunk(this.worldObj, this.rand, p_73153_2_, p_73153_3_);
            this.scatteredFeatureGenerator.generateStructuresInChunk(this.worldObj, this.rand, p_73153_2_, p_73153_3_);
        }*/

        int var12;
        int var13;
        int var14;

        if (var6 != BiomeGenBase.desert && var6 != BiomeGenBase.desertHills && !var11 && this.rand.nextInt(4) == 0)
        {
            var12 = var4 + this.rand.nextInt(16) + 8;
            var13 = this.rand.nextInt(256);
            var14 = var5 + this.rand.nextInt(16) + 8;
            (new WorldGenLakes(Blocks.water)).generate(this.worldObj, this.rand, var12, var13, var14);
        }

        if (!var11 && this.rand.nextInt(8) == 0)
        {
            var12 = var4 + this.rand.nextInt(16) + 8;
            var13 = this.rand.nextInt(this.rand.nextInt(248) + 8);
            var14 = var5 + this.rand.nextInt(16) + 8;

            if (var13 < 63 || this.rand.nextInt(10) == 0)
            {
                (new WorldGenLakes(Blocks.lava)).generate(this.worldObj, this.rand, var12, var13, var14);
            }
        }

        for (var12 = 0; var12 < 8; ++var12)
        {
            var13 = var4 + this.rand.nextInt(16) + 8;
            var14 = this.rand.nextInt(256);
            int var15 = var5 + this.rand.nextInt(16) + 8;
            (new WorldGenDungeons()).generate(this.worldObj, this.rand, var13, var14, var15);
        }

        var6.decorate(this.worldObj, this.rand, var4, var5);
        SpawnerAnimals.performWorldGenSpawning(this.worldObj, var6, var4 + 8, var5 + 8, 16, 16, this.rand);
        var4 += 8;
        var5 += 8;

        for (var12 = 0; var12 < 16; ++var12)
        {
            for (var13 = 0; var13 < 16; ++var13)
            {
                var14 = this.worldObj.getPrecipitationHeight(var4 + var12, var5 + var13);

                if (this.worldObj.isBlockFreezable(var12 + var4, var14 - 1, var13 + var5))
                {
                    this.worldObj.setBlock(var12 + var4, var14 - 1, var13 + var5, Blocks.ice, 0, 2);
                }

                if (this.worldObj.func_147478_e(var12 + var4, var14, var13 + var5, true))
                {
                    this.worldObj.setBlock(var12 + var4, var14, var13 + var5, Blocks.snow_layer, 0, 2);
                }
            }
        }

        BlockFalling.fallInstantly = false;
    }

    /**
     * Two modes of operation: if passed true, save all Chunks in one go.  If passed false, save up to two chunks.
     * Return true if all chunks have been saved.
     */
    public boolean saveChunks(boolean p_73151_1_, IProgressUpdate p_73151_2_)
    {
        return true;
    }

    /**
     * Unloads chunks that are marked to be unloaded. This is not guaranteed to unload every such chunk.
     */
    public boolean unloadQueuedChunks()
    {
        return false;
    }

    /**
     * Returns if the IChunkProvider supports saving.
     */
    public boolean canSave()
    {
        return true;
    }

    /**
     * Converts the instance data to a readable string.
     */
    public String makeString()
    {
        return "RandomLevelSource";
    }

    /**
     * Returns a list of creatures of the specified type that can spawn at the given location.
     */
    public List getPossibleCreatures(EnumCreatureType p_73155_1_, int p_73155_2_, int p_73155_3_, int p_73155_4_)
    {
        BiomeGenBase var5 = this.worldObj.getBiomeGenForCoords(p_73155_2_, p_73155_4_);
        return p_73155_1_ == EnumCreatureType.monster && this.scatteredFeatureGenerator.func_143030_a(p_73155_2_, p_73155_3_, p_73155_4_) ? this.scatteredFeatureGenerator.getScatteredFeatureSpawnList() : var5.getSpawnableList(p_73155_1_);
    }

    public ChunkPosition func_147416_a(World p_147416_1_, String p_147416_2_, int p_147416_3_, int p_147416_4_, int p_147416_5_)
    {
        return /*"Stronghold".equals(p_147416_2_) && this.strongholdGenerator != null ? this.strongholdGenerator.func_151545_a(p_147416_1_, p_147416_3_, p_147416_4_, p_147416_5_) : */null;
    }

    public int getLoadedChunkCount()
    {
        return 0;
    }

    public void recreateStructures(int p_82695_1_, int p_82695_2_)
    {
        /*if (this.mapFeaturesEnabled)
        {
            this.mineshaftGenerator.func_151539_a(this, this.worldObj, p_82695_1_, p_82695_2_, (Block[])null);
            this.villageGenerator.func_151539_a(this, this.worldObj, p_82695_1_, p_82695_2_, (Block[])null);
            this.strongholdGenerator.func_151539_a(this, this.worldObj, p_82695_1_, p_82695_2_, (Block[])null);
            this.scatteredFeatureGenerator.func_151539_a(this, this.worldObj, p_82695_1_, p_82695_2_, (Block[])null);
        }*/
    }

    /**
     * Save extra data not associated with any Chunk.  Not saved during autosave, only during world unload.  Currently
     * unimplemented.
     */
    public void saveExtraData() {}

}

 

[Liahim]

Может быть не нужно ворлд провайдер абстрактным делать?
Поэтому он и не может создать экземпляр.
Я так думаю.

 

[DJ_RTyTb]

Дааааа, точно! Спасибо, сам я до этого не додумался)