1238 lines
49 KiB
Java
1238 lines
49 KiB
Java
package world.bentobox.boxed.generators.biomes;
|
|
|
|
import java.io.File;
|
|
import java.util.Arrays;
|
|
import java.util.Collections;
|
|
import java.util.EnumMap;
|
|
import java.util.List;
|
|
import java.util.Locale;
|
|
import java.util.Map;
|
|
import java.util.Map.Entry;
|
|
import java.util.SortedMap;
|
|
import java.util.TreeMap;
|
|
|
|
import org.bukkit.World.Environment;
|
|
import org.bukkit.block.Biome;
|
|
import org.bukkit.block.BlockFace;
|
|
import org.bukkit.configuration.file.YamlConfiguration;
|
|
import org.bukkit.generator.BiomeParameterPoint;
|
|
import org.bukkit.generator.BiomeProvider;
|
|
import org.bukkit.generator.WorldInfo;
|
|
import org.bukkit.util.Vector;
|
|
import org.eclipse.jdt.annotation.NonNull;
|
|
|
|
import com.google.common.base.Enums;
|
|
|
|
import world.bentobox.boxed.Boxed;
|
|
|
|
/**
|
|
* Generates the biomes for the seed world. A seed world is the template for the chunks that
|
|
* are used to generate areas for the players to play it.s
|
|
* @author tastybento
|
|
*
|
|
*/
|
|
public abstract class AbstractSeedBiomeProvider extends BiomeProvider {
|
|
|
|
private static final Map<Environment, String> ENV_MAP;
|
|
|
|
static {
|
|
Map<Environment, String> e = new EnumMap<>(Environment.class);
|
|
e.put(Environment.NORMAL, "distribution.overworld");
|
|
e.put(Environment.NETHER, "distribution.nether");
|
|
e.put(Environment.THE_END, "distribution.the_end");
|
|
ENV_MAP = Collections.unmodifiableMap(e);
|
|
}
|
|
|
|
/**
|
|
* Heights / ridges by erosion
|
|
*/
|
|
private enum Ridges {
|
|
VALLEYS(-1.0, -0.85), LOW(-0.85, -0.6), MID(-0.6, 0.2), HIGH(0.2, 0.7), PEAKS(0.7, 1.0);
|
|
|
|
private double low;
|
|
private double high;
|
|
|
|
Ridges(double low, double high) {
|
|
this.low = low;
|
|
this.high = high;
|
|
}
|
|
|
|
public static Ridges getRidge(double erosion) {
|
|
for (Ridges r : Ridges.values()) {
|
|
if (erosion >= r.low && erosion < r.high) {
|
|
return r;
|
|
}
|
|
}
|
|
return MID;
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Badland Biones by Humidity Zone
|
|
*/
|
|
private enum BadlandBiome {
|
|
HZONE0(0, Biome.BADLANDS, Biome.ERODED_BADLANDS), HZONE1(1, Biome.BADLANDS, Biome.ERODED_BADLANDS),
|
|
HZONE2(2, Biome.BADLANDS, Biome.BADLANDS), HZONE3(3, Biome.WOODED_BADLANDS, Biome.WOODED_BADLANDS),
|
|
HZONE4(4, Biome.WOODED_BADLANDS, Biome.WOODED_BADLANDS);
|
|
|
|
private int humidityZone;
|
|
private Biome biome;
|
|
private Biome biome2;
|
|
|
|
BadlandBiome(int h, Biome biome, Biome biome2) {
|
|
this.humidityZone = h;
|
|
this.biome = biome;
|
|
this.biome2 = biome2;
|
|
}
|
|
|
|
public static Biome getBiome(int humidity, double weirdness) {
|
|
for (BadlandBiome mb : BadlandBiome.values()) {
|
|
if (mb.humidityZone == humidity) {
|
|
if (weirdness < 0) {
|
|
return mb.biome;
|
|
} else {
|
|
return mb.biome2;
|
|
}
|
|
}
|
|
}
|
|
throw new IllegalArgumentException("badlands biome h = " + humidity);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Middle Biomes by temperature and humidity zones
|
|
*/
|
|
private enum MiddleBiome {
|
|
X00(0, 0, Biome.SNOWY_PLAINS, Biome.ICE_SPIKES), X01(0, 1, Biome.PLAINS, Biome.PLAINS),
|
|
X02(0, 2, Biome.FLOWER_FOREST, Biome.SUNFLOWER_PLAINS), x03(0, 3, Biome.SAVANNA, Biome.SAVANNA),
|
|
X04(0, 4, Biome.DESERT, Biome.DESERT),
|
|
|
|
X10(1, 0, Biome.SNOWY_PLAINS, Biome.SNOWY_PLAINS), X11(1, 1, Biome.PLAINS, Biome.PLAINS),
|
|
X12(1, 2, Biome.PLAINS, Biome.PLAINS), X13(1, 3, Biome.SAVANNA, Biome.SAVANNA),
|
|
X14(1, 4, Biome.DESERT, Biome.DESERT),
|
|
|
|
X20(2, 0, Biome.SNOWY_PLAINS, Biome.SNOWY_TAIGA), X21(2, 1, Biome.FOREST, Biome.FOREST),
|
|
X22(2, 2, Biome.FOREST, Biome.FOREST), X23(2, 3, Biome.FOREST, Biome.PLAINS),
|
|
X24(2, 4, Biome.DESERT, Biome.DESERT),
|
|
|
|
X30(3, 0, Biome.SNOWY_TAIGA, Biome.SNOWY_TAIGA), X31(3, 1, Biome.TAIGA, Biome.TAIGA),
|
|
X32(3, 2, Biome.BIRCH_FOREST, Biome.OLD_GROWTH_BIRCH_FOREST), X33(3, 3, Biome.JUNGLE, Biome.SPARSE_JUNGLE),
|
|
X34(3, 4, Biome.DESERT, Biome.DESERT),
|
|
|
|
X40(4, 0, Biome.TAIGA, Biome.TAIGA), X41(4, 1, Biome.OLD_GROWTH_SPRUCE_TAIGA, Biome.OLD_GROWTH_PINE_TAIGA),
|
|
X42(4, 2, Biome.DARK_FOREST, Biome.DARK_FOREST), X43(4, 3, Biome.JUNGLE, Biome.BAMBOO_JUNGLE),
|
|
X44(4, 4, Biome.DESERT, Biome.DESERT),
|
|
;
|
|
|
|
private int temperature;
|
|
private int humidity;
|
|
private Biome biome;
|
|
private Biome weirdBiome; // What the biome be if the weirdness is high enough
|
|
|
|
MiddleBiome(int h, int t, Biome b, Biome weirdBiome) {
|
|
this.humidity = h;
|
|
this.temperature = t;
|
|
this.weirdBiome = weirdBiome;
|
|
this.biome = b;
|
|
}
|
|
|
|
public static Biome getBiome(int humidity, int temperature, double weirdness) {
|
|
for (MiddleBiome mb : MiddleBiome.values()) {
|
|
if (mb.humidity == humidity && mb.temperature == temperature) {
|
|
if (weirdness < 0) {
|
|
return mb.biome;
|
|
} else {
|
|
return mb.weirdBiome;
|
|
}
|
|
}
|
|
}
|
|
throw new IllegalArgumentException("middle biome h = " + humidity + " t = " + temperature);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Plateau biomes by temperature and humidity zones
|
|
*/
|
|
private enum PlateauBiome {
|
|
X00(0, 0, Biome.SNOWY_PLAINS, Biome.ICE_SPIKES), x01(0, 1, Biome.MEADOW, Biome.CHERRY_GROVE),
|
|
X02(0, 2, Biome.MEADOW, Biome.CHERRY_GROVE), x03(0, 3, Biome.SAVANNA_PLATEAU, Biome.SAVANNA_PLATEAU),
|
|
X04(0, 4, Biome.BADLANDS, Biome.ERODED_BADLANDS),
|
|
|
|
X10(1, 0, Biome.SNOWY_PLAINS, Biome.SNOWY_PLAINS), x11(1, 1, Biome.MEADOW, Biome.MEADOW),
|
|
X12(1, 2, Biome.MEADOW, Biome.CHERRY_GROVE), x13(1, 3, Biome.SAVANNA_PLATEAU, Biome.SAVANNA_PLATEAU),
|
|
X14(1, 4, Biome.BADLANDS, Biome.ERODED_BADLANDS),
|
|
|
|
X20(2, 0, Biome.SNOWY_PLAINS, Biome.SNOWY_TAIGA), x21(2, 1, Biome.FOREST, Biome.MEADOW),
|
|
X22(2, 2, Biome.MEADOW, Biome.BIRCH_FOREST), x23(2, 3, Biome.FOREST, Biome.FOREST),
|
|
X24(2, 4, Biome.BADLANDS, Biome.BADLANDS),
|
|
|
|
X30(3, 0, Biome.SNOWY_TAIGA, Biome.SNOWY_TAIGA), x31(3, 1, Biome.TAIGA, Biome.MEADOW),
|
|
X32(3, 2, Biome.MEADOW, Biome.BIRCH_FOREST), x33(3, 3, Biome.FOREST, Biome.FOREST),
|
|
X34(3, 4, Biome.WOODED_BADLANDS, Biome.WOODED_BADLANDS),
|
|
|
|
X40(4, 0, Biome.SNOWY_TAIGA, Biome.SNOWY_TAIGA),
|
|
X41(4, 1, Biome.OLD_GROWTH_SPRUCE_TAIGA, Biome.OLD_GROWTH_PINE_TAIGA),
|
|
X42(4, 2, Biome.DARK_FOREST, Biome.DARK_FOREST), x43(4, 3, Biome.JUNGLE, Biome.JUNGLE),
|
|
X44(4, 4, Biome.WOODED_BADLANDS, Biome.WOODED_BADLANDS),;
|
|
|
|
private int temp;
|
|
private int humidity;
|
|
private Biome b;
|
|
private Biome weirdBiome;
|
|
|
|
PlateauBiome(int humidity, int temp, Biome b, Biome weirdBiome) {
|
|
this.humidity = humidity;
|
|
this.temp = temp;
|
|
this.weirdBiome = weirdBiome;
|
|
this.b = b;
|
|
}
|
|
|
|
public static Biome getBiome(int humidity, int temp, double weirdness) {
|
|
for (PlateauBiome mb : PlateauBiome.values()) {
|
|
if (mb.humidity == humidity && mb.temp == temp) {
|
|
if (weirdness < 0) {
|
|
return mb.b;
|
|
} else {
|
|
return mb.weirdBiome;
|
|
}
|
|
}
|
|
}
|
|
throw new IllegalArgumentException("plateau biome h = " + humidity + " t = " + temp);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Shattered biomes by temperature and humidity
|
|
*/
|
|
private enum ShatteredBiome {
|
|
X00(0, 0, Biome.WINDSWEPT_GRAVELLY_HILLS, Biome.WINDSWEPT_GRAVELLY_HILLS),
|
|
X01(0, 1, Biome.WINDSWEPT_GRAVELLY_HILLS, Biome.WINDSWEPT_GRAVELLY_HILLS),
|
|
X02(0, 2, Biome.WINDSWEPT_HILLS, Biome.WINDSWEPT_HILLS), X03(0, 3, Biome.SAVANNA, Biome.SAVANNA),
|
|
X04(0, 4, Biome.DESERT, Biome.DESERT),
|
|
|
|
X10(1, 0, Biome.WINDSWEPT_GRAVELLY_HILLS, Biome.WINDSWEPT_GRAVELLY_HILLS),
|
|
X11(1, 1, Biome.WINDSWEPT_GRAVELLY_HILLS, Biome.WINDSWEPT_GRAVELLY_HILLS),
|
|
X12(1, 2, Biome.WINDSWEPT_HILLS, Biome.WINDSWEPT_HILLS),
|
|
X13(1, 3, Biome.SAVANNA_PLATEAU, Biome.SAVANNA_PLATEAU), X14(1, 4, Biome.DESERT, Biome.DESERT),
|
|
|
|
X20(2, 0, Biome.WINDSWEPT_HILLS, Biome.WINDSWEPT_HILLS),
|
|
X21(2, 1, Biome.WINDSWEPT_HILLS, Biome.WINDSWEPT_HILLS),
|
|
X22(2, 2, Biome.WINDSWEPT_HILLS, Biome.WINDSWEPT_HILLS), X23(2, 3, Biome.FOREST, Biome.FOREST),
|
|
X24(2, 4, Biome.DESERT, Biome.DESERT),
|
|
|
|
X30(3, 0, Biome.WINDSWEPT_FOREST, Biome.WINDSWEPT_FOREST),
|
|
X31(3, 1, Biome.WINDSWEPT_FOREST, Biome.WINDSWEPT_FOREST),
|
|
X32(3, 2, Biome.WINDSWEPT_FOREST, Biome.WINDSWEPT_FOREST), X33(3, 3, Biome.JUNGLE, Biome.SPARSE_JUNGLE),
|
|
X34(3, 4, Biome.DESERT, Biome.DESERT),
|
|
|
|
X40(4, 0, Biome.WINDSWEPT_FOREST, Biome.WINDSWEPT_FOREST),
|
|
X41(4, 1, Biome.WINDSWEPT_FOREST, Biome.WINDSWEPT_FOREST),
|
|
X42(4, 2, Biome.WINDSWEPT_FOREST, Biome.WINDSWEPT_FOREST), X43(4, 3, Biome.JUNGLE, Biome.BAMBOO_JUNGLE),
|
|
X44(4, 4, Biome.DESERT, Biome.DESERT),;
|
|
|
|
private int temperature;
|
|
private int humidity;
|
|
private Biome biome;
|
|
private Biome weirdBiome;
|
|
|
|
ShatteredBiome(int h, int t, Biome b, Biome weirdBiome) {
|
|
this.humidity = h;
|
|
this.temperature = t;
|
|
this.weirdBiome = weirdBiome;
|
|
this.biome = b;
|
|
}
|
|
|
|
public static Biome getBiome(int h, int t, double we) {
|
|
for (ShatteredBiome mb : ShatteredBiome.values()) {
|
|
if (mb.humidity == h && mb.temperature == t) {
|
|
if (we < 0) {
|
|
return mb.biome;
|
|
} else {
|
|
return mb.weirdBiome;
|
|
}
|
|
}
|
|
}
|
|
throw new IllegalArgumentException("shattered biome h = " + h + " t = " + t);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Continental location by continentalness
|
|
*/
|
|
private enum ContLoc {
|
|
MUSHROOM_FIELDS(-1.2, -1.05),
|
|
DEEP_OCEAN(-1.05, -0.455),
|
|
OCEAN(-0.455, -0.19),
|
|
COAST(-0.19, -0.11),
|
|
NEAR_INLAND(-0.11, 0.03),
|
|
MID_INLAND(0.03, 0.3),
|
|
FAR_INLAND(0.3, 10.0);
|
|
|
|
private double min;
|
|
private double max;
|
|
|
|
ContLoc(double min, double max) {
|
|
this.min = min;
|
|
this.max = max;
|
|
}
|
|
|
|
public static ContLoc getCont(double continentalness) {
|
|
for (ContLoc c : ContLoc.values()) {
|
|
if (continentalness >= c.min && continentalness < c.max) {
|
|
return c;
|
|
}
|
|
}
|
|
throw new IllegalArgumentException("contloc out of spec value = " + continentalness);
|
|
}
|
|
}
|
|
|
|
private final Boxed addon;
|
|
protected final int dist;
|
|
private final int spawnX;
|
|
private final int spawnZ;
|
|
protected final Map<BlockFace, SortedMap<Double, Biome>> quadrants;
|
|
|
|
protected AbstractSeedBiomeProvider(Boxed boxed, Environment env) {
|
|
this.addon = boxed;
|
|
// These fields are used to determine the biomes around the spawn point
|
|
this.dist = addon.getSettings().getIslandDistance();
|
|
if (env.equals(Environment.NORMAL)) {
|
|
spawnX = addon.getSettings().getSeedX();
|
|
spawnZ = addon.getSettings().getSeedZ();
|
|
} else {
|
|
spawnX = addon.getSettings().getNetherSeedX();
|
|
spawnZ = addon.getSettings().getNetherSeedZ();
|
|
}
|
|
// Load the config
|
|
File biomeFile = new File(addon.getDataFolder(), "biomes.yml");
|
|
// Check if it exists and if not, save it from the jar
|
|
if (!biomeFile.exists()) {
|
|
addon.saveResource("biomes.yml", true);
|
|
}
|
|
YamlConfiguration config = YamlConfiguration.loadConfiguration(biomeFile);
|
|
SortedMap<Double, Biome> northEast = loadQuad(config, ENV_MAP.get(env) + ".north-east");
|
|
SortedMap<Double, Biome> southEast = loadQuad(config, ENV_MAP.get(env) + ".south-east");
|
|
SortedMap<Double, Biome> northWest = loadQuad(config, ENV_MAP.get(env) + ".north-west");
|
|
SortedMap<Double, Biome> southWest = loadQuad(config, ENV_MAP.get(env) + ".south-west");
|
|
|
|
quadrants = new EnumMap<>(BlockFace.class);
|
|
quadrants.put(BlockFace.NORTH_EAST, northEast);
|
|
quadrants.put(BlockFace.NORTH_WEST, northWest);
|
|
quadrants.put(BlockFace.SOUTH_EAST, southEast);
|
|
quadrants.put(BlockFace.SOUTH_WEST, southWest);
|
|
}
|
|
|
|
private Biome getQuadrantBiome(BlockFace dir, double d) {
|
|
Entry<Double, Biome> en = ((TreeMap<Double, Biome>) quadrants.get(dir)).ceilingEntry(d);
|
|
return en == null ? null : en.getValue();
|
|
}
|
|
|
|
@Override
|
|
public Biome getBiome(WorldInfo worldInfo, int x, int y, int z, BiomeParameterPoint biomeParameterPoint) {
|
|
return this.getMappedBiome(worldInfo, x, y, z, biomeParameterPoint);
|
|
}
|
|
|
|
@Override
|
|
public Biome getBiome(WorldInfo worldInfo, int x, int y, int z) {
|
|
throw new IllegalStateException("This method should never be called.");
|
|
}
|
|
|
|
/**
|
|
* Get the vanilla biome at this coordinate
|
|
* @param worldInfo world info
|
|
* @param x x
|
|
* @param y y
|
|
* @param z z
|
|
* @return Biome
|
|
*/
|
|
@NonNull
|
|
private Biome getVanillaBiome(WorldInfo worldInfo, int x, int y, int z, BiomeParameterPoint bpb, Biome def) {
|
|
if (worldInfo.getEnvironment() == Environment.NORMAL) {
|
|
return getNormalBiome(bpb, def);
|
|
}
|
|
return getNetherBiome(bpb);
|
|
|
|
}
|
|
|
|
private @NonNull Biome getNetherBiome(BiomeParameterPoint bpb) {
|
|
// Bring these values to 1 decimal place
|
|
double temp = Math.round(bpb.getTemperature() * 10.0) / 10.0;
|
|
double humidity = Math.round(bpb.getHumidity() * 10.0) / 10.0;
|
|
if (temp == -0.5D && humidity == 0.0D) {
|
|
return Biome.BASALT_DELTAS;
|
|
} else if (temp == 0.4D && humidity == 0.0D) {
|
|
return Biome.CRIMSON_FOREST;
|
|
} else if (temp == 0.0D && humidity == -0.5D) {
|
|
return Biome.SOUL_SAND_VALLEY;
|
|
} else if (temp == -0.5D && humidity == 0.5D) {
|
|
return Biome.WARPED_FOREST;
|
|
}
|
|
|
|
return Biome.NETHER_WASTES;
|
|
}
|
|
|
|
private @NonNull Biome getNormalBiome(BiomeParameterPoint bpb, Biome def) {
|
|
/*
|
|
* Caves
|
|
*/
|
|
double d = bpb.getDepth();
|
|
if (d > 0.2 && d < 0.9) {
|
|
if (bpb.getHumidity() >= 0.4 && bpb.getHumidity() < 1.0) {
|
|
def = Biome.LUSH_CAVES;
|
|
}
|
|
if (bpb.getContinentalness() >= 0.8D && bpb.getContinentalness() <= 1.0D) {
|
|
def = Biome.DRIPSTONE_CAVES;
|
|
}
|
|
}
|
|
if (d >= 0.9) { // Vanilla has this as 1.1
|
|
def = Biome.DEEP_DARK;
|
|
}
|
|
if (def != null) {
|
|
return def;
|
|
}
|
|
|
|
/*
|
|
* Continentalness (also known as continents) is used to decide between ocean/beach/land biomes.
|
|
*/
|
|
int temp = getTemp(bpb.getTemperature());
|
|
int humidity = getHumidity(bpb.getHumidity());
|
|
int erosion = getErosion(bpb.getErosion());
|
|
double we = bpb.getWeirdness();
|
|
|
|
return switch (ContLoc.getCont(bpb.getContinentalness())) {
|
|
case COAST -> coastBiome(humidity, temp, erosion, we);
|
|
case DEEP_OCEAN -> deepOceanBiome(temp);
|
|
case FAR_INLAND -> farInlandBiome(humidity, temp, erosion, we);
|
|
case MID_INLAND -> midInlandBiome(humidity, temp, erosion, we);
|
|
case MUSHROOM_FIELDS -> Biome.MUSHROOM_FIELDS;
|
|
case NEAR_INLAND -> nearInlandBiome(humidity, temp, erosion, we);
|
|
case OCEAN -> oceanBiome(temp);
|
|
default -> farInlandBiome(humidity, temp, erosion, we);
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Erosion values are divided into 7 levels. The corresponding ranges from level 0 to level 6 are:
|
|
* -1.0~-0.78, -0.78~-0.375, -0.375~-0.2225, -0.2225~0.05, 0.05~0.45, 0.45~0.55, 0.55~1.0.
|
|
*
|
|
* @param erosion The erosion value
|
|
* @return The erosion level (0-6)
|
|
*/
|
|
private int getErosion(double erosion) {
|
|
if (erosion < -0.78) {
|
|
return 0;
|
|
} else if (erosion < -0.375) {
|
|
return 1;
|
|
} else if (erosion < -0.2225) {
|
|
return 2;
|
|
} else if (erosion < 0.05) {
|
|
return 3;
|
|
} else if (erosion < 0.45) {
|
|
return 4;
|
|
} else if (erosion < 0.55) {
|
|
return 5;
|
|
} else {
|
|
return 6;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Humidity values are also divided into 5 levels. The corresponding ranges from level 0 to level 4 are:
|
|
* -1.0~-0.35, -0.35~-0.1, -0.1~0.1, 0.1~0.3, 0.3~1.0.
|
|
*
|
|
* @param humidity The humidity value
|
|
* @return The humidity level (0-4)
|
|
*/
|
|
private int getHumidity(double humidity) {
|
|
if (humidity < -0.35) {
|
|
return 0;
|
|
} else if (humidity < -0.1) {
|
|
return 1;
|
|
} else if (humidity < 0.1) {
|
|
return 2;
|
|
} else if (humidity < 0.3) {
|
|
return 3;
|
|
} else {
|
|
return 4;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Temperature is a noise parameter used only in biome generation and does not affect terrain generation.
|
|
* Temperature values are divided into 5 levels. The corresponding ranges from level 0 to level 4 are:
|
|
* -1.0~-0.45, -0.45~-0.15, -0.15~0.2, 0.2~0.55, 0.55~1.0.
|
|
*
|
|
* @param temp The temperature value
|
|
* @return The temperature level (0-4)
|
|
*/
|
|
private int getTemp(double temp) {
|
|
if (temp < -0.45) {
|
|
return 0;
|
|
} else if (temp < -0.15) {
|
|
return 1;
|
|
} else if (temp < 0.2) {
|
|
return 2;
|
|
} else if (temp < 0.55) {
|
|
return 3;
|
|
} else {
|
|
return 4;
|
|
}
|
|
}
|
|
|
|
|
|
private @NonNull Biome oceanBiome(int temp) {
|
|
return switch (temp) {
|
|
case 0 -> Biome.FROZEN_OCEAN;
|
|
case 1 -> Biome.COLD_OCEAN;
|
|
case 2 -> Biome.OCEAN;
|
|
case 3 -> Biome.LUKEWARM_OCEAN;
|
|
case 4 -> Biome.WARM_OCEAN;
|
|
default -> Biome.OCEAN;
|
|
};
|
|
}
|
|
|
|
private @NonNull Biome deepOceanBiome(int temp) {
|
|
return switch (temp) {
|
|
case 0 -> Biome.DEEP_FROZEN_OCEAN;
|
|
case 1 -> Biome.DEEP_COLD_OCEAN;
|
|
case 2 -> Biome.DEEP_OCEAN;
|
|
case 3 -> Biome.DEEP_LUKEWARM_OCEAN;
|
|
case 4 -> Biome.WARM_OCEAN;
|
|
default -> Biome.DEEP_OCEAN;
|
|
};
|
|
}
|
|
|
|
private @NonNull Biome farInlandBiome(int humidity, int temperature, int erosion, double weirdness) {
|
|
return switch (Ridges.getRidge(convertToY(weirdness))) {
|
|
case HIGH -> getFarInlandHighBiome(humidity, temperature, erosion, weirdness);
|
|
case LOW -> getFarInlandLowBiome(humidity, temperature, erosion, weirdness);
|
|
case MID -> getFarInlandMidBiome(humidity, temperature, erosion, weirdness);
|
|
case PEAKS -> getFarInlandPeaksBiome(humidity, temperature, erosion, weirdness);
|
|
default -> getFarInlandValleysBiome(humidity, temperature, erosion, weirdness);
|
|
};
|
|
}
|
|
|
|
private @NonNull Biome getFarInlandValleysBiome(int humidity, int temperature, int erosion, double weirdness) {
|
|
if (erosion >= 0 && erosion < 6) {
|
|
if (temperature > 0D) {
|
|
return Biome.RIVER;
|
|
} else {
|
|
return Biome.FROZEN_RIVER;
|
|
}
|
|
}
|
|
// e == 6
|
|
if (temperature == 0) {
|
|
return Biome.FROZEN_RIVER;
|
|
}
|
|
if (temperature == 1 || temperature == 2) {
|
|
return Biome.SWAMP;
|
|
}
|
|
return Biome.MANGROVE_SWAMP;
|
|
}
|
|
|
|
private @NonNull Biome getValleysNearInlandBiome(int humidity, int temperature, int erosion, double weirdness) {
|
|
return getFarInlandValleysBiome(humidity, temperature, erosion, weirdness);
|
|
}
|
|
|
|
private @NonNull Biome getFarInlandPeaksBiome(int humidity, int temperature, int erosion, double weirdness) {
|
|
if (erosion == 0) {
|
|
if (temperature >= 0 && temperature <= 2) {
|
|
if (weirdness < 0) {
|
|
return Biome.JAGGED_PEAKS;
|
|
} else {
|
|
return Biome.FROZEN_PEAKS;
|
|
}
|
|
} else if (temperature == 3) {
|
|
return Biome.STONY_PEAKS;
|
|
}
|
|
return BadlandBiome.getBiome(humidity, weirdness);
|
|
} else if (erosion == 1) {
|
|
if (temperature == 0 && (humidity == 0 || humidity == 1)) {
|
|
return Biome.SNOWY_SLOPES;
|
|
} else if (temperature == 0 && humidity > 1) {
|
|
return Biome.GROVE;
|
|
} else if (temperature < 4) {
|
|
return MiddleBiome.getBiome(humidity, temperature, weirdness);
|
|
}
|
|
return BadlandBiome.getBiome(humidity, weirdness);
|
|
} else if (erosion >= 2 && erosion <= 4) {
|
|
// Middle biomes
|
|
return MiddleBiome.getBiome(humidity, temperature, weirdness);
|
|
} else if (erosion == 5) {
|
|
if (weirdness < 0 && (temperature == 0 || temperature == 1 || humidity == 4)) {
|
|
// Shattered biomes
|
|
return ShatteredBiome.getBiome(humidity, temperature, weirdness);
|
|
}
|
|
if (weirdness > 0 && (temperature > 2 && temperature <= 4 && humidity >= 0 && humidity <= 4)) {
|
|
return Biome.WINDSWEPT_SAVANNA;
|
|
}
|
|
}
|
|
// middle biomes
|
|
return MiddleBiome.getBiome(humidity, temperature, weirdness);
|
|
}
|
|
|
|
private @NonNull Biome getFarInlandMidBiome(int humidity, int temperature, int erosion, double weirdness) {
|
|
if (erosion == 0) {
|
|
if (temperature < 3 && (humidity == 0 || humidity == 1)) {
|
|
return Biome.SNOWY_SLOPES;
|
|
}
|
|
if (temperature < 3 && (humidity == 2 || humidity == 3 || humidity == 4)) {
|
|
return Biome.GROVE;
|
|
}
|
|
return PlateauBiome.getBiome(humidity, temperature, weirdness);
|
|
} else if (erosion == 1) {
|
|
if (temperature == 0 && (humidity == 0 || humidity == 1)) {
|
|
return Biome.SNOWY_SLOPES;
|
|
}
|
|
if (temperature == 0 && (humidity == 2 || humidity == 3 || humidity == 4)) {
|
|
return Biome.GROVE;
|
|
}
|
|
return PlateauBiome.getBiome(humidity, temperature, weirdness);
|
|
} else if (erosion == 2) {
|
|
return PlateauBiome.getBiome(humidity, temperature, weirdness);
|
|
} else if (erosion == 3) {
|
|
// Middle biomes
|
|
return MiddleBiome.getBiome(humidity, temperature, weirdness);
|
|
} else if (erosion == 5) {
|
|
if (weirdness < 0 && (temperature == 0 || temperature == 1) || humidity == 4) {
|
|
// Middle biomes
|
|
return MiddleBiome.getBiome(humidity, temperature, weirdness);
|
|
}
|
|
if (weirdness > 0 && (temperature > 2 && temperature <= 4 && humidity >= 0 && humidity <= 4)) {
|
|
return Biome.WINDSWEPT_SAVANNA;
|
|
}
|
|
}
|
|
if (temperature == 0) {
|
|
// Middle Biomes
|
|
return MiddleBiome.getBiome(humidity, temperature, weirdness);
|
|
}
|
|
if (temperature == 1 || temperature == 2) {
|
|
return Biome.SWAMP;
|
|
}
|
|
return Biome.MANGROVE_SWAMP;
|
|
}
|
|
|
|
private @NonNull Biome getFarInlandLowBiome(int humidity, int temperature, int erosion, double weirdness) {
|
|
if (erosion >= 0 && erosion < 2) {
|
|
if (temperature < 4) {
|
|
return MiddleBiome.getBiome(humidity, temperature, weirdness);
|
|
}
|
|
return BadlandBiome.getBiome(humidity, weirdness);
|
|
} else if (erosion >= 2 && erosion < 5) {
|
|
// Middle Biomes
|
|
return MiddleBiome.getBiome(humidity, temperature, weirdness);
|
|
} else if (erosion == 5) {
|
|
if (weirdness < 0 && (temperature == 0 || temperature == 1 || humidity == 4)) {
|
|
// Middle biomes
|
|
return MiddleBiome.getBiome(humidity, temperature, weirdness);
|
|
}
|
|
if (weirdness > 0 && (temperature > 2 && temperature <= 4 && humidity >= 0 && humidity <= 4)) {
|
|
return Biome.WINDSWEPT_SAVANNA;
|
|
}
|
|
}
|
|
if (temperature == 0) {
|
|
return MiddleBiome.getBiome(humidity, temperature, weirdness);
|
|
} else if (temperature == 1 || temperature == 2) {
|
|
return Biome.SWAMP;
|
|
}
|
|
return Biome.MANGROVE_SWAMP;
|
|
}
|
|
|
|
private @NonNull Biome getFarInlandHighBiome(int humidity, int temperature, int erosion, double weirdness) {
|
|
if (erosion == 0) {
|
|
if (temperature < 3 && (humidity == 0 || humidity == 1)) {
|
|
return Biome.SNOWY_SLOPES;
|
|
}
|
|
if (temperature < 3 && (humidity == 2 || humidity == 3 || humidity == 4)) {
|
|
return Biome.GROVE;
|
|
}
|
|
return PlateauBiome.getBiome(humidity, temperature, weirdness);
|
|
} else if (erosion == 1) {
|
|
if (temperature == 0 && (humidity == 0 || humidity == 1)) {
|
|
return Biome.SNOWY_SLOPES;
|
|
}
|
|
if (temperature == 0 && (humidity == 2 || humidity == 3 || humidity == 4)) {
|
|
return Biome.GROVE;
|
|
}
|
|
if (temperature > 0 && temperature < 4) {
|
|
return MiddleBiome.getBiome(humidity, temperature, weirdness);
|
|
}
|
|
return BadlandBiome.getBiome(humidity, weirdness);
|
|
} else if (erosion == 2 || erosion == 3 || erosion == 4) {
|
|
return PlateauBiome.getBiome(humidity, temperature, weirdness);
|
|
} else if (erosion == 4 || erosion == 6) {
|
|
return MiddleBiome.getBiome(humidity, temperature, weirdness);
|
|
}
|
|
return ShatteredBiome.getBiome(humidity, temperature, weirdness);
|
|
}
|
|
|
|
private @NonNull Biome nearInlandBiome(int humidity, int temperature, int erosion, double weirdness) {
|
|
return switch (Ridges.getRidge(convertToY(weirdness))) {
|
|
case HIGH -> getHighNearInlandBiome(humidity, temperature, erosion, weirdness);
|
|
case LOW -> getLowNearInlandBiome(humidity, temperature, erosion, weirdness);
|
|
case MID -> getMidNearInlandBiome(humidity, temperature, erosion, weirdness);
|
|
case PEAKS -> getPeaksNearInlandBiome(humidity, temperature, erosion, weirdness);
|
|
default -> getValleysNearInlandBiome(humidity, temperature, erosion, weirdness);
|
|
};
|
|
}
|
|
|
|
private @NonNull Biome getPeaksNearInlandBiome(int humidity, int temperature, int erosion, double weirdness) {
|
|
if (erosion == 0) {
|
|
if (temperature >= 0 && temperature <= 2) {
|
|
if (weirdness < 0) {
|
|
return Biome.JAGGED_PEAKS;
|
|
} else {
|
|
return Biome.FROZEN_PEAKS;
|
|
}
|
|
} else if (temperature == 3) {
|
|
return Biome.STONY_PEAKS;
|
|
}
|
|
return BadlandBiome.getBiome(humidity, weirdness);
|
|
|
|
} else if (erosion == 1) {
|
|
if (temperature == 0 && (humidity == 0 || humidity == 1)) {
|
|
return Biome.SNOWY_SLOPES;
|
|
} else if (temperature == 0 && humidity > 1) {
|
|
return Biome.GROVE;
|
|
} else if (temperature < 4) {
|
|
return MiddleBiome.getBiome(humidity, temperature, weirdness);
|
|
}
|
|
return BadlandBiome.getBiome(humidity, weirdness);
|
|
} else if (erosion >= 2 && erosion <= 4) {
|
|
// Middle biomes
|
|
return MiddleBiome.getBiome(humidity, temperature, weirdness);
|
|
} else if (erosion == 5) {
|
|
if (weirdness < 0 && (temperature == 0 || temperature == 1 || humidity == 4)) {
|
|
// Shattered biomes
|
|
return ShatteredBiome.getBiome(humidity, temperature, weirdness);
|
|
}
|
|
if (weirdness > 0 && (temperature > 2 && temperature <= 4 && humidity >= 0 && humidity <= 4)) {
|
|
return Biome.WINDSWEPT_SAVANNA;
|
|
}
|
|
}
|
|
// middle biomes
|
|
return MiddleBiome.getBiome(humidity, temperature, weirdness);
|
|
}
|
|
|
|
private @NonNull Biome getMidNearInlandBiome(int humidity, int temperature, int erosion, double weirdness) {
|
|
if (erosion == 0) {
|
|
if (temperature < 3 && (humidity == 0 || humidity == 1)) {
|
|
return Biome.SNOWY_SLOPES;
|
|
}
|
|
if (temperature < 3 && (humidity == 2 || humidity == 3 || humidity == 4)) {
|
|
return Biome.GROVE;
|
|
}
|
|
return PlateauBiome.getBiome(humidity, temperature, weirdness);
|
|
} else if (erosion == 1) {
|
|
if (temperature == 0 && (humidity == 0 || humidity == 1)) {
|
|
return Biome.SNOWY_SLOPES;
|
|
}
|
|
if (temperature == 0 && (humidity == 2 || humidity == 3 || humidity == 4)) {
|
|
return Biome.GROVE;
|
|
}
|
|
if (temperature > 0 && temperature < 4) {
|
|
return MiddleBiome.getBiome(humidity, temperature, weirdness);
|
|
}
|
|
return BadlandBiome.getBiome(humidity, weirdness);
|
|
} else if (erosion >= 2 && erosion <= 4) {
|
|
// Middle biomes
|
|
return MiddleBiome.getBiome(humidity, temperature, weirdness);
|
|
} else if (erosion == 5) {
|
|
if (weirdness < 0 && (temperature == 0 || temperature == 1) || humidity == 4) {
|
|
// Middle biomes
|
|
return MiddleBiome.getBiome(humidity, temperature, weirdness);
|
|
}
|
|
if (weirdness > 0 && (temperature > 2 && temperature <= 4 && humidity >= 0 && humidity <= 4)) {
|
|
return Biome.WINDSWEPT_SAVANNA;
|
|
}
|
|
}
|
|
if (temperature == 0) {
|
|
// Middle Biomes
|
|
return MiddleBiome.getBiome(humidity, temperature, weirdness);
|
|
}
|
|
if (temperature == 1 || temperature == 2) {
|
|
return Biome.SWAMP;
|
|
}
|
|
return Biome.MANGROVE_SWAMP;
|
|
}
|
|
|
|
private @NonNull Biome getLowNearInlandBiome(int humidity, int temperature, int erosion, double weirdness) {
|
|
if (erosion >= 0 && erosion < 2) {
|
|
if (temperature < 4) {
|
|
return MiddleBiome.getBiome(humidity, temperature, weirdness);
|
|
}
|
|
return BadlandBiome.getBiome(humidity, weirdness);
|
|
} else if (erosion >= 2 && erosion < 5) {
|
|
// Middle Biomes
|
|
return MiddleBiome.getBiome(humidity, temperature, weirdness);
|
|
} else if (erosion == 5) {
|
|
if (weirdness < 0 && (temperature == 0 || temperature == 1 || humidity == 4)) {
|
|
// Middle biomes
|
|
return MiddleBiome.getBiome(humidity, temperature, weirdness);
|
|
}
|
|
if (weirdness > 0 && (temperature > 2 && temperature <= 4 && humidity >= 0 && humidity <= 4)) {
|
|
return Biome.WINDSWEPT_SAVANNA;
|
|
}
|
|
}
|
|
if (temperature == 0) {
|
|
return MiddleBiome.getBiome(humidity, temperature, weirdness);
|
|
} else if (temperature == 1 || temperature == 2) {
|
|
return Biome.SWAMP;
|
|
}
|
|
return Biome.MANGROVE_SWAMP;
|
|
}
|
|
|
|
private @NonNull Biome getHighNearInlandBiome(int humidity, int temperature, int erosion, double weirdness) {
|
|
if (erosion == 0) {
|
|
if (temperature < 3 && (humidity == 0 || humidity == 1)) {
|
|
return Biome.SNOWY_SLOPES;
|
|
}
|
|
if (temperature < 3 && (humidity == 2 || humidity == 3 || humidity == 4)) {
|
|
return Biome.GROVE;
|
|
}
|
|
return PlateauBiome.getBiome(humidity, temperature, weirdness);
|
|
} else if (erosion == 1) {
|
|
if (temperature == 0 && (humidity == 0 || humidity == 1)) {
|
|
return Biome.SNOWY_SLOPES;
|
|
}
|
|
if (temperature == 0 && (humidity == 2 || humidity == 3 || humidity == 4)) {
|
|
return Biome.GROVE;
|
|
}
|
|
if (temperature > 0 && temperature < 4) {
|
|
return MiddleBiome.getBiome(humidity, temperature, weirdness);
|
|
}
|
|
return BadlandBiome.getBiome(humidity, weirdness);
|
|
} else if (erosion >= 2 && erosion <= 4) {
|
|
// Middle biomes
|
|
return MiddleBiome.getBiome(humidity, temperature, weirdness);
|
|
} else if (erosion == 5) {
|
|
if (weirdness < 0 && (temperature == 0 || temperature == 1) || humidity == 4) {
|
|
// Middle biomes
|
|
return MiddleBiome.getBiome(humidity, temperature, weirdness);
|
|
}
|
|
if (weirdness > 0 && (temperature > 2 && temperature <= 4 && humidity >= 0 && humidity <= 4)) {
|
|
return Biome.WINDSWEPT_SAVANNA;
|
|
}
|
|
}
|
|
return MiddleBiome.getBiome(humidity, temperature, weirdness);
|
|
}
|
|
|
|
private @NonNull Biome midInlandBiome(int humidity, int temperature, int erosion, double weirdness) {
|
|
return switch (Ridges.getRidge(convertToY(weirdness))) {
|
|
case HIGH -> getHighMidInlandBiome(humidity, temperature, erosion, weirdness);
|
|
case LOW -> getLowMidInlandBiome(humidity, temperature, erosion, weirdness);
|
|
case MID -> getMidMidInlandBiome(humidity, temperature, erosion, weirdness);
|
|
case PEAKS -> getPeaksMidInlandBiome(humidity, temperature, erosion, weirdness);
|
|
default -> getValleysMidInlandBiome(humidity, temperature, erosion, weirdness);
|
|
};
|
|
}
|
|
|
|
private @NonNull Biome getValleysMidInlandBiome(int humidity, int temperature, int erosion, double weirdness) {
|
|
if (erosion == 0 || erosion == 1) {
|
|
if (temperature < 4) {
|
|
return MiddleBiome.getBiome(humidity, temperature, weirdness);
|
|
} else {
|
|
return BadlandBiome.getBiome(humidity, weirdness);
|
|
}
|
|
}
|
|
if (erosion >= 2 && erosion <= 5) {
|
|
if (temperature == 0) {
|
|
return Biome.FROZEN_RIVER;
|
|
} else {
|
|
return Biome.RIVER;
|
|
}
|
|
}
|
|
if (temperature == 0) {
|
|
return Biome.FROZEN_RIVER;
|
|
}
|
|
if (temperature == 1 || temperature == 2) {
|
|
return Biome.SWAMP;
|
|
}
|
|
return Biome.MANGROVE_SWAMP;
|
|
}
|
|
|
|
private @NonNull Biome getPeaksMidInlandBiome(int humidity, int temperature, int erosion, double weirdness) {
|
|
if (erosion == 0 || erosion == 1) {
|
|
if (temperature >= 0 && temperature <= 2) {
|
|
if (weirdness < 0) {
|
|
return Biome.JAGGED_PEAKS;
|
|
} else {
|
|
return Biome.FROZEN_PEAKS;
|
|
}
|
|
} else if (temperature == 3) {
|
|
return Biome.STONY_PEAKS;
|
|
}
|
|
return BadlandBiome.getBiome(humidity, weirdness);
|
|
|
|
} else if (erosion == 2) {
|
|
return PlateauBiome.getBiome(humidity, temperature, weirdness);
|
|
} else if (erosion == 3) {
|
|
if (temperature < 4) {
|
|
// Middle biomes
|
|
return MiddleBiome.getBiome(humidity, temperature, weirdness);
|
|
}
|
|
return BadlandBiome.getBiome(humidity, weirdness);
|
|
} else if (erosion == 4 || erosion == 6) {
|
|
return MiddleBiome.getBiome(humidity, temperature, weirdness);
|
|
}
|
|
return ShatteredBiome.getBiome(humidity, temperature, weirdness);
|
|
}
|
|
|
|
private @NonNull Biome getMidMidInlandBiome(int humidity, int temperature, int erosion, double weirdness) {
|
|
if (erosion == 0) {
|
|
if (temperature < 3 && (humidity == 0 || humidity == 1)) {
|
|
return Biome.SNOWY_SLOPES;
|
|
}
|
|
if (temperature < 3 && (humidity == 2 || humidity == 3 || humidity == 4)) {
|
|
return Biome.GROVE;
|
|
}
|
|
return PlateauBiome.getBiome(humidity, temperature, weirdness);
|
|
} else if (erosion == 1) {
|
|
if (temperature == 0 && (humidity == 0 || humidity == 1)) {
|
|
return Biome.SNOWY_SLOPES;
|
|
}
|
|
if (temperature == 0 && (humidity == 2 || humidity == 3 || humidity == 4)) {
|
|
return Biome.GROVE;
|
|
}
|
|
if (temperature > 0 && temperature < 4) {
|
|
return MiddleBiome.getBiome(humidity, temperature, weirdness);
|
|
}
|
|
return BadlandBiome.getBiome(humidity, weirdness);
|
|
} else if (erosion == 2 || erosion == 3) {
|
|
if (temperature < 4) {
|
|
return MiddleBiome.getBiome(humidity, temperature, weirdness);
|
|
}
|
|
return BadlandBiome.getBiome(humidity, weirdness);
|
|
} else if (erosion == 4) {
|
|
// Middle biomes
|
|
return MiddleBiome.getBiome(humidity, temperature, weirdness);
|
|
} else if (erosion == 5) {
|
|
return ShatteredBiome.getBiome(humidity, temperature, weirdness);
|
|
}
|
|
if (temperature == 0) {
|
|
// Middle Biomes
|
|
return MiddleBiome.getBiome(humidity, temperature, weirdness);
|
|
}
|
|
if (temperature == 1 || temperature == 2) {
|
|
return Biome.SWAMP;
|
|
}
|
|
return Biome.MANGROVE_SWAMP;
|
|
}
|
|
|
|
private @NonNull Biome getLowMidInlandBiome(int humidity, int temperature, int erosion, double weirdness) {
|
|
if (erosion == 0 || erosion == 1) {
|
|
if (temperature == 0 && (humidity == 0 || humidity == 1)) {
|
|
return Biome.SNOWY_SLOPES;
|
|
} else if (temperature == 0 && humidity > 1) {
|
|
return Biome.GROVE;
|
|
} else if (temperature < 4) {
|
|
return MiddleBiome.getBiome(humidity, temperature, weirdness);
|
|
}
|
|
return BadlandBiome.getBiome(humidity, weirdness);
|
|
}
|
|
if (erosion == 2 || erosion == 3) {
|
|
if (temperature < 4) {
|
|
return MiddleBiome.getBiome(humidity, temperature, weirdness);
|
|
}
|
|
return BadlandBiome.getBiome(humidity, weirdness);
|
|
}
|
|
// e == 6
|
|
if (temperature == 0) {
|
|
// Middle Biomes
|
|
return MiddleBiome.getBiome(humidity, temperature, weirdness);
|
|
}
|
|
if (temperature == 1 || temperature == 2) {
|
|
return Biome.SWAMP;
|
|
}
|
|
return Biome.MANGROVE_SWAMP;
|
|
}
|
|
|
|
private @NonNull Biome getHighMidInlandBiome(int humidity, int temperature, int erosion, double weirdness) {
|
|
if (erosion == 0) {
|
|
if (temperature < 3 && weirdness < 0D) {
|
|
return Biome.JAGGED_PEAKS;
|
|
}
|
|
if (temperature < 3 && weirdness > 0.0D) {
|
|
return Biome.FROZEN_PEAKS;
|
|
}
|
|
if (temperature == 3) {
|
|
return Biome.STONY_PEAKS;
|
|
}
|
|
return BadlandBiome.getBiome(humidity, weirdness);
|
|
} else if (erosion == 1) {
|
|
if (temperature < 3 && (humidity == 0 || humidity == 1)) {
|
|
return Biome.SNOWY_SLOPES;
|
|
}
|
|
if (temperature < 3 && (humidity == 2 || humidity == 3 || humidity == 4)) {
|
|
return Biome.GROVE;
|
|
}
|
|
return PlateauBiome.getBiome(humidity, temperature, weirdness);
|
|
} else if (erosion == 2) {
|
|
return PlateauBiome.getBiome(humidity, temperature, weirdness);
|
|
} else if (erosion == 3) {
|
|
if (temperature < 4) {
|
|
// Middle biomes
|
|
return MiddleBiome.getBiome(humidity, temperature, weirdness);
|
|
}
|
|
return BadlandBiome.getBiome(humidity, weirdness);
|
|
} else if (erosion == 4) {
|
|
// Middle biomes
|
|
return MiddleBiome.getBiome(humidity, temperature, weirdness);
|
|
} else if (erosion == 5) {
|
|
return ShatteredBiome.getBiome(humidity, temperature, weirdness);
|
|
}
|
|
return MiddleBiome.getBiome(humidity, temperature, weirdness);
|
|
}
|
|
|
|
private @NonNull Biome coastBiome(int humidity, int temperature, int erosion, double weirdness) {
|
|
return switch (Ridges.getRidge(convertToY(weirdness))) {
|
|
case HIGH -> getHighCoastBionme(humidity, temperature, erosion, weirdness);
|
|
case LOW -> getLowCoastBionme(humidity, temperature, erosion, weirdness);
|
|
case MID -> getMidCoastBionme(humidity, temperature, erosion, weirdness);
|
|
case PEAKS -> getPeaksCoastBionme(humidity, temperature, erosion, weirdness);
|
|
default -> getValleysCoastBionme(humidity, temperature, erosion, weirdness);
|
|
};
|
|
}
|
|
|
|
private @NonNull Biome getValleysCoastBionme(int humidity, int temperature, int erosion, double weirdness) {
|
|
if (temperature > 0D) {
|
|
return Biome.RIVER;
|
|
}
|
|
return Biome.FROZEN_RIVER;
|
|
}
|
|
|
|
private @NonNull Biome getPeaksCoastBionme(int humidity, int temperature, int erosion, double weirdness) {
|
|
if (erosion == 0) {
|
|
if (temperature >= 0 && temperature <= 2) {
|
|
if (weirdness < 0) {
|
|
return Biome.JAGGED_PEAKS;
|
|
} else {
|
|
return Biome.FROZEN_PEAKS;
|
|
}
|
|
} else if (temperature == 3) {
|
|
return Biome.STONY_PEAKS;
|
|
}
|
|
return BadlandBiome.getBiome(humidity, weirdness);
|
|
|
|
} else if (erosion == 1) {
|
|
if (temperature == 0 && (humidity == 0 || humidity == 1)) {
|
|
return Biome.SNOWY_SLOPES;
|
|
} else if (temperature == 0 && humidity > 1) {
|
|
return Biome.GROVE;
|
|
} else if (temperature < 4) {
|
|
return MiddleBiome.getBiome(humidity, temperature, weirdness);
|
|
}
|
|
return BadlandBiome.getBiome(humidity, weirdness);
|
|
} else if (erosion >= 2 && erosion <= 4) {
|
|
// Middle biomes
|
|
return MiddleBiome.getBiome(humidity, temperature, weirdness);
|
|
} else if (erosion == 5) {
|
|
if (weirdness < 0 && (temperature == 0 || temperature == 1 || humidity == 4)) {
|
|
// Shattered biomes
|
|
return ShatteredBiome.getBiome(humidity, temperature, weirdness);
|
|
}
|
|
if (weirdness > 0 && (temperature > 2 && temperature <= 4 && humidity >= 0 && humidity <= 4)) {
|
|
return Biome.WINDSWEPT_SAVANNA;
|
|
}
|
|
}
|
|
// middle biomes
|
|
return MiddleBiome.getBiome(humidity, temperature, weirdness);
|
|
}
|
|
|
|
private @NonNull Biome getMidCoastBionme(int humidity, int temperature, int erosion, double weirdness) {
|
|
if (erosion > 0 && erosion < 3) {
|
|
return Biome.STONY_SHORE;
|
|
} else if (erosion == 3) {
|
|
// Middle Biomes
|
|
return MiddleBiome.getBiome(humidity, temperature, weirdness);
|
|
} else if (erosion == 4) {
|
|
if (weirdness < 0) {
|
|
// Beach Biomes
|
|
return getBeachBiome(temperature);
|
|
} else {
|
|
// Middle biomes
|
|
return MiddleBiome.getBiome(humidity, temperature, weirdness);
|
|
}
|
|
} else if (erosion == 5) {
|
|
if (weirdness < 0) {
|
|
// Beach Biomes
|
|
return getBeachBiome(temperature);
|
|
}
|
|
if (weirdness < 0 && (temperature == 0 || temperature == 1 || humidity == 4)) {
|
|
// Middle biomes
|
|
return MiddleBiome.getBiome(humidity, temperature, weirdness);
|
|
}
|
|
if (weirdness > 0 && (temperature > 2 && temperature <= 4 && humidity >= 0 && humidity <= 4)) {
|
|
return Biome.WINDSWEPT_SAVANNA;
|
|
}
|
|
|
|
} else if (erosion == 6) {
|
|
if (weirdness < 0D) {
|
|
// Beach Biomes
|
|
return getBeachBiome(temperature);
|
|
} else {
|
|
// Middle Biomes
|
|
return MiddleBiome.getBiome(humidity, temperature, weirdness);
|
|
}
|
|
}
|
|
// Else Beach biomes
|
|
return getBeachBiome(temperature);
|
|
}
|
|
|
|
private @NonNull Biome getLowCoastBionme(int humidity, int temperature, int erosion, double weirdness) {
|
|
if (erosion >= 0 && erosion < 3) {
|
|
return Biome.STONY_SHORE;
|
|
} else if (erosion >= 3 && erosion < 5) {
|
|
// Beach Biomes
|
|
return getBeachBiome(temperature);
|
|
} else if (erosion == 5) {
|
|
if (weirdness < 0) {
|
|
// Beach Biomes
|
|
return getBeachBiome(temperature);
|
|
}
|
|
if (weirdness < 0 && (temperature == 0 || temperature == 1 || humidity == 4)) {
|
|
// Middle biomes
|
|
return MiddleBiome.getBiome(humidity, temperature, weirdness);
|
|
}
|
|
if (weirdness > 0 && (temperature > 2 && temperature <= 4 && humidity >= 0 && humidity <= 4)) {
|
|
return Biome.WINDSWEPT_SAVANNA;
|
|
}
|
|
}
|
|
// Else Beach biomes
|
|
return getBeachBiome(temperature);
|
|
}
|
|
|
|
private @NonNull Biome getHighCoastBionme(int humidity, int temperature, int erosion, double weirdness) {
|
|
if (erosion >= 0 && erosion < 5) {
|
|
// Middle Biomes
|
|
return MiddleBiome.getBiome(humidity, temperature, weirdness);
|
|
} else if (erosion == 5) {
|
|
if (weirdness < 0 && (temperature == 0 || temperature == 1 || humidity == 4)) {
|
|
// Middle biomes
|
|
return MiddleBiome.getBiome(humidity, temperature, weirdness);
|
|
}
|
|
if (weirdness > 0 && (temperature > 2 && temperature <= 4 && humidity >= 0 && humidity <= 4)) {
|
|
return Biome.WINDSWEPT_SAVANNA;
|
|
}
|
|
}
|
|
// Middle Biomes
|
|
return MiddleBiome.getBiome(humidity, temperature, weirdness);
|
|
}
|
|
|
|
Biome getBeachBiome(int t) {
|
|
return switch (t) {
|
|
case 0 -> Biome.SNOWY_BEACH;
|
|
case 4 -> Biome.DESERT;
|
|
default -> Biome.BEACH;
|
|
};
|
|
}
|
|
|
|
public static double convertToY(double x) {
|
|
x = Math.max(-1, Math.min(1, x)); // Clamp value
|
|
if (x >= -1 && x < -0.5) {
|
|
return 2 * x + 1;
|
|
} else if (x >= -0.5 && x < 0) {
|
|
return -2 * x;
|
|
} else if (x >= 0 && x < 0.5) {
|
|
return 2 * x;
|
|
} else if (x >= 0.5 && x <= 1) {
|
|
return -2 * x + 1;
|
|
} else {
|
|
throw new IllegalArgumentException("Invalid x value. x must be in the range [-1, 1]. Value = " + x);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the mapped 2D biome at position x,z
|
|
* @param worldInfo world info
|
|
* @param x - block coord
|
|
* @param y - block coord
|
|
* @param z - block coord
|
|
* @param biomeParameterPoint
|
|
* @return Biome
|
|
*/
|
|
private Biome getMappedBiome(WorldInfo worldInfo, int x, int y, int z, BiomeParameterPoint biomeParameterPoint) {
|
|
/*
|
|
* Biomes go around the island centers
|
|
*
|
|
*/
|
|
|
|
Vector s = new Vector(x, 0, z);
|
|
Vector l = new Vector(spawnX, 0, spawnZ);
|
|
double dis = l.distance(s);
|
|
if (dis > dist * 2) {
|
|
// Only customize biomes around the spawn location
|
|
return getVanillaBiome(worldInfo, x, y, z, biomeParameterPoint, null);
|
|
}
|
|
// Provide custom biomes
|
|
Biome result;
|
|
double d = dis / dist; // Normalize
|
|
Vector direction = s.subtract(l);
|
|
if (direction.getBlockX() <= 0 && direction.getBlockZ() <= 0) {
|
|
result = getQuadrantBiome(BlockFace.NORTH_WEST, d);
|
|
} else if (direction.getBlockX() > 0 && direction.getBlockZ() <= 0) {
|
|
result = getQuadrantBiome(BlockFace.NORTH_EAST, d);
|
|
} else if (direction.getBlockX() <= 0 && direction.getBlockZ() > 0) {
|
|
result = getQuadrantBiome(BlockFace.SOUTH_WEST, d);
|
|
} else {
|
|
result = getQuadrantBiome(BlockFace.SOUTH_EAST, d);
|
|
}
|
|
|
|
if (result == null || result.equals(Biome.CUSTOM)) {
|
|
result = getVanillaBiome(worldInfo, x, y, z, biomeParameterPoint, null);
|
|
|
|
}
|
|
|
|
// Caves
|
|
if (biomeParameterPoint.getDepth() > 0.2) {
|
|
result = getVanillaBiome(worldInfo, x, y, z, biomeParameterPoint, null);
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
@Override
|
|
public List<Biome> getBiomes(WorldInfo worldInfo) {
|
|
// Return all of them for now!
|
|
return Arrays.stream(Biome.values()).filter(b -> !b.equals(Biome.CUSTOM)).toList();
|
|
}
|
|
|
|
/**
|
|
* Loads the custom biomes from the config file
|
|
* @param config - Yaml configuration object
|
|
* @param sector - the direction section to load
|
|
* @return sorted map of the biomes and their probabilities as keys
|
|
*/
|
|
private SortedMap<Double, Biome> loadQuad(YamlConfiguration config, String sector) {
|
|
SortedMap<Double, Biome> result = new TreeMap<>();
|
|
if (!config.contains(sector)) {
|
|
return result;
|
|
}
|
|
for (String ring : config.getStringList(sector)) {
|
|
String[] split = ring.split(":");
|
|
if (split.length == 2) {
|
|
try {
|
|
double d = Double.parseDouble(split[0]);
|
|
Biome biome = Enums.getIfPresent(Biome.class, split[1].toUpperCase(Locale.ENGLISH)).orNull();
|
|
if (biome == null) {
|
|
addon.logError(split[1].toUpperCase(Locale.ENGLISH) + " is an unknown biome on this server.");
|
|
result.put(d, Biome.CUSTOM);
|
|
} else {
|
|
// A biome of null means that no alternative biome should be applied
|
|
result.put(d, biome);
|
|
}
|
|
} catch (Exception e) {
|
|
addon.logError(sector + ": " + split[0]
|
|
+ " does not seem to be a double. For integers add a .0 to the end");
|
|
}
|
|
} else {
|
|
addon.logError(ring + " must be in the format ratio:biome where ratio is a double.");
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
}
|