817 lines
37 KiB
Java
Executable file
817 lines
37 KiB
Java
Executable file
package game.init;
|
|
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Map.Entry;
|
|
import java.util.Set;
|
|
|
|
import game.Log;
|
|
import game.biome.Biome;
|
|
import game.block.BlockColored;
|
|
import game.block.BlockSand;
|
|
import game.block.LeavesType;
|
|
import game.collect.Lists;
|
|
import game.collect.Maps;
|
|
import game.collect.Sets;
|
|
import game.color.DyeColor;
|
|
import game.dimension.Area;
|
|
import game.dimension.DimType;
|
|
import game.dimension.Dimension;
|
|
import game.dimension.Dimension.GeneratorType;
|
|
import game.dimension.Dimension.ReplacerType;
|
|
import game.dimension.Domain;
|
|
import game.dimension.Galaxy;
|
|
import game.dimension.Moon;
|
|
import game.dimension.Planet;
|
|
import game.dimension.Sector;
|
|
import game.dimension.Semi;
|
|
import game.dimension.Space;
|
|
import game.dimension.Star;
|
|
import game.nbt.NBTException;
|
|
import game.nbt.NBTParser;
|
|
import game.nbt.NBTTagCompound;
|
|
import game.nbt.NBTTagList;
|
|
import game.rng.Random;
|
|
import game.world.PortalType;
|
|
import game.world.State;
|
|
import game.world.Weather;
|
|
|
|
public abstract class UniverseRegistry {
|
|
public static final int MORE_DIM_ID = 1000;
|
|
public static final long EARTH_YEAR = 8766144L;
|
|
|
|
private static final List<Dimension> BASE_DIMS = Lists.newArrayList();
|
|
private static final Map<Integer, Dimension> BASE_REGISTRY = Maps.newHashMap();
|
|
private static final Map<String, Dimension> BASE_ALIASES = Maps.newHashMap();
|
|
private static final Map<String, String> BASE_MAP = Maps.newHashMap();
|
|
private static final Map<String, String> BASE_NAMES = Maps.newHashMap();
|
|
private static final Map<Integer, Integer> PORTALS = Maps.newHashMap();
|
|
|
|
private static final List<Dimension> DIMENSIONS = Lists.newArrayList();
|
|
private static final Map<Integer, Dimension> REGISTRY = Maps.newTreeMap();
|
|
private static final Map<String, Dimension> ALIASES = Maps.newTreeMap();
|
|
private static final Set<String> NAMES = Sets.newTreeSet();
|
|
|
|
// private static final Map<String, Moon> MOONS = Maps.newHashMap();
|
|
// private static final Map<String, Planet> PLANETS = Maps.newHashMap();
|
|
// private static final Map<String, Star> STARS = Maps.newHashMap();
|
|
private static final Map<String, Sector> SECTORS = Maps.newHashMap();
|
|
private static final Map<String, Galaxy> GALAXIES = Maps.newHashMap();
|
|
private static final Map<String, Domain> DOMAINS = Maps.newHashMap();
|
|
|
|
private static final Map<Moon, Planet> MOON_MAP = Maps.newHashMap();
|
|
private static final Map<Planet, Star> PLANET_MAP = Maps.newHashMap();
|
|
private static final Map<Star, Sector> STAR_MAP = Maps.newHashMap();
|
|
private static final Map<Sector, Galaxy> SECTOR_MAP = Maps.newHashMap();
|
|
private static final Map<Area, Domain> AREA_MAP = Maps.newHashMap();
|
|
|
|
private static int nextDimId;
|
|
|
|
public static void clear() {
|
|
nextDimId = UniverseRegistry.MORE_DIM_ID;
|
|
ALIASES.clear();
|
|
NAMES.clear();
|
|
REGISTRY.clear();
|
|
DIMENSIONS.clear();
|
|
SECTORS.clear();
|
|
GALAXIES.clear();
|
|
DOMAINS.clear();
|
|
MOON_MAP.clear();
|
|
PLANET_MAP.clear();
|
|
STAR_MAP.clear();
|
|
SECTOR_MAP.clear();
|
|
AREA_MAP.clear();
|
|
register(Space.INSTANCE);
|
|
for(Dimension dim : BASE_REGISTRY.values()) {
|
|
register(dim.copy());
|
|
}
|
|
for(Entry<String, String> entry : BASE_MAP.entrySet()) {
|
|
assign(entry.getKey(), entry.getValue());
|
|
}
|
|
}
|
|
|
|
public static void loadNbt(NBTTagCompound tag) {
|
|
NBTTagList list = tag.getTagList("Dimensions", 10);
|
|
for(int z = 0; z < list.tagCount(); z++) {
|
|
Dimension dim = Dimension.getByNbt(list.getCompoundTagAt(z));
|
|
if(!REGISTRY.containsKey(dim.getDimensionId()) && !ALIASES.containsKey(dim.getDimensionName()))
|
|
register(dim);
|
|
}
|
|
|
|
list = tag.getTagList("Names", 10);
|
|
for(int z = 0; z < list.tagCount(); z++) {
|
|
NBTTagCompound data = list.getCompoundTagAt(z);
|
|
String id = data.getString("ID");
|
|
// if(BASE_ALIASES.containsKey(id)) {
|
|
Dimension dim = ALIASES.get(id);
|
|
if(dim != null && dim != Space.INSTANCE)
|
|
dim.readNbt(data);
|
|
// }
|
|
}
|
|
|
|
list = tag.getTagList("Sectors", 10);
|
|
for(int z = 0; z < list.tagCount(); z++) {
|
|
NBTTagCompound data = list.getCompoundTagAt(z);
|
|
String id = data.getString("ID");
|
|
Sector sector = SECTORS.get(id);
|
|
if(sector == null)
|
|
SECTORS.put(id, sector = new Sector(id));
|
|
sector.readNbt(data);
|
|
}
|
|
|
|
list = tag.getTagList("Galaxies", 10);
|
|
for(int z = 0; z < list.tagCount(); z++) {
|
|
NBTTagCompound data = list.getCompoundTagAt(z);
|
|
String id = data.getString("ID");
|
|
Galaxy galaxy = GALAXIES.get(id);
|
|
if(galaxy == null)
|
|
GALAXIES.put(id, galaxy = new Galaxy(id));
|
|
galaxy.readNbt(data);
|
|
}
|
|
|
|
list = tag.getTagList("Domains", 10);
|
|
for(int z = 0; z < list.tagCount(); z++) {
|
|
NBTTagCompound data = list.getCompoundTagAt(z);
|
|
String id = data.getString("ID");
|
|
Domain domain = DOMAINS.get(id);
|
|
if(domain == null)
|
|
DOMAINS.put(id, domain = new Domain(id));
|
|
domain.readNbt(data);
|
|
}
|
|
|
|
list = tag.getTagList("Barycenters", 10);
|
|
for(int z = 0; z < list.tagCount(); z++) {
|
|
NBTTagCompound link = list.getCompoundTagAt(z);
|
|
if(!assign(link.getString("Celestial"), link.getString("Center")))
|
|
Log.JNI.warn("Konnte '" + link.getString("Celestial") + "' nicht zu '" + link.getString("Center") + "' zuweisen");
|
|
}
|
|
}
|
|
|
|
public static NBTTagCompound saveNbt() {
|
|
NBTTagCompound tag = new NBTTagCompound();
|
|
|
|
NBTTagList list = new NBTTagList();
|
|
for(Dimension dim : DIMENSIONS) {
|
|
if(!BASE_REGISTRY.containsKey(dim.getDimensionId()) && dim != Space.INSTANCE)
|
|
list.appendTag(dim.toNbt());
|
|
}
|
|
if(!list.hasNoTags())
|
|
tag.setTag("Dimensions", list);
|
|
|
|
list = new NBTTagList();
|
|
for(Dimension dim : DIMENSIONS) {
|
|
if(/* BASE_REGISTRY.containsKey(dim.getDimensionId()) */ dim != Space.INSTANCE) {
|
|
NBTTagCompound data = new NBTTagCompound();
|
|
dim.writeNbt(data);
|
|
if(!data.hasNoTags()) {
|
|
data.setString("ID", dim.getDimensionName());
|
|
list.appendTag(data);
|
|
}
|
|
}
|
|
}
|
|
if(!list.hasNoTags())
|
|
tag.setTag("Names", list);
|
|
|
|
list = new NBTTagList();
|
|
for(Sector sector : SECTORS.values()) {
|
|
NBTTagCompound data = new NBTTagCompound();
|
|
sector.writeNbt(data);
|
|
if(!data.hasNoTags()) {
|
|
data.setString("ID", sector.id);
|
|
list.appendTag(data);
|
|
}
|
|
}
|
|
if(!list.hasNoTags())
|
|
tag.setTag("Sectors", list);
|
|
|
|
list = new NBTTagList();
|
|
for(Galaxy galaxy : GALAXIES.values()) {
|
|
NBTTagCompound data = new NBTTagCompound();
|
|
galaxy.writeNbt(data);
|
|
if(!data.hasNoTags()) {
|
|
data.setString("ID", galaxy.id);
|
|
list.appendTag(data);
|
|
}
|
|
}
|
|
if(!list.hasNoTags())
|
|
tag.setTag("Galaxies", list);
|
|
|
|
list = new NBTTagList();
|
|
for(Domain domain : DOMAINS.values()) {
|
|
NBTTagCompound data = new NBTTagCompound();
|
|
domain.writeNbt(data);
|
|
if(!data.hasNoTags()) {
|
|
data.setString("ID", domain.id);
|
|
list.appendTag(data);
|
|
}
|
|
}
|
|
if(!list.hasNoTags())
|
|
tag.setTag("Domains", list);
|
|
|
|
list = new NBTTagList();
|
|
for(Entry<Moon, Planet> entry : MOON_MAP.entrySet()) {
|
|
if(BASE_REGISTRY.containsKey(entry.getKey().getDimensionId()))
|
|
continue;
|
|
NBTTagCompound link = new NBTTagCompound();
|
|
link.setString("Celestial", entry.getKey().getDimensionName());
|
|
link.setString("Center", entry.getValue().getDimensionName());
|
|
list.appendTag(link);
|
|
}
|
|
for(Entry<Planet, Star> entry : PLANET_MAP.entrySet()) {
|
|
if(BASE_REGISTRY.containsKey(entry.getKey().getDimensionId()))
|
|
continue;
|
|
NBTTagCompound link = new NBTTagCompound();
|
|
link.setString("Celestial", entry.getKey().getDimensionName());
|
|
link.setString("Center", entry.getValue().getDimensionName());
|
|
list.appendTag(link);
|
|
}
|
|
for(Entry<Star, Sector> entry : STAR_MAP.entrySet()) {
|
|
if(BASE_REGISTRY.containsKey(entry.getKey().getDimensionId()))
|
|
continue;
|
|
NBTTagCompound link = new NBTTagCompound();
|
|
link.setString("Celestial", entry.getKey().getDimensionName());
|
|
link.setString("Center", entry.getValue().id);
|
|
list.appendTag(link);
|
|
}
|
|
for(Entry<Sector, Galaxy> entry : SECTOR_MAP.entrySet()) {
|
|
if(BASE_MAP.containsKey(entry.getKey().id))
|
|
continue;
|
|
NBTTagCompound link = new NBTTagCompound();
|
|
link.setString("Celestial", entry.getKey().id);
|
|
link.setString("Center", entry.getValue().id);
|
|
list.appendTag(link);
|
|
}
|
|
for(Entry<Area, Domain> entry : AREA_MAP.entrySet()) {
|
|
if(BASE_REGISTRY.containsKey(entry.getKey().getDimensionId()))
|
|
continue;
|
|
NBTTagCompound link = new NBTTagCompound();
|
|
link.setString("Celestial", entry.getKey().getDimensionName());
|
|
link.setString("Center", entry.getValue().id);
|
|
list.appendTag(link);
|
|
}
|
|
if(!list.hasNoTags())
|
|
tag.setTag("Barycenters", list);
|
|
|
|
return tag;
|
|
}
|
|
|
|
public static Planet registerPlanet(String star, String name, String custom, int sky, int fog, int clouds, long orbit, long rotation,
|
|
float offset, float gravity, float temperature, int brightness) {
|
|
if(!ALIASES.containsKey(star) || ALIASES.get(star).getType() != DimType.STAR || ALIASES.containsKey(name))
|
|
return null;
|
|
Planet dim = new Planet(nextDimId++, name, sky, fog, clouds, orbit, rotation, offset, gravity, temperature, brightness);
|
|
register(dim);
|
|
assign(name, star);
|
|
dim.setTimeQualifier(3);
|
|
dim.setCustomName(custom);
|
|
return dim;
|
|
}
|
|
|
|
public static Dimension[] registerPreset(Dimension preset) {
|
|
if(ALIASES.containsKey(preset.getDimensionName()))
|
|
return new Dimension[] {preset};
|
|
Random rand = new Random();
|
|
String pname = NameRegistry.FANTASY.generate(rand, rand.range(2, 5));
|
|
preset = preset.copy(nextDimId++, pname.toLowerCase());
|
|
preset.setCustomName(pname);
|
|
register(preset);
|
|
if(preset.getType() == DimType.PLANET) {
|
|
String galaxy = NameRegistry.FANTASY.generate(rand, rand.range(2, 5));
|
|
String sector = NameRegistry.FANTASY.generate(rand, rand.range(2, 5));
|
|
String sname = NameRegistry.FANTASY.generate(rand, rand.range(2, 5));
|
|
Star star = new Star(nextDimId++, sname.toLowerCase(), 0xff0000 | (rand.range(0x60, 0xa0) << 8),
|
|
rand.frange(200.0f, 400.0f), rand.frange(5000.0f, 7000.0f),
|
|
rand.pick(Blocks.lava.getState(), Blocks.magma.getState()), rand.range(64, 212));
|
|
star.setCustomName(sname);
|
|
register(star);
|
|
assign(preset.getDimensionName(), star.getDimensionName());
|
|
assign(star.getDimensionName(), sector.toLowerCase());
|
|
SECTORS.get(sector.toLowerCase()).setCustomName(sector);
|
|
assign(sector.toLowerCase(), galaxy.toLowerCase());
|
|
GALAXIES.get(galaxy.toLowerCase()).setCustomName(galaxy);
|
|
return new Dimension[] {preset, star};
|
|
}
|
|
else if(preset.getType() == DimType.AREA) {
|
|
String domain = NameRegistry.FANTASY.generate(rand, rand.range(2, 5));
|
|
assign(preset.getDimensionName(), domain.toLowerCase());
|
|
DOMAINS.get(domain.toLowerCase()).setCustomName(domain);
|
|
}
|
|
return new Dimension[] {preset};
|
|
}
|
|
|
|
public static boolean assign(String body, String center) {
|
|
Dimension celestial = ALIASES.get(body);
|
|
Dimension barycenter = ALIASES.get(center);
|
|
if(celestial != null && celestial.getType() == DimType.MOON && barycenter != null
|
|
&& barycenter.getType() == DimType.PLANET) {
|
|
MOON_MAP.put((Moon)celestial, (Planet)barycenter);
|
|
((Planet)barycenter).addMoon((Moon)celestial);
|
|
return true;
|
|
}
|
|
else if(celestial != null && celestial.getType() == DimType.PLANET && barycenter != null
|
|
&& barycenter.getType() == DimType.STAR) {
|
|
PLANET_MAP.put((Planet)celestial, (Star)barycenter);
|
|
((Star)barycenter).addPlanet((Planet)celestial);
|
|
return true;
|
|
}
|
|
else if(celestial != null && celestial.getType() == DimType.STAR && barycenter == null) {
|
|
Sector sector = SECTORS.get(center);
|
|
if(sector == null) {
|
|
SECTORS.put(center, sector = new Sector(center));
|
|
if(BASE_NAMES.containsKey(center))
|
|
sector.setCustomName(BASE_NAMES.get(center));
|
|
}
|
|
STAR_MAP.put((Star)celestial, sector);
|
|
sector.addStar((Star)celestial);
|
|
return true;
|
|
}
|
|
else if(celestial != null && celestial.getType() == DimType.AREA && barycenter == null) {
|
|
Domain domain = DOMAINS.get(center);
|
|
if(domain == null) {
|
|
DOMAINS.put(center, domain = new Domain(center));
|
|
if(BASE_NAMES.containsKey(center))
|
|
domain.setCustomName(BASE_NAMES.get(center));
|
|
}
|
|
AREA_MAP.put((Area)celestial, domain);
|
|
domain.addArea((Area)celestial);
|
|
return true;
|
|
}
|
|
else if(celestial == null && barycenter == null) {
|
|
Sector sector = SECTORS.get(body);
|
|
if(sector == null) {
|
|
SECTORS.put(body, sector = new Sector(body));
|
|
if(BASE_NAMES.containsKey(body))
|
|
sector.setCustomName(BASE_NAMES.get(body));
|
|
}
|
|
Galaxy galaxy = GALAXIES.get(center);
|
|
if(galaxy == null) {
|
|
GALAXIES.put(center, galaxy = new Galaxy(center));
|
|
if(BASE_NAMES.containsKey(center))
|
|
galaxy.setCustomName(BASE_NAMES.get(center));
|
|
}
|
|
SECTOR_MAP.put(sector, galaxy);
|
|
galaxy.addSector(sector);
|
|
return true;
|
|
}
|
|
else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
private static void register(Dimension dim) {
|
|
DIMENSIONS.add(dim);
|
|
ALIASES.put(dim.getDimensionName(), dim);
|
|
NAMES.add(dim.getDimensionName());
|
|
REGISTRY.put(dim.getDimensionId(), dim);
|
|
}
|
|
|
|
public static List<Dimension> getDimensions() {
|
|
return DIMENSIONS;
|
|
}
|
|
|
|
public static Dimension getDimension(int dim) {
|
|
return REGISTRY.get(dim);
|
|
}
|
|
|
|
public static Dimension getDimension(String name) {
|
|
return ALIASES.get(name);
|
|
}
|
|
|
|
public static Set<String> getWorldNames() {
|
|
return NAMES;
|
|
}
|
|
|
|
public static String getDefaultName(String name) {
|
|
return BASE_NAMES.get(name);
|
|
}
|
|
|
|
public static List<Dimension> getBaseDimensions() {
|
|
return BASE_DIMS;
|
|
}
|
|
|
|
public static int getPortalDest(int src, PortalType portal) {
|
|
return PORTALS.containsKey((portal.ordinal() << 20) | src) ? PORTALS.get((portal.ordinal() << 20) | src) :
|
|
(PORTALS.containsKey(portal.ordinal() | 0x7ff00000) ? PORTALS.get(portal.ordinal() | 0x7ff00000) : src);
|
|
}
|
|
|
|
// public static Text getUnformattedName(Dimension dim, boolean full) {
|
|
// Text base = dim.getNameComponent();
|
|
//// if(dim.getCustomName() != null && !dim.getCustomName().isEmpty())
|
|
//// base = new TextComponent(dim.getCustomName());
|
|
//// else if(dim.getDimensionId() >= Constants.MORE_DIM_ID)
|
|
////// base = new Translation("dimension." + dim.getType().getName(), dim.getDimensionName());
|
|
//// base = new Translation("preset." + dim.getDimensionName());
|
|
//// else
|
|
//// base = new Translation("dimension." + dim.getDimensionName());
|
|
// if(!full)
|
|
// return base;
|
|
// switch(dim.getType()) {
|
|
// case MOON:
|
|
// dim = MOON_MAP.get(dim);
|
|
// if(dim == null)
|
|
// return base;
|
|
// base.appendText(" / ").appendSibling(dim.getNameComponent());
|
|
// case PLANET:
|
|
// dim = PLANET_MAP.get(dim);
|
|
// if(dim == null)
|
|
// return base;
|
|
// base.appendText(" / ").appendSibling(dim.getNameComponent());
|
|
// case STAR:
|
|
// Sector sector = STAR_MAP.get(dim);
|
|
// if(sector == null)
|
|
// return base;
|
|
// base.appendText(" / ").appendSibling(sector.getNameComponent());
|
|
// Galaxy galaxy = SECTOR_MAP.get(sector);
|
|
// if(galaxy == null)
|
|
// return base;
|
|
// base.appendText(" / ").appendSibling(galaxy.getNameComponent());
|
|
// break;
|
|
// case AREA:
|
|
// Domain domain = AREA_MAP.get(dim);
|
|
// if(domain == null)
|
|
// return base;
|
|
// base.appendText(" / ").appendSibling(domain.getNameComponent());
|
|
// break;
|
|
// default:
|
|
// break;
|
|
// }
|
|
// return base;
|
|
// }
|
|
|
|
public static String getFormattedName(Dimension dim, boolean full) {
|
|
String base = dim.getNameString();
|
|
// if(dim.getCustomName() != null && !dim.getCustomName().isEmpty())
|
|
// base = dim.getCustomName();
|
|
// else if(dim.getDimensionId() >= Constants.MORE_DIM_ID)
|
|
//// base = I18n.format("dimension." + dim.getType().getName(), dim.getDimensionName());
|
|
// base = I18n.format("preset." + dim.getDimensionName());
|
|
// else
|
|
// base = I18n.format("dimension." + dim.getDimensionName());
|
|
if(!full)
|
|
return base;
|
|
switch(dim.getType()) {
|
|
case MOON:
|
|
dim = MOON_MAP.get(dim);
|
|
if(dim == null)
|
|
return base;
|
|
base += " / " + dim.getNameString();
|
|
case PLANET:
|
|
dim = PLANET_MAP.get(dim);
|
|
if(dim == null)
|
|
return base;
|
|
base += " / " + dim.getNameString();
|
|
case STAR:
|
|
Sector sector = STAR_MAP.get(dim);
|
|
if(sector == null)
|
|
return base;
|
|
base += " / " + sector.getNameString();
|
|
Galaxy galaxy = SECTOR_MAP.get(sector);
|
|
if(galaxy == null)
|
|
return base;
|
|
base += " / " + galaxy.getNameString();
|
|
break;
|
|
case AREA:
|
|
Domain domain = AREA_MAP.get(dim);
|
|
if(domain == null)
|
|
return base;
|
|
base += " / " + domain.getNameString();
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return base;
|
|
}
|
|
|
|
private static void registerDimension(String name, Dimension dim) {
|
|
dim.setCustomName(name);
|
|
BASE_NAMES.put(dim.getDimensionName(), name);
|
|
if(dim.getType() == DimType.PLANET || dim.getType() == DimType.AREA || dim.getType() == DimType.SEMI)
|
|
BASE_DIMS.add(dim);
|
|
BASE_REGISTRY.put(dim.getDimensionId(), dim);
|
|
BASE_ALIASES.put(dim.getDimensionName(), dim);
|
|
}
|
|
|
|
private static void registerGalaxy(String name, String galaxy) {
|
|
BASE_NAMES.put(galaxy, name);
|
|
}
|
|
|
|
private static void registerSector(String name, String sector, String galaxy) {
|
|
BASE_MAP.put(sector, galaxy);
|
|
BASE_NAMES.put(sector, name);
|
|
}
|
|
|
|
private static void registerDomain(String name, String domain) {
|
|
BASE_NAMES.put(domain, name);
|
|
}
|
|
|
|
private static void registerDimension(String name, Dimension dim, String base) {
|
|
registerDimension(name, dim);
|
|
BASE_MAP.put(dim.getDimensionName(), base);
|
|
}
|
|
|
|
private static void registerPortal(PortalType portal, String src, String dest) {
|
|
PORTALS.put((portal.ordinal() << 20) | BASE_ALIASES.get(src).getDimensionId(), BASE_ALIASES.get(dest).getDimensionId());
|
|
}
|
|
|
|
private static void registerPortal(PortalType portal, String dest) {
|
|
PORTALS.put(portal.ordinal() | 0x7ff00000, BASE_ALIASES.get(dest).getDimensionId());
|
|
}
|
|
|
|
static void register() {
|
|
registerGalaxy("Milchstraße", "milkyway");
|
|
registerSector("Solar", "solar", "milkyway");
|
|
registerDimension("Sol", new Star(2, "sol", 0xff7f00, 274.0f, 5778.0f, Blocks.lava.getState(), 128).setTimeQualifier(1), "solar");
|
|
registerDimension("Terra", new Planet(1, "terra", 0xffffffff, 0xc0d8ff, 0xffffff, UniverseRegistry.EARTH_YEAR, 24000L, 28.0f, 9.81f,
|
|
259.15f).setTimeQualifier(0)
|
|
.setPerlinGen(Blocks.stone.getState(), Blocks.water.getState(), 63)
|
|
.setBiomeReplacer(Blocks.gravel.getState())
|
|
.setBiomeGen(Biome.forest, false, 4, 4, 6, 50, 50, Biome.mushroomPlains).enableMobs().enableSnow()
|
|
.setFrostBiomes(Biome.icePlains, Biome.icePlains, Biome.icePlains, Biome.coldTaiga, Biome.megaTaiga)
|
|
.setColdBiomes(Biome.forest, Biome.extremeHills, Biome.taiga, Biome.plains)
|
|
.setMediumBiomes(Biome.forest, Biome.roofedForest, Biome.extremeHills, Biome.plains, Biome.birchForest,
|
|
Biome.swampland, Biome.jungle)
|
|
.setHotBiomes(Biome.desert, Biome.desert, Biome.desert, Biome.savanna, Biome.savanna, Biome.plains)
|
|
.enableCavesRavines(Blocks.lava.getState()).setDungeons(8).setWorldFloor(Blocks.bedrock.getState())
|
|
.addLake(Blocks.water.getState(), null, Blocks.grass.getState(), 4, 0, 255, false)
|
|
.addLake(Blocks.lava.getState(), Blocks.stone.getState(), null, 8, 8, 255, true)
|
|
.addLiquid(Blocks.flowing_water.getState(), 50, 8, 255, false)
|
|
.addLiquid(Blocks.flowing_lava.getState(), 20, 8, 255, true)
|
|
.addMetalOres(MetalType.values())
|
|
.addOre(Blocks.dirt.getState(), 10, 0, 33, 0, 256, false)
|
|
.addOre(Blocks.gravel.getState(), 8, 0, 33, 0, 256, false)
|
|
.addOre(Blocks.rock.getState(), 6, 0, 22, 24, 72, false)
|
|
.addOre(Blocks.coal_ore.getState(), 20, 0, 17, 0, 128, false)
|
|
.addOre(Blocks.redstone_ore.getState(), 8, 0, 8, 0, 16, false)
|
|
.addOre(Blocks.lapis_ore.getState(), 1, 0, 7, 16, 16, true)
|
|
.addOre(Blocks.diamond_ore.getState(), 1, 0, 8, 0, 16, false)
|
|
.addOre(Blocks.ruby_ore.getState(), 1, 0, 4, 12, 8, true)
|
|
.addOre(Blocks.cinnabar_ore.getState(), 1, 0, 11, 0, 24, false)
|
|
.enableVillages().enableMineshafts().enableScattered().enableStrongholds(), "sol");
|
|
registerDimension("Luna", new Moon(3, "luna", 0x333333, 0x333333, 655728L, 655728L, 1.62f, 210.0f, 8)
|
|
.setPerlinGen(Blocks.moon_rock.getState(), Blocks.air.getState(), 63).setBiome(Biome.moon)
|
|
.setTimeQualifier(1), "terra");
|
|
|
|
registerDimension("Merkur", new Planet(4, "mercury", 0x666666, 0x535353, 0x858585, 2111297L, 1407509L, 3.7f, 440.0f)
|
|
.setPerlinGen(Blocks.moon_rock.getState(), Blocks.air.getState(), 63)
|
|
.setTimeQualifier(1), "sol");
|
|
registerDimension("Venus", new Planet(5, "venus", 0xc0c0c0, 0xa0a0a0, 0xe0e0e0, 5392908L, 5832449L, 8.87f, 737.0f)
|
|
.setPerlinGen(Blocks.sand.getState(), Blocks.air.getState(), 63)
|
|
.setTimeQualifier(1), "sol");
|
|
registerDimension("Mars", new Planet(6, "mars", 0xd6905b, 0xbd723a, 0xbd9273, 16487781L, 24623L, 3.71f, 208.0f)
|
|
.setPerlinGen(Blocks.sand.getState().withProperty(BlockSand.VARIANT, BlockSand.EnumType.RED_SAND),
|
|
Blocks.air.getState(), 63).setTimeQualifier(1), "sol");
|
|
registerDimension("Jupiter", new Planet(7, "jupiter", 0xffd5ba, 0xb89f90, 0xc7b5a9, 103989391L, 9925L, 24.79f, 163.0f).enableDenseFog()
|
|
.setFlatGen(Blocks.hydrogen.getState(), 256).setTimeQualifier(1).setCloudHeight(576.0f), "sol");
|
|
registerDimension("Saturn", new Planet(8, "saturn", 0xf1d1a1, 0xd3b385, 0xeed7b5, 258141008L, 10656L, 10.44f, 133.0f).enableDenseFog()
|
|
.setFlatGen(Blocks.hydrogen.getState(), 256).setTimeQualifier(1).setCloudHeight(576.0f), "sol");
|
|
registerDimension("Uranus", new Planet(9, "uranus", 0xcee6ff, 0xadd2f9, 0x8eb0d3, 736503770L, 17240L, 8.87f, 78.0f)
|
|
.setPerlinGen(Blocks.packed_ice.getState(), Blocks.water.getState(), 70)
|
|
.addOre(Blocks.diamond_ore.getState(), 4, 4, 12, 0, 60, false)
|
|
.setTimeQualifier(1), "sol");
|
|
registerDimension("Neptun", new Planet(10, "neptune", 0xb4d9ff, 0x85bef9, 0x649bd3, 1444584441L, 16110L, 11.15f, 72.0f)
|
|
.setPerlinGen(Blocks.packed_ice.getState(), Blocks.water.getState(), 70)
|
|
.addOre(Blocks.diamond_ore.getState(), 4, 2, 1, 0, 60, false)
|
|
.setTimeQualifier(1), "sol");
|
|
registerDimension("Ceres", new Planet(11, "ceres", 0x666666, 0x535353, 0x858585, 40315496L, 9074L, 0.27f, 167.0f)
|
|
.setPerlinGen(Blocks.moon_rock.getState(), Blocks.air.getState(), 63)
|
|
.setTimeQualifier(1), "sol");
|
|
registerDimension("Pluto", new Planet(12, "pluto", 0x666666, 0x535353, 0x858585, 2173127098L, 153293L, 0.62f, 40.0f)
|
|
.setPerlinGen(Blocks.moon_rock.getState(), Blocks.air.getState(), 63)
|
|
.setTimeQualifier(1), "sol");
|
|
registerDimension("Haumea", new Planet(13, "haumea", 0x666666, 0x535353, 0x858585, 2487831667L, 3914L, 0.63f, 48.0f)
|
|
.setPerlinGen(Blocks.moon_rock.getState(), Blocks.air.getState(), 63)
|
|
.setTimeQualifier(1), "sol");
|
|
registerDimension("Makemake", new Planet(14, "makemake", 0x666666, 0x535353, 0x858585, 2684193293L, 22826L, 0.4f, 30.0f)
|
|
.setPerlinGen(Blocks.moon_rock.getState(), Blocks.air.getState(), 63)
|
|
.setTimeQualifier(1), "sol");
|
|
registerDimension("Eris", new Planet(15, "eris", 0x666666, 0x535353, 0x858585, 4900274496L, 378862L, 0.82f, 30.0f)
|
|
.setPerlinGen(Blocks.moon_rock.getState(), Blocks.air.getState(), 63)
|
|
.setTimeQualifier(1), "sol");
|
|
|
|
registerDimension("Gi'rok", new Star(100, "girok", 0xff8f00, 232.0f, 5220.0f, Blocks.lava.getState(), 112).setTimeQualifier(2), "solar");
|
|
registerDimension("'Elbenplanet Gharoth'", new Planet(101, "gharoth", 0xffffffff, 0xc0d8ff, 0xffffff, 4837386L, 52960L, 30.0f, 10.0f, 257.3f)
|
|
.setTimeQualifier(2).setSimpleGen(Blocks.dirt.getState(), Blocks.water.getState(), 64)
|
|
.setSimpleReplacer(Blocks.gravel.getState(), Blocks.sand.getState()).setBiome(Biome.elvenForest)
|
|
.enableCaves(Blocks.air.getState()).setDungeons(4).enableMobs().enableSnow()
|
|
.setWorldFloor(Blocks.bedrock.getState())
|
|
.addLake(Blocks.water.getState(), null, Blocks.grass.getState(), 4, 0, 255, false)
|
|
.addLake(Blocks.lava.getState(), null, null, 8, 8, 255, true)
|
|
.addLiquid(Blocks.flowing_water.getState(), 50, 8, 255, false)
|
|
.addLiquid(Blocks.flowing_lava.getState(), 20, 8, 255, true)
|
|
.addOre(Blocks.thetium_ore.getState(), 1, 0, 3, 0, 14, false)
|
|
.addOre(Blocks.gyriyn_ore.getState(), 0, 2, 3, 0, 12, false), "girok");
|
|
registerDimension("'Vampirplanet Transsylvanien'", new Planet(102, "transylvania", 0xffffffff, 0xc0d8ff, 0xffffff, 33850466L, 49760L, 20.0f, 10.0f, 255.5f)
|
|
.setTimeQualifier(5).setPerlinGen(Blocks.rock.getState(), Blocks.water.getState(), 63)
|
|
.setBiomeReplacer(Blocks.gravel.getState()).setBiomeGen(Biome.forest, true, 5, 3, 3, 30)
|
|
.enableCavesRavines(Blocks.lava.getState()).setDungeons(10).enableMobs().enableSnow()
|
|
.setWorldFloor(Blocks.bedrock.getState())
|
|
.addLake(Blocks.water.getState(), null, Blocks.grass.getState(), 4, 0, 255, false)
|
|
.addLake(Blocks.lava.getState(), null, null, 8, 8, 255, true)
|
|
.addLiquid(Blocks.flowing_water.getState(), 50, 8, 255, false)
|
|
.addLiquid(Blocks.flowing_lava.getState(), 20, 8, 255, true)
|
|
.addOre(Blocks.coal_ore.getState(), 12, 0, 14, 4, 28, false)
|
|
.addOre(Blocks.lead_ore.getState(), 2, 0, 8, 0, 8, false)
|
|
.addOre(Blocks.ardite_ore.getState(), 0, 2, 3, 0, 12, false)
|
|
.addOre(Blocks.nichun_ore.getState(), 0, 10, 1, 0, 10, false), "girok");
|
|
registerDimension("'Eismond Yrdinath'", new Moon(103, "yrdinath", 0xccccff, 0xccccff, 46743637L, 17460L, 2.5f, 239.15f, 8).setTimeQualifier(4)
|
|
.setPerlinGen(Blocks.snow.getState(), Blocks.ice.getState(), 63).setBiome(Biome.snowLand)
|
|
.setWorldFloor(Blocks.air.getState()).enableMobs().enableSnow().setWeather(Weather.SNOW), "transylvania");
|
|
registerDimension("'Wüstenplanet Me'sar'", new Planet(104, "mesar", 0xff7f3f, 0xff6022, 0xff6f00, 56643366L, 87340L, 11.0f, 333.15f)
|
|
.setTimeQualifier(5).setPerlinGen(Blocks.rock.getState(), Blocks.air.getState(), 63)
|
|
.setBiomeReplacer(Blocks.sand.getState().withProperty(BlockSand.VARIANT, BlockSand.EnumType.RED_SAND))
|
|
.setBiomeGen(Biome.mesa, true, 3, 1000, 100000, 100000)
|
|
.enableCavesRavines(Blocks.lava.getState()).enableMobs()
|
|
.setWorldFloor(Blocks.bedrock.getState())
|
|
.addLake(Blocks.lava.getState(), null, null, 8, 8, 255, true)
|
|
.addLiquid(Blocks.flowing_lava.getState(), 20, 8, 255, true)
|
|
.addOre(Blocks.iron_ore.getState(), 6, 2, 24, 0, 64, false)
|
|
.addOre(Blocks.gold_ore.getState(), 4, 2, 20, 0, 48, false)
|
|
.addOre(Blocks.lead_ore.getState(), 6, 0, 14, 0, 32, false)
|
|
.addOre(Blocks.copper_ore.getState(), 8, 2, 12, 0, 52, false)
|
|
.addOre(Blocks.coal_ore.getState(), 8, 4, 30, 0, 16, false)
|
|
.addOre(Blocks.stone.getState(), 8, 4, 33, 0, 80, false), "girok");
|
|
|
|
registerDimension("Der Warp", new Semi(-1, "warp", 0x0c001f, 0x0c001f, 0x190033, 285.0f, 3).setCloudTexture("clouds_dense").setCloudHeight(238.0f)
|
|
.setPerlinGen(Blocks.obsidian.getState(), Blocks.lava.getState(), 63)
|
|
.setBiome(Biome.chaos).enableCavesRavines(Blocks.air.getState()).enableLongCaves().enableMobs().enableSnow()
|
|
.addLake(Blocks.water.getState(), null, Blocks.obsidian.getState(), 8, 0, 255, false)
|
|
.addLake(Blocks.lava.getState(), null, null, 1, 8, 255, false)
|
|
.addLiquid(Blocks.flowing_water.getState(), 1, 8, 255, false)
|
|
.addLiquid(Blocks.flowing_lava.getState(), 40, 8, 255, true)
|
|
.setStarBrightness(0.9f).setDeepStarBrightness(0.6f)
|
|
.setStarColorSin(25.0f, 0.1f, 0.25f, 0xff00ff, 1, 4).setDeepStarColorSin(25.0f, 0.1f, 0.5f, 0xff00ff, 1, 4));
|
|
|
|
registerDomain("Tian'Xin", "tianxin");
|
|
registerDimension("Ni'enrath", new Area(-2, "nienrath", 0x7f00ff, 0x7f00ff, 276.15f, 1)
|
|
.setPerlinGen(Blocks.tian.getState(), Blocks.water.getState(), 63).setBiome(Biome.tian)
|
|
.setBiomeReplacer(Blocks.tian.getState()).enableLongCaves().enableMobs().enableSnow()
|
|
.addLake(Blocks.water.getState(), Blocks.tian.getState(), Blocks.tian.getState(), 4, 0, 255, false)
|
|
.addLiquid(Blocks.flowing_water.getState(), 50, 8, 255, false), "tianxin");
|
|
|
|
registerDimension("Cyberspace", new Area(-3, "cyberspace", 0x000000, 0x000000, 293.15f, 15)
|
|
.setFlatGen(Blocks.stained_hardened_clay.getState().withProperty(BlockColored.COLOR, DyeColor.GREEN), 2)
|
|
.enableMobs());
|
|
|
|
registerDomain("Hölle", "hell");
|
|
registerDimension("Kreis Thedric", new Area(-1001, "thedric", 0x330707, 0x330707, 347.15f, 2).enableLongCaves().enableMobs().enableFortresses()
|
|
.setWorldFloor(Blocks.air.getState()).setWorldCeiling(Blocks.bedrock.getState()).enableDenseFog()
|
|
.setCavernGen(Blocks.hellrock.getState(), Blocks.lava.getState(), 63)
|
|
.setSurfaceReplacer(Blocks.gravel.getState(), Blocks.soul_sand.getState())
|
|
.setBiome(Biome.upperHell), "hell");
|
|
registerDimension("Kreis Kyroth", new Area(-1002, "kyroth", 0x990000, 0x990000, 387.15f, 3).enableLongCaves().enableMobs()
|
|
.setWorldFloor(Blocks.air.getState())
|
|
.setSimpleGen(Blocks.hellrock.getState(), Blocks.lava.getState(), 64)
|
|
.setSimpleReplacer(Blocks.obsidian.getState(), Blocks.soul_sand.getState())
|
|
.setBiome(Biome.lowerHell)
|
|
.addLake(Blocks.lava.getState(), null, null, 4, 8, 255, false)
|
|
.addLiquid(Blocks.flowing_lava.getState(), 40, 8, 255, true), "hell");
|
|
registerDimension("Kreis Ahrd", new Area(-1003, "ahrd", 0xcc0000, 0xcc0000, 467.15f, 15).enableLongCaves().enableMobs()
|
|
.setWorldFloor(Blocks.air.getState())
|
|
.setPerlinGen(Blocks.hellrock.getState(), Blocks.lava.getState(), 63)
|
|
.setBiomeReplacer(Blocks.soul_sand.getState()).setBiome(Biome.hellHills)
|
|
.addLake(Blocks.lava.getState(), Blocks.soul_sand.getState(), Blocks.soul_sand.getState(),
|
|
2, 8, 255, false).addLiquid(Blocks.flowing_lava.getState(), 80, 8, 255, true), "hell");
|
|
registerDimension("Kreis Mizorath", new Area(-1004, "mizorath", 0xff0000, 0xff0000, 1067.15f, 15).enableMobs()
|
|
.setWorldFloor(Blocks.air.getState())
|
|
.setPerlinGen(Blocks.hellrock.getState(), Blocks.blood.getState(), 63)
|
|
.setBiomeReplacer(Blocks.soul_sand.getState()).setBiome(Biome.soulPlains), "hell");
|
|
registerDimension("Kreis Dargoth", new Area(-1005, "dargoth", 0xff3f0c, 0xff3f0c, 1707.15f, 15).enableMobs()
|
|
.setWorldFloor(Blocks.air.getState())
|
|
.setPerlinGen(Blocks.hellrock.getState(), Blocks.magma.getState(), 63)
|
|
.setBiomeReplacer(Blocks.soul_sand.getState()).setBiome(Biome.soulPlains), "hell");
|
|
registerDimension("Kreis Aasirith", new Area(-1006, "aasirith", 0x191919, 0x191919, 2482.0f, 1).enableLongCaves().enableMobs()
|
|
.setWorldFloor(Blocks.air.getState())
|
|
.setPerlinGen(Blocks.rock.getState(), Blocks.magma.getState(), 63)
|
|
.setBiomeReplacer(Blocks.ash.getState()).setBiome(Biome.ashLand)
|
|
.addLake(Blocks.lava.getState(), Blocks.rock.getState(), Blocks.rock.getState(),
|
|
2, 8, 255, false).addLiquid(Blocks.flowing_lava.getState(), 80, 8, 255, true), "hell");
|
|
|
|
setPresets();
|
|
clear();
|
|
}
|
|
|
|
private static Dimension addPreset(String name, String data) {
|
|
return addPreset(name, "terra", data);
|
|
}
|
|
|
|
private static Dimension addPreset(String name, String base, String data) {
|
|
Dimension dim = BASE_ALIASES.get(base).copy(UniverseRegistry.MORE_DIM_ID, "preset");
|
|
NBTTagCompound ptag;
|
|
try {
|
|
ptag = NBTParser.parseTag("{" + data + "}");
|
|
}
|
|
catch(NBTException e) {
|
|
throw new RuntimeException(e);
|
|
}
|
|
NBTTagCompound dtag = dim.toNbt(true);
|
|
if(ptag.getBoolean("ClearGenerator")) {
|
|
ptag.removeTag("ClearGenerator");
|
|
dtag.removeTag("FloorBlock");
|
|
dtag.removeTag("CeilingBlock");
|
|
dtag.removeTag("Layers");
|
|
dtag.removeTag("AddBiomes");
|
|
dtag.removeTag("FrostBiomes");
|
|
dtag.removeTag("ColdBiomes");
|
|
dtag.removeTag("MediumBiomes");
|
|
dtag.removeTag("HotBiomes");
|
|
dtag.removeTag("Ores");
|
|
dtag.removeTag("Lakes");
|
|
dtag.removeTag("Liquids");
|
|
dtag.setString("Generator", GeneratorType.FLAT.getName());
|
|
dtag.setString("Replacer", ReplacerType.NONE.getName());
|
|
// dtag.setBoolean("MobGen", false);
|
|
// dtag.setBoolean("SnowGen", false);
|
|
dtag.setBoolean("Caves", false);
|
|
dtag.setBoolean("Ravines", false);
|
|
dtag.setBoolean("AltCaves", false);
|
|
dtag.setBoolean("Strongholds", false);
|
|
dtag.setBoolean("Villages", false);
|
|
dtag.setBoolean("Mineshafts", false);
|
|
dtag.setBoolean("Scattered", false);
|
|
dtag.setBoolean("Fortresses", false);
|
|
dtag.setInteger("Dungeons", 0);
|
|
dtag.setInteger("BiomeSize", 0);
|
|
dtag.setInteger("RiverSize", 4);
|
|
dtag.setInteger("SnowRarity", 6);
|
|
dtag.setInteger("SeaRarity", 50);
|
|
dtag.setInteger("AddRarity", 50);
|
|
dtag.setInteger("SeaLevel", 0);
|
|
dtag.setString("DefaultBiome", Biome.none.name.toLowerCase());
|
|
dtag.setBoolean("SemiFixed", false);
|
|
// dtag.setString("DefaultWeather", Weather.CLEAR.getName());
|
|
dtag.setString("DefaultLeaves", LeavesType.SPRING.getName());
|
|
dtag.setString("FillerBlock", BlockRegistry.toIdName(Blocks.air.getState()));
|
|
dtag.setString("TopBlock", BlockRegistry.toIdName(Blocks.air.getState()));
|
|
dtag.setString("SurfaceBlock", BlockRegistry.toIdName(Blocks.air.getState()));
|
|
dtag.setString("AltBlock1", BlockRegistry.toIdName(Blocks.air.getState()));
|
|
dtag.setString("AltBlock2", BlockRegistry.toIdName(Blocks.air.getState()));
|
|
dtag.setString("LiquidBlock", BlockRegistry.toIdName(Blocks.air.getState()));
|
|
dtag.setString("CaveFillBlock", BlockRegistry.toIdName(Blocks.air.getState()));
|
|
}
|
|
dtag.merge(ptag);
|
|
dim.fromNbt(dtag);
|
|
dim.setCustomName(name);
|
|
BASE_DIMS.add(dim);
|
|
return dim;
|
|
}
|
|
|
|
private static Dimension addFlatPreset(String name, Biome biome, boolean populate, State main, Object ... layers) {
|
|
return addFlatPreset(name, "terra", biome, populate, main, layers);
|
|
}
|
|
|
|
private static Dimension addFlatPreset(String name, String base, Biome biome, boolean populate, State main, Object ... layers) {
|
|
Dimension dim = addPreset("Flach - " + name, base, "ClearGenerator:1b" + (populate ? "" : ",NoPopulation:1b"));
|
|
dim.setBiome(biome);
|
|
if(main != null)
|
|
dim.setFlatGen(main, layers);
|
|
return dim;
|
|
}
|
|
|
|
private static void setPresets()
|
|
{
|
|
addPreset("Standard", "");
|
|
addPreset("Doppelte Höhe (128)", "BaseSize:17.0,Stretch:24.0,ScaleY:80.0,SeaLevel:127");
|
|
addPreset("Große Biome", "BiomeSize:6");
|
|
addPreset("Überdreht", "Amplification:2.0");
|
|
addPreset("Wasserwelt", "ScaleX:5000.0,ScaleY:1000.0,ScaleZ:5000.0,Stretch:8.0,BDepthWeight:2.0,BDepthOffset:0.5,BScaleWeight:2.0,BScaleOffset:0.375,SeaLevel:511");
|
|
addPreset("Inselland", "CoordScale:3000.0,HeightScale:6000.0,UpperLmtScale:250.0,Stretch:10.0");
|
|
addPreset("Favorit des Gräbers", "ScaleX:5000.0,ScaleY:1000.0,ScaleZ:5000.0,Stretch:5.0,BDepthWeight:2.0,BDepthOffset:1.0,BScaleWeight:4.0,BScaleOffset:1.0");
|
|
addPreset("Verrückte Berge", "CoordScale:738.41864,HeightScale:157.69133,UpperLmtScale:801.4267,LowerLmtScale:1254.1643,DepthScaleX:374.93652,DepthScaleZ:288.65228,"
|
|
+ "ScaleX:1355.9908,ScaleY:745.5343,ScaleZ:1183.464,BaseSize:1.8758626,Stretch:1.7137525,BDepthWeight:1.7553768,BDepthOffset:3.4701107,BScaleOffset:2.535211");
|
|
addPreset("Trockenheit", "ScaleX:1000.0,ScaleY:3000.0,ScaleZ:1000.0,Stretch:10.0,SeaLevel:20");
|
|
addPreset("Chaotische Höhlen", "UpperLmtScale:2.0,LowerLmtScale:64.0,SeaLevel:6");
|
|
addPreset("Viel Glück", "LiquidBlock:lava,SeaLevel:40");
|
|
|
|
addFlatPreset("Klassisch", Biome.plains, false, Blocks.dirt.getState(), Blocks.bedrock.getState(), 2, Blocks.dirt.getState(),
|
|
Blocks.grass.getState()).enableVillages();
|
|
|
|
addFlatPreset("Abbauwelt", Biome.extremeHills, true, Blocks.stone.getState(), Blocks.bedrock.getState(), 230, Blocks.stone.getState(),
|
|
5, Blocks.dirt.getState(), Blocks.grass.getState()).enableStrongholds().enableMineshafts().setDungeons(8);
|
|
|
|
addFlatPreset("Wasserwelt", Biome.sea, false, Blocks.stone.getState(), Blocks.bedrock.getState(), 5, Blocks.stone.getState(),
|
|
52, Blocks.dirt.getState(), 5, Blocks.sand.getState(), 90, Blocks.water.getState());
|
|
|
|
addFlatPreset("Oberfläche", Biome.plains, true, Blocks.stone.getState(), Blocks.bedrock.getState(), 59, Blocks.stone.getState(),
|
|
3, Blocks.dirt.getState(), Blocks.grass.getState()).setBiomeReplacer(Blocks.gravel.getState()).enableVillages().enableStrongholds().enableMineshafts().setDungeons(8)
|
|
.addLake(Blocks.water.getState(), null, Blocks.grass.getState(), 4, 0, 255, false).addLake(Blocks.lava.getState(), Blocks.stone.getState(), null, 8, 8, 255, true);
|
|
|
|
addFlatPreset("Verschneites Königreich", Biome.icePlains, false, Blocks.stone.getState(), Blocks.bedrock.getState(), 59, Blocks.stone.getState(),
|
|
3, Blocks.dirt.getState(), Blocks.grass.getState(), Blocks.snow_layer.getState()).enableVillages();
|
|
|
|
addFlatPreset("Verschneites Königreich +", Biome.icePlains, true, Blocks.stone.getState(), Blocks.bedrock.getState(), 59, Blocks.stone.getState(),
|
|
3, Blocks.dirt.getState(), Blocks.grass.getState(), Blocks.snow_layer.getState()).setBiomeReplacer(Blocks.gravel.getState()).enableVillages()
|
|
.addLake(Blocks.water.getState(), null, Blocks.grass.getState(), 4, 0, 255, false);
|
|
|
|
addFlatPreset("Unendliche Grube", Biome.plains, false, Blocks.dirt.getState(), 2, Blocks.cobblestone.getState(), 3, Blocks.dirt.getState(), Blocks.grass.getState())
|
|
.setBiomeReplacer(Blocks.gravel.getState()).enableVillages();
|
|
|
|
addFlatPreset("Wüste", Biome.desert, false, Blocks.stone.getState(), Blocks.bedrock.getState(), 3, Blocks.stone.getState(), 52, Blocks.sandstone.getState())
|
|
.enableVillages().enableScattered();
|
|
|
|
addFlatPreset("Redstonewelt", Biome.desert, false, Blocks.sandstone.getState(), Blocks.bedrock.getState(), 3, Blocks.stone.getState(),
|
|
52, Blocks.sandstone.getState());
|
|
|
|
addPreset("Leer", "ClearGenerator:1b");
|
|
addPreset("Alpha 1.2", "Strongholds:0b,Villages:0b,MineShafts:0b,Scattered:0b,Generator:simple,Replacer:simple,Ravines:0b,SeaLevel:64,AltBlock2:sand");
|
|
}
|
|
}
|