[1.7.10] Island World Generator

[Raiza]

Hello everyone, so for the past couple of days I have endeavored on studying how minecraft's world generation occurs and how I can tweak it to my liking. I'm working on a mod that will generate(does not have to be 100%, but most of the time), a world that is entirely an ocean biome. However, I can't seem to achieve this and I'm stuck at whether I can acheive just editing the files that produce the chunks or if I'm going to completely have to restructure biomes and how they generate.

 

Here are some samples of my code, if anyone could provide me with ideas or ways that I could achieve my goal it would be much appreciated.

 

IslandWorldGen Class

 

public class Islandworldgen extends WorldType{

 

public Islandworldgen(int par1, String par2Str) {

 

super(par1, par2Str);

this.addNewBiome(BiomeGenBase.ocean);

 

 

}

 

@Override

public WorldChunkManager getChunkManager(World world) {

 

return new IslandWorldChunkManager(world);

 

}

 

@Override

public IChunkProvider getChunkGenerator(World world, String generatorOptions) {

 

return new IslandWorldChunkProvider(world);

       

}

 

 

 

    //Get spawn coords for player

@Override

public int getSpawnFuzz() {

 

    return 100;

       

}

 

}

 

 

IslandWorldChunkManager

 

public class IslandWorldChunkManager extends WorldChunkManager {

 

public static ArrayList<BiomeGenBase> allowedBiomes = new ArrayList<BiomeGenBase>(Arrays.asList(BiomeGenBase.ocean,BiomeGenBase.beach));

private GenLayer genBiomes;

private World world;

private List biomesToSpawnIn;

private GenLayer biomeIndexLayer;

private BiomeCache biomeCache;

 

protected IslandWorldChunkManager() {

 

this.biomeCache = new BiomeCache(this);

this.biomesToSpawnIn = new ArrayList();

this.biomesToSpawnIn.addAll(allowedBiomes);

 

}

 

public IslandWorldChunkManager(long par1, WorldType par3WorldType) {

 

this();

        GenLayer[] agenlayer = GenLayer.initializeAllBiomeGenerators(par1, par3WorldType);

        agenlayer = getModdedBiomeGenerators(par3WorldType, par1, agenlayer);

        this.genBiomes = agenlayer[0];

        this.biomeIndexLayer = agenlayer[1];

 

}

 

public IslandWorldChunkManager(World par1World)

    {

        this(par1World.getSeed(), par1World.getWorldInfo().getTerrainType());

    }

 

 

public List getBiomesToSpawnIn() {

 

return this.biomesToSpawnIn;

 

}

 

public BiomeGenBase getBiomeGenAt(int x, int z) {

 

return this.biomeCache.getBiomeGenAt(x, z);

       

    }

 

 

public float[] getRainfall(float[] par1ArrayOfFloat, int par2, int par3, int par4, int par5)

    {

        IntCache.resetIntCache();

 

        if (par1ArrayOfFloat == null || par1ArrayOfFloat.length < par4 * par5)

        {

            par1ArrayOfFloat = new float[par4 * par5];

        }

 

        int[] aint = this.biomeIndexLayer.getInts(par2, par3, par4, par5);

 

        for (int i1 = 0; i1 < par4 * par5; ++i1)

        {

            float f = (float)BiomeGenBase.biomeList[aint[i1]].getIntRainfall() / 65536.0F;

 

            if (f > 1.0F)

            {

                f = 1.0F;

            }

 

            par1ArrayOfFloat[i1] = f;

        }

 

        return par1ArrayOfFloat;

    }

 

 

@SideOnly(Side.CLIENT)

 

    /**

    * Return an adjusted version of a given temperature based on the y height

    */

    public float getTemperatureAtHeight(float par1, int par2)

    {

        return par1;

    }

 

    /**

    * Returns a list of temperatures to use for the specified blocks.  Args: listToReuse, x, y, width, length

    */

    public float[] getTemperatures(float[] par1ArrayOfFloat, int par2, int par3, int par4, int par5)

