Jump to content
Search In
  • More options...
Find results that contain...
Find results in...

Chunk Provider Custom Structures


GiantNuker
 Share

Recommended Posts

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_);
        	}
        }

:D

P.S. using for custom villages.

Link to comment
Share on other sites

Join the conversation

You can post now and register later. If you have an account, sign in now to post with your account.
Note: Your post will require moderator approval before it will be visible.

Guest
Reply to this topic...

×   Pasted as rich text.   Restore formatting

  Only 75 emoji are allowed.

×   Your link has been automatically embedded.   Display as a link instead

×   Your previous content has been restored.   Clear editor

×   You cannot paste images directly. Upload or insert images from URL.

 Share



×
×
  • Create New...

Important Information

By using this site, you agree to our Terms of Use.