Chunk Provider Custom Structures

I tried to use asm transformers but, not exactly an expert in that field.

Here's basaicly the idea:

Two new classes:

MapProvider:

package mods.giantnuker.backslash.world;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Random;

import mods.giantnuker.backslash.ListMap;
import mods.giantnuker.backslash.world.structure.village.MapGenModVillage;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
import net.minecraft.world.biome.Biome;
import net.minecraft.world.gen.MapGenBase;
import net.minecraft.world.gen.feature.WorldGenerator;
import net.minecraft.world.gen.structure.MapGenStructure;
import net.minecraft.world.gen.structure.MapGenVillage;
import net.minecraft.world.gen.structure.StructureComponent;
import net.minecraft.world.gen.structure.StructureStart;
import net.minecraft.world.gen.structure.StructureVillagePieces;

public class MapProvider {
	private static final ListMap<Integer, MapGenStructure> structures = new ListMap();
	private static final HashMap<MapGenStructure, Boolean> doWorldStructures = new HashMap();
	
	public static void registerStructure(MapGenStructure structure, int... dimensions) {
		if (dimensions.length > 0)
			for (int d : dimensions)
					structures.add(d, structure);
		else
			structures.add(0, structure);
		doWorldStructures.put(structure, true);
	}
	
	public static boolean shouldGenerateStructure(MapGenStructure structure, int dim) {
		if (!structures.get(dim).contains(structure)) return false;
		return doWorldStructures.get(structure);
	}
	
	public static void setGenerateStructure(MapGenStructure structure, boolean generate) {
		doWorldStructures.put(structure, generate);
	}
	
	public static MapGenStructure[] getStructures(int dim) {
		return structures.get(dim).toArray(new MapGenStructure[0]);
	}
	public static MapGenStructure[] getGeneratableStructures(int dim) {
		ArrayList<MapGenStructure> structures = new ArrayList();
		for (MapGenStructure s : doWorldStructures.keySet()) {
			if (MapProvider.structures.get(dim).contains(s)) structures.add(s);
		}
		return structures.toArray(new MapGenStructure[0]);
	}
	
	private static final ListMap<Integer, WorldGenerator> gens = new ListMap();
	private static final HashMap<WorldGenerator, Boolean> doWorldGens = new HashMap();
	
	public static void registerGen(WorldGenerator structure, int... dimensions) {
		if (dimensions.length > 0)
			for (int d : dimensions)
				gens.add(d, structure);
		else
			gens.add(0, structure);
		doWorldGens.put(structure, true);
	}
	
	public static boolean shouldGenerate(WorldGenerator gen, int dim) {
		if (!gens.get(dim).contains(gen)) return false;
		return doWorldGens.get(gen);
	}
	
	public static void setGenerate(WorldGenerator gen, boolean generate) {
		doWorldGens.put(gen, generate);
	}
	
	public static WorldGenerator[] getAllGenerators(int dim) {
		return gens.get(dim).toArray(new WorldGenerator[0]);
	}
	public static WorldGenerator[] getGenerators(int dim) {
		ArrayList<WorldGenerator> structures = new ArrayList();
		for (WorldGenerator s : doWorldGens.keySet()) {
			if (MapProvider.gens.get(dim).contains(s)) structures.add(s);
		}
		return structures.toArray(new WorldGenerator[0]);
	}
	
	private static final ListMap<Integer, MapGenBase> genBases = new ListMap();
	private static final HashMap<MapGenBase, Boolean> doWorldGenBases = new HashMap();
	
	public static void registerGenBase(MapGenBase structure, int... dimensions) {
		if (dimensions.length > 0)
			for (int d : dimensions)
				genBases.add(d, structure);
		else
			genBases.add(0, structure);
		doWorldGenBases.put(structure, true);
	}
	
	public static boolean shouldGenerateBase(MapGenBase gen, int dim) {
		if (!genBases.get(dim).contains(gen)) return false;
		return doWorldGenBases.get(gen);
	}
	
	public static void setGenerateBase(MapGenBase gen, boolean generate) {
		doWorldGenBases.put(gen, generate);
	}
	
	public static MapGenBase[] getAllBaseGenerators(int dim) {
		return genBases.get(dim).toArray(new MapGenBase[0]);
	}
	public static MapGenBase[] getBaseGenerators(int dim) {
		ArrayList<MapGenBase> structures = new ArrayList();
		for (MapGenBase s : doWorldGenBases.keySet()) {
			if (MapProvider.genBases.get(dim).contains(s)) structures.add(s);
		}
		return structures.toArray(new MapGenBase[0]);
	}
}

and ChunkProviders have a mod,

in the provideChunk you get Structures & MapGenBases set up.

			for (MapGenStructure s : MapProvider.getGeneratableStructures(0)) {
            	s.generateStructure(world, rand, chunkpos);
            }

in the populate method,

everything.

in the recreateStructures method, do the structures,

and the getStrongholdGen method(poorly named in my opinion!)

before the vanilla statments put

	for (MapGenStructure s : MapProvider.getGeneratableStructures(0)) { // XXX Find Structure
        	if (s.getStructureName().equals(structureName)) {
        		return s.getClosestStrongholdPos(worldIn, position, p_180513_4_);
        	}
        }

P.S. using for custom villages.