    {

        IntCache.resetIntCache();

 

        if (par1ArrayOfFloat == null || par1ArrayOfFloat.length < par4 * par5)

        {

            par1ArrayOfFloat = new float[par4 * par5];

        }

 

        int[] aint = this.biomeIndexLayer.getInts(par2, par3, par4, par5);

 

        for (int i1 = 0; i1 < par4 * par5; ++i1)

        {

            float f = (float)BiomeGenBase.biomeList[aint[i1]].getIntTemperature() / 65536.0F;

 

            if (f > 1.0F)

            {

                f = 1.0F;

            }

 

            par1ArrayOfFloat[i1] = f;

        }

 

        return par1ArrayOfFloat;

    }

 

    /**

    * Returns an array of biomes for the location input.

    */

    public BiomeGenBase[] getBiomesForGeneration(BiomeGenBase[] par1ArrayOfBiomeGenBase, int par2, int par3, int par4, int par5)

    {

        IntCache.resetIntCache();

 

        if (par1ArrayOfBiomeGenBase == null || par1ArrayOfBiomeGenBase.length < par4 * par5)

        {

            par1ArrayOfBiomeGenBase = new BiomeGenBase[par4 * par5];

        }

 

        int[] aint = this.genBiomes.getInts(par2, par3, par4, par5);

 

        for (int i1 = 0; i1 < par4 * par5; ++i1)

        {

            par1ArrayOfBiomeGenBase[i1] = BiomeGenBase.biomeList[aint[i1]];

        }

 

        return par1ArrayOfBiomeGenBase;

    }

 

    /**

    * Returns biomes to use for the blocks and loads the other data like temperature and humidity onto the

    * WorldChunkManager Args: oldBiomeList, x, z, width, depth

    */

    public BiomeGenBase[] loadBlockGeneratorData(BiomeGenBase[] par1ArrayOfBiomeGenBase, int par2, int par3, int par4, int par5)

    {

        return this.getBiomeGenAt(par1ArrayOfBiomeGenBase, par2, par3, par4, par5, true);

    }

 

    /**

    * Return a list of biomes for the specified blocks. Args: listToReuse, x, y, width, length, cacheFlag (if false,

    * don't check biomeCache to avoid infinite loop in BiomeCacheBlock)

    */

    public BiomeGenBase[] getBiomeGenAt(BiomeGenBase[] par1ArrayOfBiomeGenBase, int par2, int par3, int par4, int par5, boolean par6)

    {

        IntCache.resetIntCache();

 

        if (par1ArrayOfBiomeGenBase == null || par1ArrayOfBiomeGenBase.length < par4 * par5)

        {

            par1ArrayOfBiomeGenBase = new BiomeGenBase[par4 * par5];

        }

 

        if (par6 && par4 == 16 && par5 == 16 && (par2 & 15) == 0 && (par3 & 15) == 0)

        {

            BiomeGenBase[] abiomegenbase1 = this.biomeCache.getCachedBiomes(par2, par3);

            System.arraycopy(abiomegenbase1, 0, par1ArrayOfBiomeGenBase, 0, par4 * par5);

            return par1ArrayOfBiomeGenBase;

        }

        else

        {

            int[] aint = this.biomeIndexLayer.getInts(par2, par3, par4, par5);

 

            for (int i1 = 0; i1 < par4 * par5; ++i1)

            {

                par1ArrayOfBiomeGenBase[i1] = BiomeGenBase.biomeList[aint[i1]];

            }

 

            return par1ArrayOfBiomeGenBase;

        }

    }

 

    /**

    * checks given Chunk's Biomes against List of allowed ones

    */

    public boolean areBiomesViable(int par1, int par2, int par3, List par4List)

    {

        IntCache.resetIntCache();

        int l = par1 - par3 >> 2;

        int i1 = par2 - par3 >> 2;

        int j1 = par1 + par3 >> 2;

        int k1 = par2 + par3 >> 2;

        int l1 = j1 - l + 1;

        int i2 = k1 - i1 + 1;

        int[] aint = this.genBiomes.getInts(l, i1, l1, i2);

 

        for (int j2 = 0; j2 < l1 * i2; ++j2)

        {

            BiomeGenBase biomegenbase = BiomeGenBase.biomeList[aint[j2]];

 

            if (!par4List.contains(biomegenbase))

            {

                return false;

            }

        }

 

        return true;

    }

 

    /**

    * Finds a valid position within a range, that is in one of the listed biomes. Searches {par1,par2} +-par3 blocks.

    * Strongly favors positive y positions.

    */

