Hello! I want to have floating islands in my custom dimension but only in one biomes so that's why I think I cannot do that in Chunk Generator, and I must do that in WorldGenerator class. After hours of trying I got something like: 

Spoiler

https://imgur.com/a/1b7fy1V

The problem is I would prefer something more like the last image here

Spoiler

https://minecraft.curseforge.com/projects/dimensional-control/images#

I thought of using Noise Generator in World Generator. So the question is: Do anyone know some source code of some structure which is generated using noise generators? I even do not understand noise generator so that's why I need some source code to understand just a bit how it's working

 

Also if someone has any ideas how to improve my generator here's the actual code
 

Spoiler

public class WorldGenFloatingIslands extends WorldGenerator{
	int weight=1;
	public WorldGenFloatingIslands(int w) {
		weight=w;
	}
	
	
    public boolean generate(World worldIn, Random rand, BlockPos pos)
    {
    	this.generateIsland(worldIn, rand, pos);
    	
    	
    	return true;
    }
    private void generateIsland(World worldIn,Random rand,BlockPos pos) {
    	int forz=0;
    	int maxForZ=0;
    	int k=20+rand.nextInt(30);
    	for(int width=0;width<=k;width++) {
    		if(width>(k/2)) {
    			forz-=rand.nextInt(3);
    		}else {
    			forz+=rand.nextInt(3);
    		}
    		if(forz>maxForZ) {
    			maxForZ=forz;
    		}
    		generateLayer(worldIn,rand,new BlockPos(pos.getX()+width,pos.getY(),pos.getZ()),forz,width,k);
    	}
    	
    	
    }
    private void generateLayer(World world,Random rand,BlockPos pos,int forz,int width,int maxWidth) {
    	IBlockState stoneState = KCore.MythicStone.getDefaultState();
    	IBlockState grassState = KCore.CorruptedGrass.getDefaultState();
    	IBlockState dirtState = KCore.CorruptedDirt.getDefaultState();
    	BlockPos tmp;
    	int chance=5;
    	for(int c=0;c<=forz;c++) {
    		int height = (int) ((int) ((int) 1+rand.nextInt(3)+(MathHelper.sqrt(maxWidth*forz)))-MathHelper.sqrt(width*c));
    		for(int y=0;y<=height;y++) {
    			if(y==0) {
            		tmp=new BlockPos(pos.getX(),pos.getY()-y,pos.getZ()-c);
            		setBlock(world,tmp,grassState);
            		tmp=new BlockPos(pos.getX(),pos.getY()-y,pos.getZ()+c);
            		setBlock(world,tmp,grassState);
    			}
    			else if(y!=0&&y<=4) {
            		tmp=new BlockPos(pos.getX(),pos.getY()-y,pos.getZ()-c);
            		setBlock(world,tmp,dirtState);
            		tmp=new BlockPos(pos.getX(),pos.getY()-y,pos.getZ()+c);
            		setBlock(world,tmp,dirtState);
    			}
    			else if(y==height) {
    				if(rand.nextInt(13+chance)==0) {
	            		tmp=new BlockPos(pos.getX(),pos.getY()-y,pos.getZ()-c);
	    				generateMagnethiumCrystals(world,rand,tmp,maxWidth,forz);
	    				chance+=3;
    				}
    			}
    			else {
            		tmp=new BlockPos(pos.getX(),pos.getY()-y,pos.getZ()-c);
            		setBlock(world,tmp,stoneState);
            		tmp=new BlockPos(pos.getX(),pos.getY()-y,pos.getZ()+c);
            		setBlock(world,tmp,stoneState);
    			}

    		}

    	}
    	
    }
    
    private void generateMagnethiumCrystals(World world,Random random,BlockPos pos,int maxWidth,int maxLength) {
    	int branches=1+random.nextInt(4);
    	IBlockState magnethiumState = KCore.Magnethium.getDefaultState();
    	BlockPos tmp;
    	
    	for(int c=0;c<=branches;c++) {
    		int shiftX=0;
    		int shiftZ=0;
    		int shiftY=0;
    		int branchLength=4+random.nextInt((maxWidth+maxLength)/3);
    		for(int length=0;length<=branchLength;length++) {
    			int decreaser = 2+random.nextInt(7);
	    		if(c==0) {
	    			shiftX=shiftX+random.nextInt(3)-random.nextInt(2);
	    			shiftZ=shiftZ+random.nextInt(3)-random.nextInt(2);
	    		}
	    		if(c==1) {
	    			shiftX=shiftX+random.nextInt(2)-random.nextInt(3);
	    			shiftZ=shiftZ+random.nextInt(3)-random.nextInt(2);
	    		}
	    		if(c==2) {
	    			shiftX=shiftX+random.nextInt(3)-random.nextInt(2);
	    			shiftZ=shiftZ+random.nextInt(2)-random.nextInt(3);
	    		}
	    		if(c==3) {
	    			shiftX=shiftX+random.nextInt(2)-random.nextInt(3);
	    			shiftZ=shiftZ+random.nextInt(2)-random.nextInt(3);
	    		}
	    		shiftY--;
	    		tmp=new BlockPos(pos.getX()+shiftX,pos.getY()+shiftY,pos.getZ()+shiftZ);
	    		//TODO setSphere(world,tmp,magnethiumState,(branchLength-length)/3);
	    		setBlock(world,tmp,magnethiumState);
    		}
    	}
    }
    
    private void setBlock(World worldIn, BlockPos pos,IBlockState state) {
        	this.setBlockAndNotifyAdequately(worldIn, pos, state);
    }
}

 

 

The general idea with "noise" generation is that they are just different functions for randomization. You have a threshold for placing blocks based on the output of that function. The function also usually has some input parameters to further control the amount of randomness. All this means that the outcome depends on a lot of "tuning" because you have a lot of "knobs to turn" to change the behavior.

 

The random functions used in game world generation are often things like Perlin. This describes a distribution of randomness that seems more natural. For example, if you just used a "flat" random function you would get a result that would be actually random -- there wouldn't be clusters of hills, flat areas, etc.

 

Perlin noise is well documented so you should check out information like: http://flafla2.github.io/2014/08/09/perlinnoise.html.

 

Normally it is "best" to combine the Perlin noise on top of a more algorithmic structure. Like in the link above it talks about how you can make artificial handwriting by adding a Perlin noise offset to the line to emulate the shakiness of a real human hand.

 

So for your islands you could use a sort of "reverse cave" approach. Instead of carving out a space of air within existing stone, you could create a space of stone in the air. That might be pretty cool.

 

Or you could be more controlled about it and literally have logic that decides (also randomly, but could be traditional flat random chance) to make a floating island and then you could procedurally fill in a space in the air with stone and then use noise to carve away the surface to create more randomness.

 

And so on.

 

Ultimately it will take a lot of tuning but the basic ideas are the same -- you need some logic that decides that placing blocks for floating island is needed and then you add some noise on top of that to give sense of natural randomness.