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.