    public ChunkPosition findBiomePosition(int par1, int par2, int par3, List par4List, Random par5Random)

    {

        IntCache.resetIntCache();

        int l = par1 - par3 >> 2;

        int i1 = par2 - par3 >> 2;

        int j1 = par1 + par3 >> 2;

        int k1 = par2 + par3 >> 2;

        int l1 = j1 - l + 1;

        int i2 = k1 - i1 + 1;

        int[] aint = this.genBiomes.getInts(l, i1, l1, i2);

        ChunkPosition chunkposition = null;

        int j2 = 0;

 

        for (int k2 = 0; k2 < l1 * i2; ++k2)

        {

            int l2 = l + k2 % l1 << 2;

            int i3 = i1 + k2 / l1 << 2;

            BiomeGenBase biomegenbase = BiomeGenBase.biomeList[aint[k2]];

 

            if (par4List.contains(biomegenbase) && (chunkposition == null || par5Random.nextInt(j2 + 1) == 0))

            {

                chunkposition = new ChunkPosition(l2, 0, i3);

                ++j2;

            }

        }

 

        return chunkposition;

    }

 

    /**

    * Calls the WorldChunkManager's biomeCache.cleanupCache()

    */

    public void cleanupCache()

    {

        this.biomeCache.cleanupCache();

    }

 

    public GenLayer[] getModdedBiomeGenerators(WorldType worldType, long seed, GenLayer[] original)

    {

        WorldTypeEvent.InitBiomeGens event = new WorldTypeEvent.InitBiomeGens(worldType, seed, original);

        MinecraftForge.TERRAIN_GEN_BUS.post(event);

        return event.newBiomeGens;

    }

}

 

 

IslandWorldChunkProvider - this is mainly the class I am having issues with(i've generated alot of void worlds messing with it),

 

public class IslandWorldChunkProvider implements IChunkProvider{

 

private World world;

private Random random;

 

public IslandWorldChunkProvider(World world) {

 

this.world = world;

 

}

 

 

public int getLoadedChunkCount(){

 

return 0;

 

}

 

public void recreateStructures(int var1, int var2) {

 

 

}

 

 

 

@Override

public boolean chunkExists(int i, int j) {

 

return true;

}

 

 

 

@Override

public Chunk provideChunk(int i, int j) {

 

return loadChunk(i,j);

}

 

 

 

@Override

public Chunk loadChunk(int i, int j) {

 

/*This is the method i am having issues with, theres a lot of thought that goes into this one and i wanted to ask others on what i need to do before tackling it myself.*/

}

 

 

 

@Override

public void populate(IChunkProvider ichunkprovider, int i, int j) {

 

 

}

 

 

 

@Override

public boolean saveChunks(boolean flag, IProgressUpdate iprogressupdate) {

 

return true;

}

 

 

 

@Override

public boolean unloadQueuedChunks() {

 

return false;

}

 

 

 

@Override

public boolean canSave() {

 

return true;

}

 

 

 

@Override

public String makeString() {

 

return "IslandSource";

}

 

 

 

@Override

public List getPossibleCreatures(EnumCreatureType enumcreaturetype, int i,

int j, int k) {

 

return null;

}

 

 

 

@Override

public ChunkPosition findClosestStructure(World world, String s, int i,

int j, int k) {

 

return null;

}

 

 

 

@Override

public void saveExtraData() {

 

 

}

 

}

 

 

 

Thank you all for any help you provide me with.

[Sessional]

I haven't worked in 1.7.10 at all, but I will see if I can offer advice that works for 1.8.

 

First: to pick which ocean is generated at which area you use the

getBiomeGenAt

method inside the ChunkManager.

public BiomeGenBase getBiomeGenAt(int x, int z) {
      
      return this.biomeCache.getBiomeGenAt(x, z);
       
    }

 

The

provideChunk

method in 1.8 is what is used to generate the chunk. For my purposes I did not have to implement the "load chunk" method at all, and let the provide chunk method do it. This method in 1.8 makes the proper calls to fully generate a 16x16 segment of the terrain - but to do this it calls into BiomeGenBase classes to generate each vertical segment of the chunk.

The provide chunk method should probably involve populating a chunk fully up to your desired height while staying below sea level. Everything between sea level and the height you stopped at should be set to water blocks, and after that you would have a simple ocean world.