- ) tag;
}
/**
* Adds {@link Block} to NETHER_GROUND and GEN_TERRAIN tags to process it properly in terrain generators and block logic.
+ *
* @param block - {@link Block}.
*/
public static void addNetherGround(Block block) {
- TagHelper.addTag(NETHER_GROUND, block);
- TagHelper.addTag(GEN_TERRAIN, block);
+ addTag(BLOCK_NETHER_GROUND, block);
+ addTag(BLOCK_GEN_TERRAIN, block);
}
/**
* Adds {@link Block} to END_GROUND and GEN_TERRAIN tags to process it properly in terrain generators and block logic.
+ *
* @param block - {@link Block}.
*/
public static void addEndGround(Block block) {
- TagHelper.addTag(GEN_TERRAIN, block);
- TagHelper.addTag(END_GROUND, block);
+ addTag(BLOCK_GEN_TERRAIN, block);
+ addTag(BLOCK_END_GROUND, block);
}
/**
* Initializes basic tags. Should be called only in BCLib main class.
*/
public static void init() {
- TagHelper.addTag(BOOKSHELVES, Blocks.BOOKSHELF);
- TagHelper.addTag(GEN_TERRAIN, Blocks.END_STONE, Blocks.NETHERRACK, Blocks.SOUL_SAND, Blocks.SOUL_SOIL);
- TagHelper.addTag(NETHER_GROUND, Blocks.NETHERRACK, Blocks.SOUL_SAND, Blocks.SOUL_SOIL);
- TagHelper.addTag(END_GROUND, Blocks.END_STONE);
- TagHelper.addTag(BLOCK_CHEST, Blocks.CHEST);
- TagHelper.addTag(ITEM_CHEST, Items.CHEST);
- TagHelper.addTag(IRON_INGOTS, Items.IRON_INGOT);
- TagHelper.addTag(FURNACES, Blocks.FURNACE);
+ addTag(BLOCK_BOOKSHELVES, Blocks.BOOKSHELF);
+ addTag(BLOCK_GEN_TERRAIN, Blocks.END_STONE, Blocks.NETHERRACK, Blocks.SOUL_SAND, Blocks.SOUL_SOIL);
+ addTag(BLOCK_NETHER_GROUND, Blocks.NETHERRACK, Blocks.SOUL_SAND, Blocks.SOUL_SOIL);
+ addTag(BLOCK_END_GROUND, Blocks.END_STONE);
+ addTag(BLOCK_CHEST, Blocks.CHEST);
+ addTag(ITEM_CHEST, Items.CHEST);
+ addTag(ITEM_IRON_INGOTS, Items.IRON_INGOT);
+ addTag(ITEM_FURNACES, Blocks.FURNACE);
+ }
+
+ /**
+ * Adds one Tag to multiple Blocks.
+ *
+ * Example:
+ *
{@code Tag.Named DIMENSION_STONE = makeBlockTag("mymod", "dim_stone");
+ * addTag(DIMENSION_STONE, Blocks.END_STONE, Blocks.NETHERRACK);}
+ *
+ * The call will reserve the Tag. The Tag is added to the blocks once
+ * {@link #apply(String, Map)} was executed.
+ *
+ * @param tag The new Tag
+ * @param blocks One or more blocks that should receive the Tag.
+ */
+ public static void addTag(Tag.Named tag, Block... blocks) {
+ ResourceLocation tagID = tag.getName();
+ Set set = TAGS_BLOCK.computeIfAbsent(tagID, k -> Sets.newHashSet());
+ for (Block block : blocks) {
+ ResourceLocation id = Registry.BLOCK.getKey(block);
+ if (id != Registry.BLOCK.getDefaultKey()) {
+ set.add(id);
+ }
+ }
+ }
+
+ /**
+ * Adds one Tag to multiple Items.
+ *
+ * Example:
+ *
{@code Tag.Named- METALS = makeBlockTag("mymod", "metals");
+ * addTag(METALS, Items.IRON_INGOT, Items.GOLD_INGOT, Items.COPPER_INGOT);}
+ *
+ * The call will reserve the Tag. The Tag is added to the items once
+ * {@link #apply(String, Map)} was executed.
+ *
+ * @param tag The new Tag
+ * @param items One or more item that should receive the Tag.
+ */
+ public static void addTag(Tag.Named- tag, ItemLike... items) {
+ ResourceLocation tagID = tag.getName();
+ Set set = TAGS_ITEM.computeIfAbsent(tagID, k -> Sets.newHashSet());
+ for (ItemLike item : items) {
+ ResourceLocation id = Registry.ITEM.getKey(item.asItem());
+ if (id != Registry.ITEM.getDefaultKey()) {
+ set.add(id);
+ }
+ }
+ }
+
+ /**
+ * Adds multiple Tags to one Item.
+ *
+ * The call will reserve the Tags. The Tags are added to the Item once
+ * * {@link #apply(String, Map)} was executed.
+ *
+ * @param item The Item that will receive all Tags
+ * @param tags One or more Tags
+ */
+ @SafeVarargs
+ public static void addTags(ItemLike item, Tag.Named- ... tags) {
+ for (Tag.Named
- tag : tags) {
+ addTag(tag, item);
+ }
+ }
+
+ /**
+ * Adds multiple Tags to one Block.
+ *
+ * The call will reserve the Tags. The Tags are added to the Block once
+ * * {@link #apply(String, Map)} was executed.
+ *
+ * @param block The Block that will receive all Tags
+ * @param tags One or more Tags
+ */
+ @SafeVarargs
+ public static void addTags(Block block, Tag.Named... tags) {
+ for (Tag.Named tag : tags) {
+ addTag(tag, block);
+ }
+ }
+
+ /**
+ * Adds all {@code ids} to the {@code builder}.
+ *
+ * @param builder
+ * @param ids
+ * @return The Builder passed as {@code builder}.
+ */
+ public static Tag.Builder apply(Tag.Builder builder, Set ids) {
+ ids.forEach(value -> builder.addElement(value, "Better End Code"));
+ return builder;
+ }
+
+ /**
+ * Automatically called in {@link net.minecraft.tags.TagLoader#loadAndBuild(ResourceManager)}.
+ *
+ * In most cases there is no need to call this Method manually.
+ *
+ * @param directory The name of the Tag-directory. Should be either "tags/blocks" or
+ * "tags/items".
+ * @param tagsMap The map that will hold the registered Tags
+ * @return The {@code tagsMap} Parameter.
+ */
+ public static Map apply(String directory, Map tagsMap) {
+ Map> endTags = null;
+ if ("tags/blocks".equals(directory)) {
+ endTags = TAGS_BLOCK;
+ }
+ else if ("tags/items".equals(directory)) {
+ endTags = TAGS_ITEM;
+ }
+ if (endTags != null) {
+ endTags.forEach((id, ids) -> apply(tagsMap.computeIfAbsent(id, key -> Tag.Builder.tag()), ids));
+ }
+ return tagsMap;
}
}
diff --git a/src/main/java/ru/bclib/api/WorldDataAPI.java b/src/main/java/ru/bclib/api/WorldDataAPI.java
index 6927c9ed..d15cf43b 100644
--- a/src/main/java/ru/bclib/api/WorldDataAPI.java
+++ b/src/main/java/ru/bclib/api/WorldDataAPI.java
@@ -1,20 +1,30 @@
package ru.bclib.api;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import net.fabricmc.loader.api.FabricLoader;
+import net.fabricmc.loader.api.ModContainer;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.nbt.NbtIo;
+import net.minecraft.world.level.storage.LevelStorageSource.LevelStorageAccess;
+import ru.bclib.BCLib;
+import ru.bclib.api.datafixer.DataFixerAPI;
+import ru.bclib.util.ModUtil;
+
import java.io.File;
import java.io.IOException;
import java.util.List;
import java.util.Map;
import java.util.Optional;
+import java.util.function.Consumer;
-import com.google.common.collect.Lists;
-import com.google.common.collect.Maps;
-
-import net.fabricmc.loader.api.FabricLoader;
-import net.fabricmc.loader.api.ModContainer;
-import net.minecraft.nbt.CompoundTag;
-import net.minecraft.nbt.NbtIo;
-import ru.bclib.BCLib;
-
+/**
+ * Mod-specifix data-storage for a world.
+ *
+ * This class provides the ability for mod to store persistent data inside a world. The Storage for the world is
+ * currently initialized as part of the {@link DataFixerAPI} in {@link DataFixerAPI#fixData(LevelStorageAccess, boolean, Consumer)}
+ * or {@link DataFixerAPI#initializeWorldData(File, boolean)}
+ */
public class WorldDataAPI {
private static final Map TAGS = Maps.newHashMap();
private static final List MODS = Lists.newArrayList();
@@ -22,36 +32,43 @@ public class WorldDataAPI {
public static void load(File dataDir) {
WorldDataAPI.dataDir = dataDir;
- MODS.stream().parallel().forEach(modID -> {
- File file = new File(dataDir, modID + ".nbt");
- CompoundTag root = new CompoundTag();
- TAGS.put(modID, root);
- if (file.exists()) {
- try {
- root = NbtIo.readCompressed(file);
- }
- catch (IOException e) {
- BCLib.LOGGER.error("World data loading failed", e);
- }
- }
- else {
- Optional optional = FabricLoader.getInstance().getModContainer(modID);
- if (optional.isPresent()) {
- ModContainer modContainer = optional.get();
- if (BCLib.isDevEnvironment()) {
- root.putString("version", "63.63.63");
+ MODS.stream()
+ .parallel()
+ .forEach(modID -> {
+ File file = new File(dataDir, modID + ".nbt");
+ CompoundTag root = new CompoundTag();
+ if (file.exists()) {
+ try {
+ root = NbtIo.readCompressed(file);
}
- else {
- root.putString("version", modContainer.getMetadata().getVersion().toString());
+ catch (IOException e) {
+ BCLib.LOGGER.error("World data loading failed", e);
}
- saveFile(modID);
+ TAGS.put(modID, root);
}
- }
- });
+ else {
+ Optional optional = FabricLoader.getInstance()
+ .getModContainer(modID);
+ if (optional.isPresent()) {
+ ModContainer modContainer = optional.get();
+ if (BCLib.isDevEnvironment()) {
+ root.putString("version", "255.255.9999");
+ }
+ else {
+ root.putString("version", modContainer.getMetadata()
+ .getVersion()
+ .toString());
+ }
+ TAGS.put(modID, root);
+ saveFile(modID);
+ }
+ }
+ });
}
/**
* Register mod cache, world cache is located in world data folder.
+ *
* @param modID - {@link String} modID.
*/
public static void registerModCache(String modID) {
@@ -60,6 +77,7 @@ public class WorldDataAPI {
/**
* Get root {@link CompoundTag} for mod cache in world data folder.
+ *
* @param modID - {@link String} modID.
* @return {@link CompoundTag}
*/
@@ -74,13 +92,14 @@ public class WorldDataAPI {
/**
* Get {@link CompoundTag} with specified path from mod cache in world data folder.
+ *
* @param modID - {@link String} path to tag, dot-separated.
* @return {@link CompoundTag}
*/
public static CompoundTag getCompoundTag(String modID, String path) {
String[] parts = path.split("\\.");
CompoundTag tag = getRootTag(modID);
- for (String part: parts) {
+ for (String part : parts) {
if (tag.contains(part)) {
tag = tag.getCompound(part);
}
@@ -95,10 +114,14 @@ public class WorldDataAPI {
/**
* Forces mod cache file to be saved.
+ *
* @param modID {@link String} mod ID.
*/
public static void saveFile(String modID) {
try {
+ if (!dataDir.exists()) {
+ dataDir.mkdirs();
+ }
NbtIo.writeCompressed(getRootTag(modID), new File(dataDir, modID + ".nbt"));
}
catch (IOException e) {
@@ -108,6 +131,7 @@ public class WorldDataAPI {
/**
* Get stored mod version (only for mods with registered cache).
+ *
* @return {@link String} mod version.
*/
public static String getModVersion(String modID) {
@@ -116,9 +140,10 @@ public class WorldDataAPI {
/**
* Get stored mod version as integer (only for mods with registered cache).
+ *
* @return {@code int} mod version.
*/
public static int getIntModVersion(String modID) {
- return DataFixerAPI.getModVersion(getModVersion(modID));
+ return ModUtil.convertModVersion(getModVersion(modID));
}
}
diff --git a/src/main/java/ru/bclib/api/biomes/BCLBiomeBuilder.java b/src/main/java/ru/bclib/api/biomes/BCLBiomeBuilder.java
new file mode 100644
index 00000000..eb53ef05
--- /dev/null
+++ b/src/main/java/ru/bclib/api/biomes/BCLBiomeBuilder.java
@@ -0,0 +1,599 @@
+package ru.bclib.api.biomes;
+
+import net.fabricmc.fabric.api.biome.v1.BiomeModifications;
+import net.minecraft.core.particles.ParticleOptions;
+import net.minecraft.data.BuiltinRegistries;
+import net.minecraft.data.worldgen.BiomeDefaultFeatures;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.sounds.Music;
+import net.minecraft.sounds.SoundEvent;
+import net.minecraft.util.Mth;
+import net.minecraft.world.entity.EntityType;
+import net.minecraft.world.entity.Mob;
+import net.minecraft.world.level.biome.AmbientAdditionsSettings;
+import net.minecraft.world.level.biome.AmbientMoodSettings;
+import net.minecraft.world.level.biome.AmbientParticleSettings;
+import net.minecraft.world.level.biome.Biome;
+import net.minecraft.world.level.biome.Biome.BiomeBuilder;
+import net.minecraft.world.level.biome.Biome.BiomeCategory;
+import net.minecraft.world.level.biome.Biome.Precipitation;
+import net.minecraft.world.level.biome.BiomeGenerationSettings;
+import net.minecraft.world.level.biome.BiomeSpecialEffects;
+import net.minecraft.world.level.biome.MobSpawnSettings;
+import net.minecraft.world.level.biome.MobSpawnSettings.SpawnerData;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.levelgen.GenerationStep;
+import net.minecraft.world.level.levelgen.GenerationStep.Decoration;
+import net.minecraft.world.level.levelgen.Noises;
+import net.minecraft.world.level.levelgen.SurfaceRules;
+import net.minecraft.world.level.levelgen.carver.ConfiguredWorldCarver;
+import net.minecraft.world.level.levelgen.feature.ConfiguredStructureFeature;
+import net.minecraft.world.level.levelgen.placement.PlacedFeature;
+import ru.bclib.util.ColorUtil;
+import ru.bclib.world.biomes.BCLBiome;
+import ru.bclib.world.features.BCLFeature;
+import ru.bclib.world.structures.BCLStructureFeature;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.BiFunction;
+import java.util.function.Consumer;
+
+public class BCLBiomeBuilder {
+ private static final BCLBiomeBuilder INSTANCE = new BCLBiomeBuilder();
+ private static final SurfaceRules.ConditionSource SURFACE_NOISE = SurfaceRules.noiseCondition(Noises.SOUL_SAND_LAYER, -0.012);
+
+ private List structures = new ArrayList<>(16);
+ private BiomeGenerationSettings.Builder generationSettings;
+ private BiomeSpecialEffects.Builder effectsBuilder;
+ private MobSpawnSettings.Builder spawnSettings;
+ private SurfaceRules.RuleSource surfaceRule;
+ private Precipitation precipitation;
+ private ResourceLocation biomeID;
+ private BiomeCategory category;
+ private float temperature;
+ private float fogDensity;
+ private float downfall;
+
+ /**
+ * Starts new biome building process.
+ * @param biomeID {@link ResourceLocation} biome identifier.
+ * @return prepared {@link BCLBiomeBuilder} instance.
+ */
+ public static BCLBiomeBuilder start(ResourceLocation biomeID) {
+ INSTANCE.biomeID = biomeID;
+ INSTANCE.precipitation = Precipitation.NONE;
+ INSTANCE.category = BiomeCategory.NONE;
+ INSTANCE.generationSettings = null;
+ INSTANCE.effectsBuilder = null;
+ INSTANCE.spawnSettings = null;
+ INSTANCE.structures.clear();
+ INSTANCE.temperature = 1.0F;
+ INSTANCE.fogDensity = 1.0F;
+ INSTANCE.downfall = 1.0F;
+ return INSTANCE;
+ }
+
+ /**
+ * Set biome {@link Precipitation}. Affect biome visual effects (rain, snow, none).
+ * @param precipitation {@link Precipitation}
+ * @return same {@link BCLBiomeBuilder} instance.
+ */
+ public BCLBiomeBuilder precipitation(Precipitation precipitation) {
+ this.precipitation = precipitation;
+ return this;
+ }
+
+ /**
+ * Set biome category. Doesn't affect biome worldgen, but Fabric biome modifications can target biome by it.
+ * @param category {@link BiomeCategory}
+ * @return same {@link BCLBiomeBuilder} instance.
+ */
+ public BCLBiomeBuilder category(BiomeCategory category) {
+ this.category = category;
+ return this;
+ }
+
+ /**
+ * Set biome temperature, affect plant color, biome generation and ice formation.
+ * @param temperature biome temperature.
+ * @return same {@link BCLBiomeBuilder} instance.
+ */
+ public BCLBiomeBuilder temperature(float temperature) {
+ this.temperature = temperature;
+ return this;
+ }
+
+ /**
+ * Set biome wetness (same as downfall). Affect plant color and biome generation.
+ * @param wetness biome wetness (downfall).
+ * @return same {@link BCLBiomeBuilder} instance.
+ */
+ public BCLBiomeBuilder wetness(float wetness) {
+ this.downfall = wetness;
+ return this;
+ }
+
+ /**
+ * Adds mob spawning to biome.
+ * @param entityType {@link EntityType} mob type.
+ * @param weight spawn weight.
+ * @param minGroupCount minimum mobs in group.
+ * @param maxGroupCount maximum mobs in group.
+ * @return same {@link BCLBiomeBuilder} instance.
+ */
+ public BCLBiomeBuilder spawn(EntityType entityType, int weight, int minGroupCount, int maxGroupCount) {
+ getSpawns().addSpawn(entityType.getCategory(), new SpawnerData(entityType, weight, minGroupCount, maxGroupCount));
+ return this;
+ }
+
+ /**
+ * Adds ambient particles to thr biome.
+ * @param particle {@link ParticleOptions} particles (or {@link net.minecraft.core.particles.ParticleType}).
+ * @param probability particle spawn probability, should have low value (example: 0.01F).
+ * @return same {@link BCLBiomeBuilder} instance.
+ */
+ public BCLBiomeBuilder particles(ParticleOptions particle, float probability) {
+ getEffects().ambientParticle(new AmbientParticleSettings(particle, probability));
+ return this;
+ }
+
+ /**
+ * Sets sky color for the biome. Color is in ARGB int format.
+ * @param color ARGB color as integer.
+ * @return same {@link BCLBiomeBuilder} instance.
+ */
+ public BCLBiomeBuilder skyColor(int color) {
+ getEffects().skyColor(color);
+ return this;
+ }
+
+ /**
+ * Sets sky color for the biome. Color represented as red, green and blue channel values.
+ * @param red red color component [0-255]
+ * @param green green color component [0-255]
+ * @param blue blue color component [0-255]
+ * @return same {@link BCLBiomeBuilder} instance.
+ */
+ public BCLBiomeBuilder skyColor(int red, int green, int blue) {
+ red = Mth.clamp(red, 0, 255);
+ green = Mth.clamp(green, 0, 255);
+ blue = Mth.clamp(blue, 0, 255);
+ return skyColor(ColorUtil.color(red, green, blue));
+ }
+
+ /**
+ * Sets fog color for the biome. Color is in ARGB int format.
+ * @param color ARGB color as integer.
+ * @return same {@link BCLBiomeBuilder} instance.
+ */
+ public BCLBiomeBuilder fogColor(int color) {
+ getEffects().fogColor(color);
+ return this;
+ }
+
+ /**
+ * Sets fog color for the biome. Color represented as red, green and blue channel values.
+ * @param red red color component [0-255]
+ * @param green green color component [0-255]
+ * @param blue blue color component [0-255]
+ * @return same {@link BCLBiomeBuilder} instance.
+ */
+ public BCLBiomeBuilder fogColor(int red, int green, int blue) {
+ red = Mth.clamp(red, 0, 255);
+ green = Mth.clamp(green, 0, 255);
+ blue = Mth.clamp(blue, 0, 255);
+ return fogColor(ColorUtil.color(red, green, blue));
+ }
+
+ /**
+ * Sets fog density for the biome.
+ * @param density fog density as a float, default value is 1.0F.
+ * @return same {@link BCLBiomeBuilder} instance.
+ */
+ public BCLBiomeBuilder fogDensity(float density) {
+ this.fogDensity = density;
+ return this;
+ }
+
+ /**
+ * Sets water color for the biome. Color is in ARGB int format.
+ * @param color ARGB color as integer.
+ * @return same {@link BCLBiomeBuilder} instance.
+ */
+ public BCLBiomeBuilder waterColor(int color) {
+ getEffects().waterColor(color);
+ return this;
+ }
+
+ /**
+ * Sets water color for the biome. Color represented as red, green and blue channel values.
+ * @param red red color component [0-255]
+ * @param green green color component [0-255]
+ * @param blue blue color component [0-255]
+ * @return same {@link BCLBiomeBuilder} instance.
+ */
+ public BCLBiomeBuilder waterColor(int red, int green, int blue) {
+ red = Mth.clamp(red, 0, 255);
+ green = Mth.clamp(green, 0, 255);
+ blue = Mth.clamp(blue, 0, 255);
+ return waterColor(ColorUtil.color(red, green, blue));
+ }
+
+ /**
+ * Sets underwater fog color for the biome. Color is in ARGB int format.
+ * @param color ARGB color as integer.
+ * @return same {@link BCLBiomeBuilder} instance.
+ */
+ public BCLBiomeBuilder waterFogColor(int color) {
+ getEffects().waterFogColor(color);
+ return this;
+ }
+
+ /**
+ * Sets underwater fog color for the biome. Color represented as red, green and blue channel values.
+ * @param red red color component [0-255]
+ * @param green green color component [0-255]
+ * @param blue blue color component [0-255]
+ * @return same {@link BCLBiomeBuilder} instance.
+ */
+ public BCLBiomeBuilder waterFogColor(int red, int green, int blue) {
+ red = Mth.clamp(red, 0, 255);
+ green = Mth.clamp(green, 0, 255);
+ blue = Mth.clamp(blue, 0, 255);
+ return waterFogColor(ColorUtil.color(red, green, blue));
+ }
+
+ /**
+ * Sets water and underwater fig color for the biome. Color is in ARGB int format.
+ * @param color ARGB color as integer.
+ * @return same {@link BCLBiomeBuilder} instance.
+ */
+ public BCLBiomeBuilder waterAndFogColor(int color) {
+ return waterColor(color).waterFogColor(color);
+ }
+
+ /**
+ * Sets water and underwater fig color for the biome. Color is in ARGB int format.
+ * @param red red color component [0-255]
+ * @param green green color component [0-255]
+ * @param blue blue color component [0-255]
+ * @return same {@link BCLBiomeBuilder} instance.
+ */
+ public BCLBiomeBuilder waterAndFogColor(int red, int green, int blue) {
+ red = Mth.clamp(red, 0, 255);
+ green = Mth.clamp(green, 0, 255);
+ blue = Mth.clamp(blue, 0, 255);
+ return waterAndFogColor(ColorUtil.color(red, green, blue));
+ }
+
+ /**
+ * Sets grass color for the biome. Color is in ARGB int format.
+ * @param color ARGB color as integer.
+ * @return same {@link BCLBiomeBuilder} instance.
+ */
+ public BCLBiomeBuilder grassColor(int color) {
+ getEffects().grassColorOverride(color);
+ return this;
+ }
+
+ /**
+ * Sets grass color for the biome. Color represented as red, green and blue channel values.
+ * @param red red color component [0-255]
+ * @param green green color component [0-255]
+ * @param blue blue color component [0-255]
+ * @return same {@link BCLBiomeBuilder} instance.
+ */
+ public BCLBiomeBuilder grassColor(int red, int green, int blue) {
+ red = Mth.clamp(red, 0, 255);
+ green = Mth.clamp(green, 0, 255);
+ blue = Mth.clamp(blue, 0, 255);
+ return grassColor(ColorUtil.color(red, green, blue));
+ }
+
+ /**
+ * Sets leaves and plants color for the biome. Color is in ARGB int format.
+ * @param color ARGB color as integer.
+ * @return same {@link BCLBiomeBuilder} instance.
+ */
+ public BCLBiomeBuilder foliageColor(int color) {
+ getEffects().foliageColorOverride(color);
+ return this;
+ }
+
+ /**
+ * Sets leaves and plants color for the biome. Color represented as red, green and blue channel values.
+ * @param red red color component [0-255]
+ * @param green green color component [0-255]
+ * @param blue blue color component [0-255]
+ * @return same {@link BCLBiomeBuilder} instance.
+ */
+ public BCLBiomeBuilder foliageColor(int red, int green, int blue) {
+ red = Mth.clamp(red, 0, 255);
+ green = Mth.clamp(green, 0, 255);
+ blue = Mth.clamp(blue, 0, 255);
+ return foliageColor(ColorUtil.color(red, green, blue));
+ }
+
+ /**
+ * Sets grass, leaves and all plants color for the biome. Color is in ARGB int format.
+ * @param color ARGB color as integer.
+ * @return same {@link BCLBiomeBuilder} instance.
+ */
+ public BCLBiomeBuilder plantsColor(int color) {
+ return grassColor(color).foliageColor(color);
+ }
+
+ /**
+ * Sets grass, leaves and all plants color for the biome. Color represented as red, green and blue channel values.
+ * @param red red color component [0-255]
+ * @param green green color component [0-255]
+ * @param blue blue color component [0-255]
+ * @return same {@link BCLBiomeBuilder} instance.
+ */
+ public BCLBiomeBuilder plantsColor(int red, int green, int blue) {
+ red = Mth.clamp(red, 0, 255);
+ green = Mth.clamp(green, 0, 255);
+ blue = Mth.clamp(blue, 0, 255);
+ return plantsColor(ColorUtil.color(red, green, blue));
+ }
+
+ /**
+ * Sets biome music, used for biomes in the Nether and End.
+ * @param music {@link Music} to use.
+ * @return same {@link BCLBiomeBuilder} instance.
+ */
+ public BCLBiomeBuilder music(Music music) {
+ getEffects().backgroundMusic(music);
+ return this;
+ }
+
+ /**
+ * Sets biome music, used for biomes in the Nether and End.
+ * @param music {@link SoundEvent} to use.
+ * @return same {@link BCLBiomeBuilder} instance.
+ */
+ public BCLBiomeBuilder music(SoundEvent music) {
+ return music(new Music(music, 600, 2400, true));
+ }
+
+ /**
+ * Sets biome ambient loop sound. Can be used for biome environment.
+ * @param loopSound {@link SoundEvent} to use as a loop.
+ * @return same {@link BCLBiomeBuilder} instance.
+ */
+ public BCLBiomeBuilder loop(SoundEvent loopSound) {
+ getEffects().ambientLoopSound(loopSound);
+ return this;
+ }
+
+ /**
+ * Sets biome mood sound. Can be used for biome environment.
+ * @param mood {@link SoundEvent} to use as a mood.
+ * @param tickDelay delay between sound events in ticks.
+ * @param blockSearchExtent block search radius (for area available for sound).
+ * @param soundPositionOffset offset in sound.
+ * @return same {@link BCLBiomeBuilder} instance.
+ */
+ public BCLBiomeBuilder mood(SoundEvent mood, int tickDelay, int blockSearchExtent, float soundPositionOffset) {
+ getEffects().ambientMoodSound(new AmbientMoodSettings(mood, tickDelay, blockSearchExtent, soundPositionOffset));
+ return this;
+ }
+
+ /**
+ * Sets biome mood sound. Can be used for biome environment.
+ * @param mood {@link SoundEvent} to use as a mood.
+ * @return same {@link BCLBiomeBuilder} instance.
+ */
+ public BCLBiomeBuilder mood(SoundEvent mood) {
+ return mood(mood, 6000, 8, 2.0F);
+ }
+
+ /**
+ * Sets biome additionsl ambient sounds.
+ * @param additions {@link SoundEvent} to use.
+ * @param intensity sound intensity. Default is 0.0111F.
+ * @return same {@link BCLBiomeBuilder} instance.
+ */
+ public BCLBiomeBuilder additions(SoundEvent additions, float intensity) {
+ getEffects().ambientAdditionsSound(new AmbientAdditionsSettings(additions, intensity));
+ return this;
+ }
+
+ /**
+ * Sets biome additionsl ambient sounds.
+ * @param additions {@link SoundEvent} to use.
+ * @return same {@link BCLBiomeBuilder} instance.
+ */
+ public BCLBiomeBuilder additions(SoundEvent additions) {
+ return additions(additions, 0.0111F);
+ }
+
+ /**
+ * Adds new feature to the biome.
+ * @param decoration {@link Decoration} feature step.
+ * @param feature {@link PlacedFeature}.
+ * @return same {@link BCLBiomeBuilder} instance.
+ */
+ public BCLBiomeBuilder feature(Decoration decoration, PlacedFeature feature) {
+ getGeneration().addFeature(decoration, feature);
+ return this;
+ }
+
+ /**
+ * Adds vanilla Mushrooms.
+ * @return same {@link BCLBiomeBuilder} instance.
+ */
+ public BCLBiomeBuilder defaultMushrooms() {
+ return feature(BiomeDefaultFeatures::addDefaultMushrooms);
+ }
+
+ /**
+ * Adds vanilla Nether Ores.
+ * @return same {@link BCLBiomeBuilder} instance.
+ */
+ public BCLBiomeBuilder netherDefaultOres() {
+ return feature(BiomeDefaultFeatures::addNetherDefaultOres);
+ }
+
+ /**
+ * Will add features into biome, used for vanilla feature adding functions.
+ * @param featureAdd {@link Consumer} with {@link BiomeGenerationSettings.Builder}.
+ * @return same {@link BCLBiomeBuilder} instance.
+ */
+ public BCLBiomeBuilder feature(Consumer featureAdd) {
+ featureAdd.accept(getGeneration());
+ return this;
+ }
+
+ /**
+ * Adds new feature to the biome.
+ * @param feature {@link BCLFeature}.
+ * @return same {@link BCLBiomeBuilder} instance.
+ */
+ public BCLBiomeBuilder feature(BCLFeature feature) {
+ return feature(feature.getDecoration(), feature.getPlacedFeature());
+ }
+
+ /**
+ * Adds new structure feature into the biome.
+ * @param structure {@link ConfiguredStructureFeature} to add.
+ * @return same {@link BCLBiomeBuilder} instance.
+ */
+ public BCLBiomeBuilder structure(ConfiguredStructureFeature structure) {
+ structures.add(structure);
+ return this;
+ }
+
+ /**
+ * Adds new structure feature into thr biome. Will add building biome into the structure list.
+ * @param structure {@link BCLStructureFeature} to add.
+ * @return same {@link BCLBiomeBuilder} instance.
+ */
+ public BCLBiomeBuilder structure(BCLStructureFeature structure) {
+ structure.addInternalBiome(biomeID);
+ return structure(structure.getFeatureConfigured());
+ }
+
+ /**
+ * Adds new world carver into the biome.
+ * @param carver {@link ConfiguredWorldCarver} to add.
+ * @return same {@link BCLBiomeBuilder} instance.
+ */
+ public BCLBiomeBuilder carver(GenerationStep.Carving step, ConfiguredWorldCarver carver) {
+ BuiltinRegistries.CONFIGURED_CARVER
+ .getResourceKey(carver)
+ .ifPresent(key -> BiomeModifications.addCarver(ctx -> ctx.getBiomeKey().location().equals(biomeID), step, key));
+ return this;
+ }
+
+ /**
+ * Adds new world surface rule for the given block
+ * @param surfaceBlock {@link Block} to use.
+ * @return same {@link BCLBiomeBuilder} instance.
+ */
+ public BCLBiomeBuilder surface(Block surfaceBlock) {
+ return surface(SurfaceRuleBuilder.start().surface(surfaceBlock.defaultBlockState()).build());
+ }
+
+ /**
+ * Adds blocks to the biome surface and below it (with specified depth).
+ * @param surfaceBlock {@link Block} that will cover biome.
+ * @param subterrainBlock {@link Block} below it with specified depth.
+ * @param depth thickness of bottom block layer.
+ * @return same {@link BCLBiomeBuilder} instance.
+ */
+ public BCLBiomeBuilder surface(Block surfaceBlock, Block subterrainBlock, int depth) {
+ return surface(SurfaceRuleBuilder
+ .start()
+ .surface(surfaceBlock.defaultBlockState())
+ .subsurface(subterrainBlock.defaultBlockState(), depth)
+ .build());
+ }
+
+ /**
+ * Adds surface rule to this biome.
+ * @param surfaceRule {link SurfaceRules.RuleSource} surface rule.
+ * @return same {@link BCLBiomeBuilder} instance.
+ */
+ public BCLBiomeBuilder surface(SurfaceRules.RuleSource surfaceRule) {
+ this.surfaceRule = surfaceRule;
+ return this;
+ }
+
+ /**
+ * Finalize biome creation.
+ * @return created {@link BCLBiome} instance.
+ */
+ public BCLBiome build() {
+ return build(BCLBiome::new);
+ }
+
+ /**
+ * Finalize biome creation.
+ * @param biomeConstructor {@link BiFunction} biome constructor.
+ * @return created {@link BCLBiome} instance.
+ */
+ public T build(BiFunction biomeConstructor) {
+ BiomeBuilder builder = new BiomeBuilder()
+ .precipitation(precipitation)
+ .biomeCategory(category)
+ .temperature(temperature)
+ .downfall(downfall);
+
+ if (spawnSettings != null) {
+ builder.mobSpawnSettings(spawnSettings.build());
+ }
+
+ if (effectsBuilder != null) {
+ builder.specialEffects(effectsBuilder.build());
+ }
+
+ if (generationSettings != null) {
+ builder.generationSettings(generationSettings.build());
+ }
+
+ final T res = biomeConstructor.apply(biomeID, builder.build());
+ res.attachStructures(structures);
+ res.setSurface(surfaceRule);
+ res.setFogDensity(fogDensity);
+ return res;
+ }
+
+ /**
+ * Get or create {@link BiomeSpecialEffects.Builder} for biome visual effects.
+ * For internal usage only.
+ * For internal usage only.
+ * @return new or same {@link BiomeSpecialEffects.Builder} instance.
+ */
+ private BiomeSpecialEffects.Builder getEffects() {
+ if (effectsBuilder == null) {
+ effectsBuilder = new BiomeSpecialEffects.Builder();
+ }
+ return effectsBuilder;
+ }
+
+ /**
+ * Get or create {@link MobSpawnSettings.Builder} for biome mob spawning.
+ * For internal usage only.
+ * @return new or same {@link MobSpawnSettings.Builder} instance.
+ */
+ private MobSpawnSettings.Builder getSpawns() {
+ if (spawnSettings == null) {
+ spawnSettings = new MobSpawnSettings.Builder();
+ }
+ return spawnSettings;
+ }
+
+ /**
+ * Get or create {@link BiomeGenerationSettings.Builder} for biome features and generation.
+ * For internal usage only.
+ * @return new or same {@link BiomeGenerationSettings.Builder} instance.
+ */
+ private BiomeGenerationSettings.Builder getGeneration() {
+ if (generationSettings == null) {
+ generationSettings = new BiomeGenerationSettings.Builder();
+ }
+ return generationSettings;
+ }
+}
diff --git a/src/main/java/ru/bclib/api/biomes/BiomeAPI.java b/src/main/java/ru/bclib/api/biomes/BiomeAPI.java
new file mode 100644
index 00000000..9bad5eee
--- /dev/null
+++ b/src/main/java/ru/bclib/api/biomes/BiomeAPI.java
@@ -0,0 +1,728 @@
+package ru.bclib.api.biomes;
+
+import com.google.common.collect.HashMultimap;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableMultimap;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Multimap;
+import com.google.common.collect.Sets;
+import net.fabricmc.api.EnvType;
+import net.fabricmc.api.Environment;
+import net.fabricmc.fabric.impl.biome.NetherBiomeData;
+import net.fabricmc.fabric.impl.biome.TheEndBiomeData;
+import net.minecraft.client.Minecraft;
+import net.minecraft.core.Registry;
+import net.minecraft.data.BuiltinRegistries;
+import net.minecraft.resources.ResourceKey;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.util.random.WeightedRandomList;
+import net.minecraft.world.entity.EntityType;
+import net.minecraft.world.entity.Mob;
+import net.minecraft.world.entity.MobCategory;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.biome.Biome;
+import net.minecraft.world.level.biome.BiomeSource;
+import net.minecraft.world.level.biome.Biomes;
+import net.minecraft.world.level.biome.Climate;
+import net.minecraft.world.level.biome.MobSpawnSettings.SpawnerData;
+import net.minecraft.world.level.levelgen.GenerationStep.Carving;
+import net.minecraft.world.level.levelgen.GenerationStep.Decoration;
+import net.minecraft.world.level.levelgen.NoiseGeneratorSettings;
+import net.minecraft.world.level.levelgen.SurfaceRules;
+import net.minecraft.world.level.levelgen.carver.ConfiguredWorldCarver;
+import net.minecraft.world.level.levelgen.feature.ConfiguredFeature;
+import net.minecraft.world.level.levelgen.feature.ConfiguredStructureFeature;
+import net.minecraft.world.level.levelgen.feature.StructureFeature;
+import net.minecraft.world.level.levelgen.placement.PlacedFeature;
+import org.jetbrains.annotations.Nullable;
+import ru.bclib.BCLib;
+import ru.bclib.config.Configs;
+import ru.bclib.interfaces.SurfaceRuleProvider;
+import ru.bclib.mixin.common.BiomeGenerationSettingsAccessor;
+import ru.bclib.mixin.common.MobSpawnSettingsAccessor;
+import ru.bclib.mixin.common.StructureSettingsAccessor;
+import ru.bclib.util.CollectionsUtil;
+import ru.bclib.util.MHelper;
+import ru.bclib.world.biomes.BCLBiome;
+import ru.bclib.world.biomes.FabricBiomesData;
+import ru.bclib.world.features.BCLFeature;
+import ru.bclib.world.generator.BiomePicker;
+import ru.bclib.world.structures.BCLStructureFeature;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import java.util.Set;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
+
+public class BiomeAPI {
+ /**
+ * Empty biome used as default value if requested biome doesn't exist or linked. Shouldn't be registered anywhere to prevent bugs.
+ * Have {@code Biomes.THE_VOID} as the reference biome.
+ */
+ public static final BCLBiome EMPTY_BIOME = new BCLBiome(Biomes.THE_VOID.location());
+
+ public static final BiomePicker NETHER_BIOME_PICKER = new BiomePicker();
+ public static final BiomePicker END_LAND_BIOME_PICKER = new BiomePicker();
+ public static final BiomePicker END_VOID_BIOME_PICKER = new BiomePicker();
+
+ private static final Map ID_MAP = Maps.newHashMap();
+ private static final Map CLIENT = Maps.newHashMap();
+ private static Registry biomeRegistry;
+
+ private static final Map>> MODIFICATIONS = Maps.newHashMap();
+ private static final Map SURFACE_RULES = Maps.newHashMap();
+ private static final Set MODIFIED_BIOMES = Sets.newHashSet();
+
+ public static final BCLBiome NETHER_WASTES_BIOME = registerNetherBiome(getFromRegistry(Biomes.NETHER_WASTES));
+ public static final BCLBiome CRIMSON_FOREST_BIOME = registerNetherBiome(getFromRegistry(Biomes.CRIMSON_FOREST));
+ public static final BCLBiome WARPED_FOREST_BIOME = registerNetherBiome(getFromRegistry(Biomes.WARPED_FOREST));
+ public static final BCLBiome SOUL_SAND_VALLEY_BIOME = registerNetherBiome(getFromRegistry(Biomes.SOUL_SAND_VALLEY));
+ public static final BCLBiome BASALT_DELTAS_BIOME = registerNetherBiome(getFromRegistry(Biomes.BASALT_DELTAS));
+
+ public static final BCLBiome THE_END = registerEndLandBiome(getFromRegistry(Biomes.THE_END));
+ public static final BCLBiome END_MIDLANDS = registerSubBiome(THE_END, getFromRegistry(Biomes.END_MIDLANDS), 0.5F);
+ public static final BCLBiome END_HIGHLANDS = registerSubBiome(THE_END, getFromRegistry(Biomes.END_HIGHLANDS), 0.5F);
+
+ public static final BCLBiome END_BARRENS = registerEndVoidBiome(getFromRegistry(new ResourceLocation("end_barrens")));
+ public static final BCLBiome SMALL_END_ISLANDS = registerEndVoidBiome(getFromRegistry(new ResourceLocation("small_end_islands")));
+
+ /**
+ * Initialize registry for current server.
+ * @param biomeRegistry - {@link Registry} for {@link Biome}.
+ */
+ public static void initRegistry(Registry biomeRegistry) {
+ BiomeAPI.biomeRegistry = biomeRegistry;
+ CLIENT.clear();
+ }
+
+ /**
+ * Register {@link BCLBiome} instance and its {@link Biome} if necessary.
+ * @param biome {@link BCLBiome}
+ * @return {@link BCLBiome}
+ */
+ public static BCLBiome registerBiome(BCLBiome biome) {
+ if (BuiltinRegistries.BIOME.get(biome.getID()) == null) {
+ Registry.register(BuiltinRegistries.BIOME, biome.getID(), biome.getBiome());
+ }
+ ID_MAP.put(biome.getID(), biome);
+ return biome;
+ }
+
+ public static BCLBiome registerSubBiome(BCLBiome parent, BCLBiome subBiome) {
+ registerBiome(subBiome);
+ parent.addSubBiome(subBiome);
+ return subBiome;
+ }
+
+ public static BCLBiome registerSubBiome(BCLBiome parent, Biome biome, float genChance) {
+ BCLBiome subBiome = new BCLBiome(biome).setGenChance(genChance);
+ return registerSubBiome(parent, subBiome);
+ }
+
+ /**
+ * Register {@link BCLBiome} instance and its {@link Biome} if necessary.
+ * After that biome will be added to BCLib Nether Biome Generator and into Fabric Biome API.
+ * @param biome {@link BCLBiome}
+ * @return {@link BCLBiome}
+ */
+ public static BCLBiome registerNetherBiome(BCLBiome biome) {
+ registerBiome(biome);
+ NETHER_BIOME_PICKER.addBiome(biome);
+ Random random = new Random(biome.getID().hashCode());
+
+ //TODO: 1.18 Check parameters, depth was previously called altitude
+ //temperature, humidity, continentalness, erosion, depth, weirdness, offset
+ Climate.ParameterPoint parameters = Climate.parameters(
+ MHelper.randRange(-1.5F, 1.5F, random),
+ MHelper.randRange(-1.5F, 1.5F, random),
+ MHelper.randRange(-1.5F, 1.5F, random), //new in 1.18
+ MHelper.randRange(-1.5F, 1.5F, random), //new in 1.18
+ MHelper.randRange(-1.5F, 1.5F, random),
+ MHelper.randRange(-1.5F, 1.5F, random),
+ random.nextFloat()
+ );
+ ResourceKey key = BuiltinRegistries.BIOME.getResourceKey(biome.getBiome()).get();
+ NetherBiomeData.addNetherBiome(key, parameters);
+ return biome;
+ }
+
+ /**
+ * Register {@link BCLBiome} instance and its {@link Biome} if necessary.
+ * After that biome will be added to BCLib Nether Biome Generator and into Fabric Biome API.
+ * @param biome {@link BCLBiome}
+ * @return {@link BCLBiome}
+ */
+ public static BCLBiome registerNetherBiome(Biome biome) {
+ BCLBiome bclBiome = new BCLBiome(biome);
+ configureBiome(bclBiome, 1.0F, 1.0F);
+ NETHER_BIOME_PICKER.addBiome(bclBiome);
+ registerBiome(bclBiome);
+ return bclBiome;
+ }
+
+ /**
+ * Register {@link BCLBiome} instance and its {@link Biome} if necessary.
+ * After that biome will be added to BCLib End Biome Generator and into Fabric Biome API as a land biome (will generate only on islands).
+ * @param biome {@link BCLBiome}
+ * @return {@link BCLBiome}
+ */
+ public static BCLBiome registerEndLandBiome(BCLBiome biome) {
+ registerBiome(biome);
+ configureBiome(biome, 1.0F, 1.0F);
+ END_LAND_BIOME_PICKER.addBiome(biome);
+ float weight = biome.getGenChance();
+ ResourceKey key = BuiltinRegistries.BIOME.getResourceKey(biome.getBiome()).get();
+ TheEndBiomeData.addEndBiomeReplacement(Biomes.END_HIGHLANDS, key, weight);
+ TheEndBiomeData.addEndBiomeReplacement(Biomes.END_MIDLANDS, key, weight);
+ return biome;
+ }
+
+ /**
+ * Register {@link BCLBiome} wrapper for {@link Biome}.
+ * After that biome will be added to BCLib End Biome Generator and into Fabric Biome API as a land biome (will generate only on islands).
+ * @param biome {@link BCLBiome}
+ * @return {@link BCLBiome}
+ */
+ public static BCLBiome registerEndLandBiome(Biome biome) {
+ BCLBiome bclBiome = new BCLBiome(biome);
+ configureBiome(bclBiome, 1.0F, 1.0F);
+ END_LAND_BIOME_PICKER.addBiome(bclBiome);
+ registerBiome(bclBiome);
+ return bclBiome;
+ }
+
+ /**
+ * Register {@link BCLBiome} wrapper for {@link Biome}.
+ * After that biome will be added to BCLib End Biome Generator and into Fabric Biome API as a land biome (will generate only on islands).
+ * @param biome {@link BCLBiome};
+ * @param genChance float generation chance.
+ * @return {@link BCLBiome}
+ */
+ public static BCLBiome registerEndLandBiome(Biome biome, float genChance) {
+ BCLBiome bclBiome = new BCLBiome(biome);
+ configureBiome(bclBiome, genChance, 1.0F);
+ END_LAND_BIOME_PICKER.addBiome(bclBiome);
+ registerBiome(bclBiome);
+ return bclBiome;
+ }
+
+ /**
+ * Register {@link BCLBiome} instance and its {@link Biome} if necessary.
+ * After that biome will be added to BCLib End Biome Generator and into Fabric Biome API as a void biome (will generate only in the End void - between islands).
+ * @param biome {@link BCLBiome}
+ * @return {@link BCLBiome}
+ */
+ public static BCLBiome registerEndVoidBiome(BCLBiome biome) {
+ registerBiome(biome);
+ configureBiome(biome, 1.0F, 1.0F);
+ END_VOID_BIOME_PICKER.addBiome(biome);
+ float weight = biome.getGenChance();
+ ResourceKey key = BuiltinRegistries.BIOME.getResourceKey(biome.getBiome()).get();
+ TheEndBiomeData.addEndBiomeReplacement(Biomes.SMALL_END_ISLANDS, key, weight);
+ return biome;
+ }
+
+ /**
+ * Register {@link BCLBiome} instance and its {@link Biome} if necessary.
+ * After that biome will be added to BCLib End Biome Generator and into Fabric Biome API as a void biome (will generate only in the End void - between islands).
+ * @param biome {@link BCLBiome}
+ * @return {@link BCLBiome}
+ */
+ public static BCLBiome registerEndVoidBiome(Biome biome) {
+ BCLBiome bclBiome = new BCLBiome(biome);
+ configureBiome(bclBiome, 1.0F, 1.0F);
+ END_VOID_BIOME_PICKER.addBiome(bclBiome);
+ registerBiome(bclBiome);
+ return bclBiome;
+ }
+
+ /**
+ * Register {@link BCLBiome} instance and its {@link Biome} if necessary.
+ * After that biome will be added to BCLib End Biome Generator and into Fabric Biome API as a void biome (will generate only in the End void - between islands).
+ * @param biome {@link BCLBiome}.
+ * @param genChance float generation chance.
+ * @return {@link BCLBiome}
+ */
+ public static BCLBiome registerEndVoidBiome(Biome biome, float genChance) {
+ ResourceKey key = BuiltinRegistries.BIOME.getResourceKey(biome).get();
+ BCLBiome bclBiome = new BCLBiome(biome);
+ configureBiome(bclBiome, genChance, 1.0F);
+ END_VOID_BIOME_PICKER.addBiome(bclBiome);
+ registerBiome(bclBiome);
+ return bclBiome;
+ }
+
+ /**
+ * Get {@link BCLBiome} from {@link Biome} instance on server. Used to convert world biomes to BCLBiomes.
+ * @param biome - {@link Biome} from world.
+ * @return {@link BCLBiome} or {@code BiomeAPI.EMPTY_BIOME}.
+ */
+ public static BCLBiome getFromBiome(Biome biome) {
+ if (biomeRegistry == null) {
+ return EMPTY_BIOME;
+ }
+ return ID_MAP.getOrDefault(biomeRegistry.getKey(biome), EMPTY_BIOME);
+ }
+
+ /**
+ * Get {@link BCLBiome} from biome on client. Used in fog rendering.
+ * @param biome - {@link Biome} from client world.
+ * @return {@link BCLBiome} or {@code BiomeAPI.EMPTY_BIOME}.
+ */
+ @Environment(EnvType.CLIENT)
+ public static BCLBiome getRenderBiome(Biome biome) {
+ BCLBiome endBiome = CLIENT.get(biome);
+ if (endBiome == null) {
+ Minecraft minecraft = Minecraft.getInstance();
+ ResourceLocation id = minecraft.level.registryAccess().registryOrThrow(Registry.BIOME_REGISTRY).getKey(biome);
+ endBiome = id == null ? EMPTY_BIOME : ID_MAP.getOrDefault(id, EMPTY_BIOME);
+ CLIENT.put(biome, endBiome);
+ }
+ return endBiome;
+ }
+
+ /**
+ * Get biome {@link ResourceKey} from given {@link Biome}.
+ * @param biome - {@link Biome} from server world.
+ * @return biome {@link ResourceKey} or {@code null}.
+ */
+ @Nullable
+ public static ResourceKey getBiomeKey(Biome biome) {
+ ResourceKey key = BuiltinRegistries.BIOME.getResourceKey(biome).orElse(null);
+ return key != null ? key : biomeRegistry != null ? biomeRegistry.getResourceKey(biome).orElse(null) : null;
+ }
+
+ /**
+ * Get biome {@link ResourceLocation} from given {@link Biome}.
+ * @param biome - {@link Biome} from server world.
+ * @return biome {@link ResourceLocation}.
+ */
+ public static ResourceLocation getBiomeID(Biome biome) {
+ ResourceLocation id = BuiltinRegistries.BIOME.getKey(biome);
+ if (id == null && biomeRegistry != null) {
+ id = biomeRegistry.getKey(biome);
+ }
+ return id == null ? EMPTY_BIOME.getID() : id;
+ }
+
+ /**
+ * Get {@link BCLBiome} from given {@link ResourceLocation}.
+ * @param biomeID - biome {@link ResourceLocation}.
+ * @return {@link BCLBiome} or {@code BiomeAPI.EMPTY_BIOME}.
+ */
+ public static BCLBiome getBiome(ResourceLocation biomeID) {
+ return ID_MAP.getOrDefault(biomeID, EMPTY_BIOME);
+ }
+
+ /**
+ * Check if biome with {@link ResourceLocation} exists in API registry.
+ * @param biomeID - biome {@link ResourceLocation}.
+ * @return {@code true} if biome exists in API registry and {@code false} if not.
+ */
+ public static boolean hasBiome(ResourceLocation biomeID) {
+ return ID_MAP.containsKey(biomeID);
+ }
+
+ /**
+ * Load biomes from Fabric API. For internal usage only.
+ */
+ public static void loadFabricAPIBiomes() {
+ FabricBiomesData.NETHER_BIOMES.forEach((key) -> {
+ if (!hasBiome(key.location())) {
+ registerNetherBiome(BuiltinRegistries.BIOME.get(key.location()));
+ }
+ });
+
+ FabricBiomesData.END_LAND_BIOMES.forEach((key, weight) -> {
+ if (!hasBiome(key.location())) {
+ registerEndLandBiome(BuiltinRegistries.BIOME.get(key.location()), weight);
+ }
+ });
+
+ FabricBiomesData.END_VOID_BIOMES.forEach((key, weight) -> {
+ if (!hasBiome(key.location())) {
+ registerEndVoidBiome(BuiltinRegistries.BIOME.get(key.location()), weight);
+ }
+ });
+ }
+
+ @Nullable
+ public static Biome getFromRegistry(ResourceLocation key) {
+ return BuiltinRegistries.BIOME.get(key);
+ }
+
+ @Nullable
+ public static Biome getFromRegistry(ResourceKey key) {
+ return BuiltinRegistries.BIOME.get(key);
+ }
+
+ public static boolean isDatapackBiome(ResourceLocation biomeID) {
+ return getFromRegistry(biomeID) == null;
+ }
+
+ public static boolean isNetherBiome(ResourceLocation biomeID) {
+ return pickerHasBiome(NETHER_BIOME_PICKER, biomeID);
+ }
+
+ public static boolean isEndBiome(ResourceLocation biomeID) {
+ return pickerHasBiome(END_LAND_BIOME_PICKER, biomeID) || pickerHasBiome(END_VOID_BIOME_PICKER, biomeID);
+ }
+
+ private static boolean pickerHasBiome(BiomePicker picker, ResourceLocation key) {
+ return picker.getBiomes().stream().filter(biome -> biome.getID().equals(key)).findFirst().isPresent();
+ }
+
+ /**
+ * Registers new biome modification for specified dimension. Will work both for mod and datapack biomes.
+ * @param dimensionID {@link ResourceLocation} dimension ID, example: Level.OVERWORLD or "minecraft:overworld".
+ * @param modification {@link BiConsumer} with {@link ResourceKey} biome ID and {@link Biome} parameters.
+ */
+ public static void registerBiomeModification(ResourceKey dimensionID, BiConsumer modification) {
+ List> modifications = MODIFICATIONS.get(dimensionID);
+ if (modifications == null) {
+ modifications = Lists.newArrayList();
+ MODIFICATIONS.put(dimensionID, modifications);
+ }
+ modifications.add(modification);
+ }
+
+ /**
+ * Registers new biome modification for the Overworld. Will work both for mod and datapack biomes.
+ * @param modification {@link BiConsumer} with {@link ResourceLocation} biome ID and {@link Biome} parameters.
+ */
+ public static void registerOverworldBiomeModification(BiConsumer modification) {
+ registerBiomeModification(Level.OVERWORLD, modification);
+ }
+
+ /**
+ * Registers new biome modification for the Nether. Will work both for mod and datapack biomes.
+ * @param modification {@link BiConsumer} with {@link ResourceLocation} biome ID and {@link Biome} parameters.
+ */
+ public static void registerNetherBiomeModification(BiConsumer modification) {
+ registerBiomeModification(Level.NETHER, modification);
+ }
+
+ /**
+ * Registers new biome modification for the End. Will work both for mod and datapack biomes.
+ * @param modification {@link BiConsumer} with {@link ResourceLocation} biome ID and {@link Biome} parameters.
+ */
+ public static void registerEndBiomeModification(BiConsumer modification) {
+ registerBiomeModification(Level.END, modification);
+ }
+
+ /**
+ * Will apply biome modifications to world, internal usage only.
+ * @param level
+ */
+ public static void applyModifications(ServerLevel level) {
+ BiomeSource source = level.getChunkSource().getGenerator().getBiomeSource();
+ Set biomes = source.possibleBiomes();
+
+ NoiseGeneratorSettings generator = null;
+ if (level.dimension() == Level.NETHER) {
+ generator = BuiltinRegistries.NOISE_GENERATOR_SETTINGS.get(NoiseGeneratorSettings.NETHER);
+ }
+ else if (level.dimension() == Level.END) {
+ generator = BuiltinRegistries.NOISE_GENERATOR_SETTINGS.get(NoiseGeneratorSettings.END);
+ }
+
+ if (generator != null) {
+ List rules = getRuleSources(biomes, level.dimension());
+ SurfaceRuleProvider provider = SurfaceRuleProvider.class.cast(generator);
+ if (rules.size() > 0) {
+ rules.add(provider.getSurfaceRule());
+ provider.setSurfaceRule(SurfaceRules.sequence(rules.toArray(new SurfaceRules.RuleSource[rules.size()])));
+ }
+ else {
+ provider.setSurfaceRule(null);
+ }
+ }
+
+ List> modifications = MODIFICATIONS.get(level.dimension());
+ if (modifications == null) {
+ return;
+ }
+
+ biomes.forEach(biome -> {
+ ResourceLocation biomeID = getBiomeID(biome);
+ boolean modify = isDatapackBiome(biomeID);
+ if (biome != BuiltinRegistries.BIOME.get(biomeID)) {
+ modify = true;
+ }
+ else if (!modify && !MODIFIED_BIOMES.contains(biomeID)) {
+ MODIFIED_BIOMES.add(biomeID);
+ modify = true;
+ }
+ if (modify) {
+ modifications.forEach(consumer -> {
+ consumer.accept(biomeID, biome);
+ });
+ }
+ });
+ }
+
+ private static List getRuleSources(Set biomes, ResourceKey dimensionType) {
+ Set biomeIDs = biomes.stream().map(biome -> getBiomeID(biome)).collect(Collectors.toSet());
+ List rules = Lists.newArrayList();
+ SURFACE_RULES.forEach((biomeID, rule) -> {
+ if (biomeIDs.contains(biomeID)) {
+ rules.add(rule);
+ }
+ });
+
+ // Try handle biomes from other dimension, may work not as expected
+ // Will not work
+ /*Optional optional = biomes
+ .stream()
+ .filter(biome -> biome.getBiomeCategory() != BiomeCategory.THEEND && biome.getBiomeCategory() != BiomeCategory.NETHER)
+ .findAny();
+ if (optional.isPresent()) {
+ rules.add(SurfaceRuleData.overworld());
+ }
+
+ if (dimensionType == Level.NETHER) {
+ optional = biomes.stream().filter(biome -> biome.getBiomeCategory() != BiomeCategory.THEEND).findAny();
+ if (optional.isPresent()) {
+ rules.add(SurfaceRuleData.end());
+ }
+ }
+ else if (dimensionType == Level.END) {
+ optional = biomes.stream().filter(biome -> biome.getBiomeCategory() != BiomeCategory.NETHER).findAny();
+ if (optional.isPresent()) {
+ rules.add(SurfaceRuleData.end());
+ }
+ }*/
+
+ return rules;
+ }
+
+ /**
+ * Adds new features to existing biome.
+ * @param biome {@link Biome} to add features in.
+ * @param feature {@link ConfiguredFeature} to add.
+ *
+ */
+ public static void addBiomeFeature(Biome biome, BCLFeature feature) {
+ addBiomeFeature(biome, feature.getPlacedFeature(), feature.getDecoration());
+ }
+
+ /**
+ * Adds new features to existing biome.
+ * @param biome {@link Biome} to add features in.
+ * @param feature {@link ConfiguredFeature} to add.
+ * @param step a {@link Decoration} step for the feature.
+ */
+ public static void addBiomeFeature(Biome biome, PlacedFeature feature, Decoration step) {
+ BiomeGenerationSettingsAccessor accessor = (BiomeGenerationSettingsAccessor) biome.getGenerationSettings();
+ List>> allFeatures = CollectionsUtil.getMutable(accessor.bclib_getFeatures());
+ Set set = CollectionsUtil.getMutable(accessor.bclib_getFeatureSet());
+ List> features = getFeaturesList(allFeatures, step);
+ features.add(() -> feature);
+ set.add(feature);
+ accessor.bclib_setFeatures(allFeatures);
+ accessor.bclib_setFeatureSet(set);
+ }
+
+ /**
+ * Adds new features to existing biome.
+ * @param biomeID {@link ResourceLocation} of the {@link Biome} to add features in.
+ * @param feature {@link ConfiguredFeature} to add.
+ * @param step a {@link Decoration} step for the feature.
+ */
+ private static void addBiomeFeature(ResourceLocation biomeID, PlacedFeature feature, Decoration step) {
+ addBiomeFeature(BuiltinRegistries.BIOME.get(biomeID), feature, step);
+ }
+
+ /**
+ * Adds new features to existing biome.
+ * @param biome {@link Biome} to add features in.
+ * @param features array of {@link BCLFeature} to add.
+ */
+ public static void addBiomeFeatures(Biome biome, BCLFeature... features) {
+ BiomeGenerationSettingsAccessor accessor = (BiomeGenerationSettingsAccessor) biome.getGenerationSettings();
+ List>> allFeatures = CollectionsUtil.getMutable(accessor.bclib_getFeatures());
+ Set set = CollectionsUtil.getMutable(accessor.bclib_getFeatureSet());
+ for (BCLFeature feature: features) {
+ List> featureList = getFeaturesList(allFeatures, feature.getDecoration());
+ featureList.add(() -> feature.getPlacedFeature());
+ set.add(feature.getPlacedFeature());
+ }
+ accessor.bclib_setFeatures(allFeatures);
+ accessor.bclib_setFeatureSet(set);
+ }
+
+ /**
+ * Adds new structure feature to existing biome.
+ * @param biomeKey {@link ResourceKey} for the {@link Biome} to add structure feature in.
+ * @param structure {@link ConfiguredStructureFeature} to add.
+ */
+ public static void addBiomeStructure(ResourceKey biomeKey, ConfiguredStructureFeature structure) {
+ changeStructureStarts(structureMap -> {
+ Multimap, ResourceKey> configuredMap = structureMap.computeIfAbsent(structure.feature, k -> HashMultimap.create());
+
+ configuredMap.put(structure, biomeKey);
+ });
+ }
+
+ public static void addBiomeStructure(Biome biome, ConfiguredStructureFeature structure) {
+ changeStructureStarts(structureMap -> {
+ Multimap, ResourceKey> configuredMap = structureMap.computeIfAbsent(structure.feature, k -> HashMultimap.create());
+ var key = getBiomeKey(biome);
+ if (key!=null) {
+ configuredMap.put(structure, key);
+ } else {
+ BCLib.LOGGER.error("Unable to find Biome " + getBiomeID(biome));
+ }
+ });
+ }
+
+ private static void changeStructureStarts(Consumer, Multimap, ResourceKey>>> modifier) {
+ Registry chunkGenSettingsRegistry = BuiltinRegistries.NOISE_GENERATOR_SETTINGS;
+
+ for (Map.Entry, NoiseGeneratorSettings> entry : chunkGenSettingsRegistry.entrySet()) {
+ Map, Multimap, ResourceKey>> structureMap = getMutableStructureConfig(entry.getValue());
+
+ modifier.accept(structureMap);
+ setMutableStructureConfig(entry.getValue(), structureMap);
+ }
+ }
+
+ /**
+ * Adds new structure feature to existing biome.
+ * @param biomeKey {@link ResourceKey} for the {@link Biome} to add structure feature in.
+ * @param structure {@link BCLStructureFeature} to add.
+ */
+ public static void addBiomeStructure(ResourceKey biomeKey, BCLStructureFeature structure) {
+ addBiomeStructure(biomeKey, structure.getFeatureConfigured());
+ }
+
+ /**
+ * Adds new structure features to existing biome.
+ * @param biomeKey {@link ResourceKey} for the {@link Biome} to add structure features in.
+ * @param structures array of {@link BCLStructureFeature} to add.
+ */
+ public static void addBiomeStructures(ResourceKey biomeKey, BCLStructureFeature... structures) {
+ for (BCLStructureFeature structure: structures) {
+ addBiomeStructure(biomeKey, structure.getFeatureConfigured());
+ }
+ }
+
+ /**
+ * Adds new carver into existing biome.
+ * @param biome {@link Biome} to add carver in.
+ * @param carver {@link ConfiguredWorldCarver} to add.
+ * @param stage {@link Carving} stage.
+ */
+ public static void addBiomeCarver(Biome biome, ConfiguredWorldCarver carver, Carving stage) {
+ BiomeGenerationSettingsAccessor accessor = (BiomeGenerationSettingsAccessor) biome.getGenerationSettings();
+ Map>>> carvers = CollectionsUtil.getMutable(accessor.bclib_getCarvers());
+ List>> carverList = CollectionsUtil.getMutable(carvers.getOrDefault(stage, new ArrayList<>()));
+ carvers.put(stage, carverList);
+ carverList.add(() -> carver);
+ accessor.bclib_setCarvers(carvers);
+ }
+
+ /**
+ * Adds surface rule to specified biome.
+ * @param biomeID biome {@link ResourceLocation}.
+ * @param source {@link SurfaceRules.RuleSource}.
+ */
+ public static void addSurfaceRule(ResourceLocation biomeID, SurfaceRules.RuleSource source) {
+ SURFACE_RULES.put(biomeID, source);
+ }
+
+ /**
+ * Get surface rule for the biome using its {@link ResourceLocation} ID as a key.
+ * @param biomeID {@link ResourceLocation} biome ID.
+ * @return {@link SurfaceRules.RuleSource}.
+ */
+ @Nullable
+ public static SurfaceRules.RuleSource getSurfaceRule(ResourceLocation biomeID) {
+ return SURFACE_RULES.get(biomeID);
+ }
+
+ /**
+ * Adds mob spawning to specified biome.
+ * @param biome {@link Biome} to add mob spawning.
+ * @param entityType {@link EntityType} mob type.
+ * @param weight spawn weight.
+ * @param minGroupCount minimum mobs in group.
+ * @param maxGroupCount maximum mobs in group.
+ */
+ public static void addBiomeMobSpawn(Biome biome, EntityType entityType, int weight, int minGroupCount, int maxGroupCount) {
+ final MobCategory category = entityType.getCategory();
+ MobSpawnSettingsAccessor accessor = (MobSpawnSettingsAccessor) biome.getMobSettings();
+ Map> spawners = CollectionsUtil.getMutable(accessor.bcl_getSpawners());
+ List mobs = spawners.containsKey(category) ? CollectionsUtil.getMutable(spawners.get(category).unwrap()) : Lists.newArrayList();
+ mobs.add(new SpawnerData(entityType, weight, minGroupCount, maxGroupCount));
+ spawners.put(category, WeightedRandomList.create(mobs));
+ accessor.bcl_setSpawners(spawners);
+ }
+
+ private static void configureBiome(BCLBiome biome, float chance, float fog) {
+ String group = biome.getID().getNamespace() + "." + biome.getID().getPath();
+ chance = Configs.BIOMES_CONFIG.getFloat(group, "generation_chance", chance);
+ fog = Configs.BIOMES_CONFIG.getFloat(group, "fog_density", fog);
+ biome.setGenChance(chance).setFogDensity(fog);
+ }
+
+ /**
+ * Getter for correct feature list from all biome feature list of lists.
+ * @param step feature {@link Decoration} step.
+ * @param lists biome accessor lists.
+ * @return mutable {@link ConfiguredFeature} list.
+ */
+ private static List> getList(Decoration step, List>> lists) {
+ int index = step.ordinal();
+ if (lists.size() <= index) {
+ for (int i = lists.size(); i <= index; i++) {
+ lists.add(Lists.newArrayList());
+ }
+ }
+ List> list = CollectionsUtil.getMutable(lists.get(index));
+ lists.set(index, list);
+ return list;
+ }
+
+ private static List> getFeaturesList(List>> features, Decoration step) {
+ int index = step.ordinal();
+ while (features.size() <= index) {
+ features.add(Lists.newArrayList());
+ }
+ List> mutable = CollectionsUtil.getMutable(features.get(index));
+ features.set(index, mutable);
+ return mutable;
+ }
+
+ //inspired by net.fabricmc.fabric.impl.biome.modification.BiomeStructureStartsImpl
+ private static Map, Multimap, ResourceKey>> getMutableStructureConfig(NoiseGeneratorSettings settings) {
+ final StructureSettingsAccessor access = (StructureSettingsAccessor)settings.structureSettings();
+ ImmutableMap, ImmutableMultimap, ResourceKey>> immutableMap = access.bcl_getStructureConfig();
+ Map, Multimap, ResourceKey>> result = new HashMap<>(immutableMap.size());
+
+ for (Map.Entry, ImmutableMultimap, ResourceKey>> entry : immutableMap.entrySet()) {
+ result.put(entry.getKey(), HashMultimap.create(entry.getValue()));
+ }
+
+ return result;
+ }
+
+ //inspired by net.fabricmc.fabric.impl.biome.modification.BiomeStructureStartsImpl
+ private static void setMutableStructureConfig(NoiseGeneratorSettings settings, Map, Multimap, ResourceKey>> structureStarts) {
+ final StructureSettingsAccessor access = (StructureSettingsAccessor) settings.structureSettings();
+ access.bcl_setStructureConfig(
+ structureStarts
+ .entrySet()
+ .stream()
+ .collect(ImmutableMap.toImmutableMap(Map.Entry::getKey, e -> ImmutableMultimap.copyOf(e.getValue())))
+ );
+ }
+}
diff --git a/src/main/java/ru/bclib/api/biomes/SurfaceRuleBuilder.java b/src/main/java/ru/bclib/api/biomes/SurfaceRuleBuilder.java
new file mode 100644
index 00000000..13082e90
--- /dev/null
+++ b/src/main/java/ru/bclib/api/biomes/SurfaceRuleBuilder.java
@@ -0,0 +1,190 @@
+package ru.bclib.api.biomes;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import net.minecraft.resources.ResourceKey;
+import net.minecraft.world.level.biome.Biome;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.levelgen.SurfaceRules;
+import net.minecraft.world.level.levelgen.SurfaceRules.RuleSource;
+import net.minecraft.world.level.levelgen.placement.CaveSurface;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Supplier;
+
+public class SurfaceRuleBuilder {
+ private static final Map RULES_CACHE = Maps.newHashMap();
+ private static final SurfaceRuleBuilder INSTANCE = new SurfaceRuleBuilder();
+ private List rules = Lists.newArrayList();
+ private SurfaceRuleEntry entryInstance;
+ private ResourceKey biomeKey;
+
+ private SurfaceRuleBuilder() {}
+
+ public static SurfaceRuleBuilder start() {
+ INSTANCE.biomeKey = null;
+ INSTANCE.rules.clear();
+ return INSTANCE;
+ }
+
+ /**
+ * Restricts surface to only one biome.
+ * @param biomeKey {@link ResourceKey} for the {@link Biome}.
+ * @return same {@link SurfaceRuleBuilder} instance.
+ */
+ public SurfaceRuleBuilder biome(ResourceKey biomeKey) {
+ this.biomeKey = biomeKey;
+ return this;
+ }
+
+ /**
+ * Restricts surface to only one biome.
+ * @param biome {@link Biome}.
+ * @return same {@link SurfaceRuleBuilder} instance.
+ */
+ public SurfaceRuleBuilder biome(Biome biome) {
+ return biome(BiomeAPI.getBiomeKey(biome));
+ }
+
+ /**
+ * Set biome surface with specified {@link BlockState}. Example - block of grass in the Overworld biomes
+ * @param state {@link BlockState} for the ground cover.
+ * @return same {@link SurfaceRuleBuilder} instance.
+ */
+ public SurfaceRuleBuilder surface(BlockState state) {
+ entryInstance = getFromCache("surface_" + state.toString(), () -> {
+ RuleSource rule = SurfaceRules.state(state);
+ rule = SurfaceRules.ifTrue(SurfaceRules.ON_FLOOR, rule);
+ return new SurfaceRuleEntry(2, rule);
+ });
+ rules.add(entryInstance);
+ return this;
+ }
+
+ /**
+ * Set biome subsurface with specified {@link BlockState}. Example - dirt in the Overworld biomes.
+ * @param state {@link BlockState} for the subterrain layer.
+ * @param depth block layer depth.
+ * @return same {@link SurfaceRuleBuilder} instance.
+ */
+ public SurfaceRuleBuilder subsurface(BlockState state, int depth) {
+ entryInstance = getFromCache("subsurface_" + depth + "_" + state.toString(), () -> {
+ RuleSource rule = SurfaceRules.state(state);
+ rule = SurfaceRules.ifTrue(SurfaceRules.stoneDepthCheck(depth, false, false, CaveSurface.FLOOR), rule);
+ return new SurfaceRuleEntry(3, rule);
+ });
+ rules.add(entryInstance);
+ return this;
+ }
+
+ /**
+ * Set biome filler with specified {@link BlockState}. Example - stone in the Overworld biomes.
+ * @param state {@link BlockState} for filling.
+ * @return same {@link SurfaceRuleBuilder} instance.
+ */
+ public SurfaceRuleBuilder filler(BlockState state) {
+ entryInstance = getFromCache("fill_" + state.toString(), () -> new SurfaceRuleEntry(3, SurfaceRules.state(state)));
+ rules.add(entryInstance);
+ return this;
+ }
+
+ /**
+ * Set biome ceiling with specified {@link BlockState}. Example - block of sandstone in the Overworld desert in air pockets.
+ * @param state {@link BlockState} for the ground cover.
+ * @return same {@link SurfaceRuleBuilder} instance.
+ */
+ public SurfaceRuleBuilder ceil(BlockState state) {
+ entryInstance = getFromCache("ceil_" + state.toString(), () -> {
+ RuleSource rule = SurfaceRules.state(state);
+ return new SurfaceRuleEntry(2, SurfaceRules.ifTrue(SurfaceRules.ON_CEILING, rule));
+ });
+ rules.add(entryInstance);
+ return this;
+ }
+
+ /**
+ * Set biome ceiling material with specified {@link BlockState} and height. Example - sandstone in the Overworld deserts.
+ * @param state {@link BlockState} for the subterrain layer.
+ * @param height block layer height.
+ * @return same {@link SurfaceRuleBuilder} instance.
+ */
+ public SurfaceRuleBuilder aboveCeil(BlockState state, int height) {
+ entryInstance = getFromCache("above_ceil_" + height + "_" + state.toString(), () -> {
+ RuleSource rule = SurfaceRules.state(state);
+ rule = SurfaceRules.ifTrue(SurfaceRules.stoneDepthCheck(height, false, false, CaveSurface.CEILING), rule);
+ return new SurfaceRuleEntry(3, rule);
+ });
+ rules.add(entryInstance);
+ return this;
+ }
+
+ /**
+ * Will cover steep areas (with large terrain angle). Example - Overworld mountains.
+ * @param state {@link BlockState} for the steep layer.
+ * @param depth layer depth
+ * @return
+ */
+ public SurfaceRuleBuilder steep(BlockState state, int depth) {
+ entryInstance = getFromCache("steep_" + depth + "_" + state.toString(), () -> {
+ RuleSource rule = SurfaceRules.state(state);
+ rule = SurfaceRules.ifTrue(SurfaceRules.stoneDepthCheck(depth, false, false, CaveSurface.FLOOR), rule);
+ rule = SurfaceRules.ifTrue(SurfaceRules.steep(), rule);
+ int priority = depth < 1 ? 0 : 1;
+ return new SurfaceRuleEntry(priority, rule);
+ });
+ rules.add(entryInstance);
+ return this;
+ }
+
+ /**
+ * Allows to add custom rule.
+ * @param priority rule priority, lower values = higher priority (rule will be applied before others).
+ * @param rule custom {@link SurfaceRules.RuleSource}.
+ * @return same {@link SurfaceRuleBuilder} instance.
+ */
+ public SurfaceRuleBuilder rule(int priority, SurfaceRules.RuleSource rule) {
+ rules.add(new SurfaceRuleEntry(priority, rule));
+ return this;
+ }
+
+ /**
+ * Allows to add custom rule.
+ * @param rule custom {@link SurfaceRules.RuleSource}.
+ * @return same {@link SurfaceRuleBuilder} instance.
+ */
+ public SurfaceRuleBuilder rule(SurfaceRules.RuleSource rule) {
+ return rule(7, rule);
+ }
+
+ /**
+ * Finalise rule building process.
+ * @return {@link SurfaceRules.RuleSource}.
+ */
+ public SurfaceRules.RuleSource build() {
+ Collections.sort(rules);
+ List ruleList = rules.stream().map(entry -> entry.getRule()).toList();
+ SurfaceRules.RuleSource[] ruleArray = ruleList.toArray(new SurfaceRules.RuleSource[ruleList.size()]);
+ SurfaceRules.RuleSource rule = SurfaceRules.sequence(ruleArray);
+ if (biomeKey != null) {
+ rule = SurfaceRules.ifTrue(SurfaceRules.isBiome(biomeKey), rule);
+ }
+ return rule;
+ }
+
+ /**
+ * Internal function, will take entry from cache or create it if necessary.
+ * @param name {@link String} entry internal name.
+ * @param supplier {@link Supplier} for {@link SurfaceRuleEntry}.
+ * @return new or existing {@link SurfaceRuleEntry}.
+ */
+ private static SurfaceRuleEntry getFromCache(String name, Supplier supplier) {
+ SurfaceRuleEntry entry = RULES_CACHE.get(name);
+ if (entry == null) {
+ entry = supplier.get();
+ RULES_CACHE.put(name, entry);
+ }
+ return entry;
+ }
+}
diff --git a/src/main/java/ru/bclib/api/biomes/SurfaceRuleEntry.java b/src/main/java/ru/bclib/api/biomes/SurfaceRuleEntry.java
new file mode 100644
index 00000000..348dbbfb
--- /dev/null
+++ b/src/main/java/ru/bclib/api/biomes/SurfaceRuleEntry.java
@@ -0,0 +1,24 @@
+package ru.bclib.api.biomes;
+
+import net.minecraft.world.entity.Mob;
+import net.minecraft.world.level.levelgen.SurfaceRules;
+import org.jetbrains.annotations.NotNull;
+
+public class SurfaceRuleEntry implements Comparable {
+ private final SurfaceRules.RuleSource rule;
+ private final byte priority;
+
+ public SurfaceRuleEntry(int priority, SurfaceRules.RuleSource rule) {
+ this.priority = (byte) priority;
+ this.rule = rule;
+ }
+
+ protected SurfaceRules.RuleSource getRule() {
+ return rule;
+ }
+
+ @Override
+ public int compareTo(@NotNull SurfaceRuleEntry entry) {
+ return Integer.compare(priority, entry.priority);
+ }
+}
diff --git a/src/main/java/ru/bclib/api/dataexchange/BaseDataHandler.java b/src/main/java/ru/bclib/api/dataexchange/BaseDataHandler.java
new file mode 100644
index 00000000..47ca87af
--- /dev/null
+++ b/src/main/java/ru/bclib/api/dataexchange/BaseDataHandler.java
@@ -0,0 +1,99 @@
+package ru.bclib.api.dataexchange;
+
+import net.fabricmc.api.EnvType;
+import net.fabricmc.api.Environment;
+import net.fabricmc.fabric.api.networking.v1.PacketSender;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.multiplayer.ClientPacketListener;
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.server.network.ServerGamePacketListenerImpl;
+import org.jetbrains.annotations.NotNull;
+
+import java.nio.charset.StandardCharsets;
+import java.util.Objects;
+
+public abstract class BaseDataHandler {
+ private final boolean originatesOnServer;
+ @NotNull
+ private final ResourceLocation identifier;
+
+ protected BaseDataHandler(ResourceLocation identifier, boolean originatesOnServer) {
+ this.originatesOnServer = originatesOnServer;
+ this.identifier = identifier;
+ }
+
+ final public boolean getOriginatesOnServer() {
+ return originatesOnServer;
+ }
+
+ final public ResourceLocation getIdentifier() {
+ return identifier;
+ }
+
+ @Environment(EnvType.CLIENT)
+ abstract void receiveFromServer(Minecraft client, ClientPacketListener handler, FriendlyByteBuf buf, PacketSender responseSender);
+
+ private ServerPlayer lastMessageSender;
+
+ void receiveFromClient(MinecraftServer server, ServerPlayer player, ServerGamePacketListenerImpl handler, FriendlyByteBuf buf, PacketSender responseSender) {
+ lastMessageSender = player;
+ }
+
+ final protected boolean reply(BaseDataHandler message, MinecraftServer server) {
+ if (lastMessageSender == null) return false;
+ message.sendToClient(server, lastMessageSender);
+ return true;
+ }
+
+ abstract void sendToClient(MinecraftServer server);
+
+ abstract void sendToClient(MinecraftServer server, ServerPlayer player);
+
+ @Environment(EnvType.CLIENT)
+ abstract void sendToServer(Minecraft client);
+
+ protected boolean isBlocking() { return false; }
+
+ @Override
+ public String toString() {
+ return "BasDataHandler{" + "originatesOnServer=" + originatesOnServer + ", identifier=" + identifier + '}';
+ }
+
+ /**
+ * Write a String to a buffer (Convenience Method)
+ *
+ * @param buf The buffer to write to
+ * @param s The String you want to write
+ */
+ public static void writeString(FriendlyByteBuf buf, String s) {
+ buf.writeByteArray(s.getBytes(StandardCharsets.UTF_8));
+ }
+
+ /**
+ * Read a string from a buffer (Convenience Method)
+ *
+ * @param buf Thea buffer to read from
+ * @return The received String
+ */
+ public static String readString(FriendlyByteBuf buf) {
+ byte[] data = buf.readByteArray();
+ return new String(data, StandardCharsets.UTF_8);
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) return true;
+ if (!(o instanceof BaseDataHandler)) return false;
+ BaseDataHandler that = (BaseDataHandler) o;
+ return originatesOnServer == that.originatesOnServer && identifier.equals(that.identifier);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(originatesOnServer, identifier);
+ }
+}
+
diff --git a/src/main/java/ru/bclib/api/dataexchange/Connector.java b/src/main/java/ru/bclib/api/dataexchange/Connector.java
new file mode 100644
index 00000000..6f933489
--- /dev/null
+++ b/src/main/java/ru/bclib/api/dataexchange/Connector.java
@@ -0,0 +1,18 @@
+package ru.bclib.api.dataexchange;
+
+import ru.bclib.api.dataexchange.handler.DataExchange;
+
+import java.util.Set;
+
+abstract class Connector {
+ protected final DataExchange api;
+
+ Connector(DataExchange api) {
+ this.api = api;
+ }
+ public abstract boolean onClient();
+
+ protected Set getDescriptors(){
+ return api.getDescriptors();
+ }
+}
diff --git a/src/main/java/ru/bclib/api/dataexchange/ConnectorClientside.java b/src/main/java/ru/bclib/api/dataexchange/ConnectorClientside.java
new file mode 100644
index 00000000..6e192b91
--- /dev/null
+++ b/src/main/java/ru/bclib/api/dataexchange/ConnectorClientside.java
@@ -0,0 +1,70 @@
+package ru.bclib.api.dataexchange;
+
+import net.fabricmc.api.EnvType;
+import net.fabricmc.api.Environment;
+import net.fabricmc.fabric.api.client.networking.v1.ClientPlayNetworking;
+import net.fabricmc.fabric.api.networking.v1.PacketSender;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.multiplayer.ClientPacketListener;
+import net.minecraft.network.FriendlyByteBuf;
+import ru.bclib.BCLib;
+import ru.bclib.api.dataexchange.handler.DataExchange;
+
+/**
+ * This is an internal class that handles a Clienetside players Connection to a Server
+ */
+@Environment(EnvType.CLIENT)
+public class ConnectorClientside extends Connector {
+ private Minecraft client;
+ ConnectorClientside(DataExchange api) {
+ super(api);
+ this.client = null;
+ }
+
+
+ @Override
+ public boolean onClient() {
+ return true;
+ }
+
+ public void onPlayInit(ClientPacketListener handler, Minecraft client){
+ if (this.client!=null && this.client != client){
+ BCLib.LOGGER.warning("Client changed!");
+ }
+ this.client = client;
+ for(DataHandlerDescriptor desc : getDescriptors()){
+ ClientPlayNetworking.registerReceiver(desc.IDENTIFIER, (_client, _handler, _buf, _responseSender)->{
+ receiveFromServer(desc, _client, _handler, _buf, _responseSender);
+ });
+ }
+ }
+
+ public void onPlayReady(ClientPacketListener handler, PacketSender sender, Minecraft client){
+ for(DataHandlerDescriptor desc : getDescriptors()){
+ if (desc.sendOnJoin){
+ BaseDataHandler h = desc.JOIN_INSTANCE.get();
+ if (!h.getOriginatesOnServer()) {
+ h.sendToServer(client);
+ }
+ }
+ }
+ }
+
+ public void onPlayDisconnect(ClientPacketListener handler, Minecraft client){
+ for(DataHandlerDescriptor desc : getDescriptors()) {
+ ClientPlayNetworking.unregisterReceiver(desc.IDENTIFIER);
+ }
+ }
+
+ void receiveFromServer(DataHandlerDescriptor desc, Minecraft client, ClientPacketListener handler, FriendlyByteBuf buf, PacketSender responseSender){
+ BaseDataHandler h = desc.INSTANCE.get();
+ h.receiveFromServer(client, handler, buf, responseSender);
+ }
+
+ public void sendToServer(BaseDataHandler h){
+ if (client==null){
+ throw new RuntimeException("[internal error] Client not initialized yet!");
+ }
+ h.sendToServer(this.client);
+ }
+}
diff --git a/src/main/java/ru/bclib/api/dataexchange/ConnectorServerside.java b/src/main/java/ru/bclib/api/dataexchange/ConnectorServerside.java
new file mode 100644
index 00000000..f8debc99
--- /dev/null
+++ b/src/main/java/ru/bclib/api/dataexchange/ConnectorServerside.java
@@ -0,0 +1,67 @@
+package ru.bclib.api.dataexchange;
+
+import net.fabricmc.fabric.api.networking.v1.PacketSender;
+import net.fabricmc.fabric.api.networking.v1.ServerPlayNetworking;
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.server.network.ServerGamePacketListenerImpl;
+import ru.bclib.BCLib;
+import ru.bclib.api.dataexchange.handler.DataExchange;
+
+/**
+ * This is an internal class that handles a Serverside Connection to a Client-Player
+ */
+public class ConnectorServerside extends Connector {
+ private MinecraftServer server;
+ ConnectorServerside(DataExchange api) {
+ super(api);
+ server = null;
+ }
+
+ @Override
+ public boolean onClient() {
+ return false;
+ }
+
+ public void onPlayInit(ServerGamePacketListenerImpl handler, MinecraftServer server){
+ if (this.server!=null && this.server != server){
+ BCLib.LOGGER.warning("Server changed!");
+ }
+ this.server = server;
+ for(DataHandlerDescriptor desc : getDescriptors()){
+ ServerPlayNetworking.registerReceiver(handler, desc.IDENTIFIER, (_server, _player, _handler, _buf, _responseSender) -> {
+ receiveFromClient(desc, _server, _player, _handler, _buf, _responseSender);
+ });
+ }
+ }
+
+ public void onPlayReady(ServerGamePacketListenerImpl handler, PacketSender sender, MinecraftServer server){
+ for(DataHandlerDescriptor desc : getDescriptors()){
+ if (desc.sendOnJoin){
+ BaseDataHandler h = desc.JOIN_INSTANCE.get();
+ if (h.getOriginatesOnServer()) {
+ h.sendToClient(server, handler.player);
+ }
+ }
+ }
+ }
+
+ public void onPlayDisconnect(ServerGamePacketListenerImpl handler, MinecraftServer server){
+ for(DataHandlerDescriptor desc : getDescriptors()){
+ ServerPlayNetworking.unregisterReceiver(handler, desc.IDENTIFIER);
+ }
+ }
+
+ void receiveFromClient(DataHandlerDescriptor desc, MinecraftServer server, ServerPlayer player, ServerGamePacketListenerImpl handler, FriendlyByteBuf buf, PacketSender responseSender){
+ BaseDataHandler h = desc.INSTANCE.get();
+ h.receiveFromClient(server, player, handler, buf, responseSender);
+ }
+
+ public void sendToClient(BaseDataHandler h){
+ if (server==null){
+ throw new RuntimeException("[internal error] Server not initialized yet!");
+ }
+ h.sendToClient(this.server);
+ }
+}
diff --git a/src/main/java/ru/bclib/api/dataexchange/DataExchangeAPI.java b/src/main/java/ru/bclib/api/dataexchange/DataExchangeAPI.java
new file mode 100644
index 00000000..4a22c6db
--- /dev/null
+++ b/src/main/java/ru/bclib/api/dataexchange/DataExchangeAPI.java
@@ -0,0 +1,211 @@
+package ru.bclib.api.dataexchange;
+
+import com.google.common.collect.Lists;
+import net.fabricmc.api.EnvType;
+import net.fabricmc.api.Environment;
+import net.minecraft.network.FriendlyByteBuf;
+import ru.bclib.BCLib;
+import ru.bclib.api.dataexchange.handler.DataExchange;
+import ru.bclib.api.dataexchange.handler.autosync.AutoSync;
+import ru.bclib.api.dataexchange.handler.autosync.AutoSync.NeedTransferPredicate;
+import ru.bclib.api.dataexchange.handler.autosync.AutoSyncID;
+import ru.bclib.config.Config;
+import ru.bclib.util.ModUtil;
+
+import java.io.File;
+import java.util.List;
+import java.util.function.BiConsumer;
+
+public class DataExchangeAPI extends DataExchange {
+ private final static List MODS = Lists.newArrayList();
+
+ /**
+ * You should never need to create a custom instance of this Object.
+ */
+ public DataExchangeAPI() {
+ super();
+ }
+
+ @Environment(EnvType.CLIENT)
+ protected ConnectorClientside clientSupplier(DataExchange api) {
+ return new ConnectorClientside(api);
+ }
+
+ protected ConnectorServerside serverSupplier(DataExchange api) {
+ return new ConnectorServerside(api);
+ }
+
+ /**
+ * Register a mod to participate in the DataExchange.
+ *
+ * @param modID - {@link String} modID.
+ */
+ public static void registerMod(String modID) {
+ if (!MODS.contains(modID)) MODS.add(modID);
+ }
+
+ /**
+ * Register a mod dependency to participate in the DataExchange.
+ *
+ * @param modID - {@link String} modID.
+ */
+ public static void registerModDependency(String modID) {
+ if (ModUtil.getModInfo(modID, false) != null && !"0.0.0".equals(ModUtil.getModVersion(modID))) {
+ registerMod(modID);
+ } else {
+ BCLib.LOGGER.info("Mod Dependency '" + modID + "' not found. This is probably OK.");
+ }
+ }
+
+ /**
+ * Returns the IDs of all registered Mods.
+ *
+ * @return List of modIDs
+ */
+ public static List registeredMods() {
+ return MODS;
+ }
+
+ /**
+ * Add a new Descriptor for a {@link DataHandler}.
+ *
+ * @param desc The Descriptor you want to add.
+ */
+ public static void registerDescriptor(DataHandlerDescriptor desc) {
+ DataExchange api = DataExchange.getInstance();
+ api.getDescriptors()
+ .add(desc);
+ }
+
+ /**
+ * Bulk-Add a Descriptors for your {@link DataHandler}-Objects.
+ *
+ * @param desc The Descriptors you want to add.
+ */
+ public static void registerDescriptors(List desc) {
+ DataExchange api = DataExchange.getInstance();
+ api.getDescriptors()
+ .addAll(desc);
+ }
+
+ /**
+ * Sends the Handler.
+ *
+ * Depending on what the result of {@link DataHandler#getOriginatesOnServer()}, the Data is sent from the server
+ * to the client (if {@code true}) or the other way around.
+ *
+ * The method {@link DataHandler#serializeData(FriendlyByteBuf, boolean)} is called just before the data is sent. You should
+ * use this method to add the Data you need to the communication.
+ *
+ * @param h The Data that you want to send
+ */
+ public static void send(BaseDataHandler h) {
+ if (h.getOriginatesOnServer()) {
+ DataExchangeAPI.getInstance().server.sendToClient(h);
+ }
+ else {
+ DataExchangeAPI.getInstance().client.sendToServer(h);
+ }
+ }
+
+ /**
+ * Registers a File for automatic client syncing.
+ *
+ * @param modID The ID of the calling Mod
+ * @param fileName The name of the File
+ */
+ public static void addAutoSyncFile(String modID, File fileName) {
+ AutoSync.addAutoSyncFileData(modID, fileName, false, SyncFileHash.NEED_TRANSFER);
+ }
+
+ /**
+ * Registers a File for automatic client syncing.
+ *
+ * The file is synced of the {@link SyncFileHash} on client and server are not equal. This method will not copy the
+ * configs content from the client to the server.
+ *
+ * @param modID The ID of the calling Mod
+ * @param uniqueID A unique Identifier for the File. (see {@link SyncFileHash#uniqueID} for
+ * Details
+ * @param fileName The name of the File
+ */
+ public static void addAutoSyncFile(String modID, String uniqueID, File fileName) {
+ AutoSync.addAutoSyncFileData(modID, uniqueID, fileName, false, SyncFileHash.NEED_TRANSFER);
+ }
+
+ /**
+ * Registers a File for automatic client syncing.
+ *
+ * The content of the file is requested for comparison. This will copy the
+ * entire file from the client to the server.
+ *
+ * You should only use this option, if you need to compare parts of the file in order to decide
+ * if the File needs to be copied. Normally using the {@link SyncFileHash}
+ * for comparison is sufficient.
+ *
+ * @param modID The ID of the calling Mod
+ * @param fileName The name of the File
+ * @param needTransfer If the predicate returns true, the file needs to get copied to the server.
+ */
+ public static void addAutoSyncFile(String modID, File fileName, NeedTransferPredicate needTransfer) {
+ AutoSync.addAutoSyncFileData(modID, fileName, true, needTransfer);
+ }
+
+ /**
+ * Registers a File for automatic client syncing.
+ *
+ * The content of the file is requested for comparison. This will copy the
+ * entire file from the client to the server.
+ *
+ * You should only use this option, if you need to compare parts of the file in order to decide
+ * if the File needs to be copied. Normally using the {@link SyncFileHash}
+ * for comparison is sufficient.
+ *
+ * @param modID The ID of the calling Mod
+ * @param uniqueID A unique Identifier for the File. (see {@link SyncFileHash#uniqueID} for
+ * Details
+ * @param fileName The name of the File
+ * @param needTransfer If the predicate returns true, the file needs to get copied to the server.
+ */
+ public static void addAutoSyncFile(String modID, String uniqueID, File fileName, NeedTransferPredicate needTransfer) {
+ AutoSync.addAutoSyncFileData(modID, uniqueID, fileName, true, needTransfer);
+ }
+
+ /**
+ * Register a function that is called whenever the client receives a file from the server and replaced toe local
+ * file with the new content.
+ *
+ * This callback is usefull if you need to reload the new content before the game is quit.
+ *
+ * @param callback A Function that receives the AutoSyncID as well as the Filename.
+ */
+ public static void addOnWriteCallback(BiConsumer callback) {
+ AutoSync.addOnWriteCallback(callback);
+ }
+
+ /**
+ * Returns the sync-folder for a given Mod.
+ *
+ * BCLib will ensure that the contents of sync-folder on the client is the same as the one on the server.
+ *
+ * @param modID ID of the Mod
+ * @return The path to the sync-folder
+ */
+ public static File getModSyncFolder(String modID) {
+ File fl = AutoSync.SYNC_FOLDER.localFolder.resolve(modID.replace(".", "-")
+ .replace(":", "-")
+ .replace("\\", "-")
+ .replace("/", "-"))
+ .normalize()
+ .toFile();
+
+ if (!fl.exists()) {
+ fl.mkdirs();
+ }
+ return fl;
+ }
+
+ static {
+ addOnWriteCallback(Config::reloadSyncedConfig);
+ }
+}
diff --git a/src/main/java/ru/bclib/api/dataexchange/DataHandler.java b/src/main/java/ru/bclib/api/dataexchange/DataHandler.java
new file mode 100644
index 00000000..b1043fc3
--- /dev/null
+++ b/src/main/java/ru/bclib/api/dataexchange/DataHandler.java
@@ -0,0 +1,274 @@
+package ru.bclib.api.dataexchange;
+
+import net.fabricmc.api.EnvType;
+import net.fabricmc.api.Environment;
+import net.fabricmc.fabric.api.client.networking.v1.ClientPlayNetworking;
+import net.fabricmc.fabric.api.networking.v1.PacketByteBufs;
+import net.fabricmc.fabric.api.networking.v1.PacketSender;
+import net.fabricmc.fabric.api.networking.v1.PlayerLookup;
+import net.fabricmc.fabric.api.networking.v1.ServerPlayNetworking;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.multiplayer.ClientPacketListener;
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.server.network.ServerGamePacketListenerImpl;
+import ru.bclib.BCLib;
+import ru.bclib.api.dataexchange.handler.autosync.Chunker;
+import ru.bclib.api.dataexchange.handler.autosync.Chunker.PacketChunkSender;
+
+import java.util.Collection;
+import java.util.List;
+
+public abstract class DataHandler extends BaseDataHandler {
+ public abstract static class WithoutPayload extends DataHandler {
+ protected WithoutPayload(ResourceLocation identifier, boolean originatesOnServer) {
+ super(identifier, originatesOnServer);
+ }
+
+ @Override
+ protected boolean prepareData(boolean isClient) { return true; }
+
+ @Override
+ protected void serializeData(FriendlyByteBuf buf, boolean isClient) {
+ }
+
+ @Override
+ protected void deserializeIncomingData(FriendlyByteBuf buf, PacketSender responseSender, boolean isClient) {
+ }
+ }
+
+ protected DataHandler(ResourceLocation identifier, boolean originatesOnServer) {
+ super(identifier, originatesOnServer);
+ }
+
+ protected boolean prepareData(boolean isClient) { return true; }
+
+ abstract protected void serializeData(FriendlyByteBuf buf, boolean isClient);
+
+ abstract protected void deserializeIncomingData(FriendlyByteBuf buf, PacketSender responseSender, boolean isClient);
+
+ abstract protected void runOnGameThread(Minecraft client, MinecraftServer server, boolean isClient);
+
+
+ @Environment(EnvType.CLIENT)
+ @Override
+ void receiveFromServer(Minecraft client, ClientPacketListener handler, FriendlyByteBuf buf, PacketSender responseSender) {
+ deserializeIncomingData(buf, responseSender, true);
+ final Runnable runner = () -> runOnGameThread(client, null, true);
+
+ if (isBlocking()) client.executeBlocking(runner);
+ else client.execute(runner);
+ }
+
+ @Override
+ void receiveFromClient(MinecraftServer server, ServerPlayer player, ServerGamePacketListenerImpl handler, FriendlyByteBuf buf, PacketSender responseSender) {
+ super.receiveFromClient(server, player, handler, buf, responseSender);
+
+ deserializeIncomingData(buf, responseSender, false);
+ final Runnable runner = () -> runOnGameThread(null, server, false);
+
+ if (isBlocking()) server.executeBlocking(runner);
+ else server.execute(runner);
+ }
+
+ @Override
+ void sendToClient(MinecraftServer server) {
+ if (prepareData(false)) {
+ FriendlyByteBuf buf = PacketByteBufs.create();
+ serializeData(buf, false);
+
+ _sendToClient(getIdentifier(), server, PlayerLookup.all(server), buf);
+ }
+ }
+
+ @Override
+ void sendToClient(MinecraftServer server, ServerPlayer player) {
+ if (prepareData(false)) {
+ FriendlyByteBuf buf = PacketByteBufs.create();
+ serializeData(buf, false);
+
+ _sendToClient(getIdentifier(), server, List.of(player), buf);
+ }
+ }
+
+
+ public static void _sendToClient(ResourceLocation identifier, MinecraftServer server, Collection players, FriendlyByteBuf buf) {
+ if (buf.readableBytes()> Chunker.MAX_PACKET_SIZE) {
+ final PacketChunkSender sender = new PacketChunkSender(buf, identifier);
+ sender.sendChunks(players);
+ } else {
+ for (ServerPlayer player : players) {
+ ServerPlayNetworking.send(player, identifier, buf);
+ }
+ }
+ }
+
+ @Environment(EnvType.CLIENT)
+ @Override
+ void sendToServer(Minecraft client) {
+ if (prepareData(true)) {
+ FriendlyByteBuf buf = PacketByteBufs.create();
+ serializeData(buf, true);
+ ClientPlayNetworking.send(getIdentifier(), buf);
+ }
+ }
+
+ /**
+ * A Message that always originates on the Client
+ */
+ public abstract static class FromClient extends BaseDataHandler {
+ public abstract static class WithoutPayload extends FromClient {
+ protected WithoutPayload(ResourceLocation identifier) {
+ super(identifier);
+ }
+
+ @Override
+ protected boolean prepareDataOnClient() { return true; }
+
+ @Override
+ protected void serializeDataOnClient(FriendlyByteBuf buf) {
+ }
+
+ @Override
+ protected void deserializeIncomingDataOnServer(FriendlyByteBuf buf, PacketSender responseSender) {
+ }
+ }
+
+ protected FromClient(ResourceLocation identifier) {
+ super(identifier, false);
+ }
+
+ @Environment(EnvType.CLIENT)
+ protected boolean prepareDataOnClient() { return true; }
+
+ @Environment(EnvType.CLIENT)
+ abstract protected void serializeDataOnClient(FriendlyByteBuf buf);
+
+ abstract protected void deserializeIncomingDataOnServer(FriendlyByteBuf buf, PacketSender responseSender);
+
+ abstract protected void runOnServerGameThread(MinecraftServer server);
+
+
+ @Environment(EnvType.CLIENT)
+ @Override
+ void receiveFromServer(Minecraft client, ClientPacketListener handler, FriendlyByteBuf buf, PacketSender responseSender) {
+ BCLib.LOGGER.error("[Internal Error] The message '" + getIdentifier() + "' must originate from the client!");
+ }
+
+ @Override
+ void receiveFromClient(MinecraftServer server, ServerPlayer player, ServerGamePacketListenerImpl handler, FriendlyByteBuf buf, PacketSender responseSender) {
+ super.receiveFromClient(server, player, handler, buf, responseSender);
+
+ deserializeIncomingDataOnServer(buf, responseSender);
+ final Runnable runner = () -> runOnServerGameThread(server);
+
+ if (isBlocking()) server.executeBlocking(runner);
+ else server.execute(runner);
+ }
+
+ @Override
+ void sendToClient(MinecraftServer server) {
+ BCLib.LOGGER.error("[Internal Error] The message '" + getIdentifier() + "' must originate from the client!");
+ }
+
+ @Override
+ void sendToClient(MinecraftServer server, ServerPlayer player) {
+ BCLib.LOGGER.error("[Internal Error] The message '" + getIdentifier() + "' must originate from the client!");
+ }
+
+ @Environment(EnvType.CLIENT)
+ @Override
+ void sendToServer(Minecraft client) {
+ if (prepareDataOnClient()) {
+ FriendlyByteBuf buf = PacketByteBufs.create();
+ serializeDataOnClient(buf);
+ ClientPlayNetworking.send(getIdentifier(), buf);
+ }
+ }
+ }
+
+ /**
+ * A Message that always originates on the Server
+ */
+ public abstract static class FromServer extends BaseDataHandler {
+ public abstract static class WithoutPayload extends FromServer {
+ protected WithoutPayload(ResourceLocation identifier) {
+ super(identifier);
+ }
+
+ @Override
+ protected boolean prepareDataOnServer() { return true; }
+
+ @Override
+ protected void serializeDataOnServer(FriendlyByteBuf buf) {
+ }
+
+ @Override
+ protected void deserializeIncomingDataOnClient(FriendlyByteBuf buf, PacketSender responseSender) {
+ }
+ }
+
+ protected FromServer(ResourceLocation identifier) {
+ super(identifier, true);
+ }
+
+ protected boolean prepareDataOnServer() { return true; }
+
+ abstract protected void serializeDataOnServer(FriendlyByteBuf buf);
+
+ @Environment(EnvType.CLIENT)
+ abstract protected void deserializeIncomingDataOnClient(FriendlyByteBuf buf, PacketSender responseSender);
+
+ @Environment(EnvType.CLIENT)
+ abstract protected void runOnClientGameThread(Minecraft client);
+
+
+ @Environment(EnvType.CLIENT)
+ @Override
+ final void receiveFromServer(Minecraft client, ClientPacketListener handler, FriendlyByteBuf buf, PacketSender responseSender) {
+ deserializeIncomingDataOnClient(buf, responseSender);
+ final Runnable runner = () -> runOnClientGameThread(client);
+
+ if (isBlocking()) client.executeBlocking(runner);
+ else client.execute(runner);
+ }
+
+ @Override
+ final void receiveFromClient(MinecraftServer server, ServerPlayer player, ServerGamePacketListenerImpl handler, FriendlyByteBuf buf, PacketSender responseSender) {
+ super.receiveFromClient(server, player, handler, buf, responseSender);
+ BCLib.LOGGER.error("[Internal Error] The message '" + getIdentifier() + "' must originate from the server!");
+ }
+
+ public void receiveFromMemory(FriendlyByteBuf buf){
+ receiveFromServer(Minecraft.getInstance(), null, buf, null);
+ }
+
+ @Override
+ final void sendToClient(MinecraftServer server) {
+ if (prepareDataOnServer()) {
+ FriendlyByteBuf buf = PacketByteBufs.create();
+ serializeDataOnServer(buf);
+
+ _sendToClient(getIdentifier(), server, PlayerLookup.all(server), buf);
+ }
+ }
+
+ @Override
+ final void sendToClient(MinecraftServer server, ServerPlayer player) {
+ if (prepareDataOnServer()) {
+ FriendlyByteBuf buf = PacketByteBufs.create();
+ serializeDataOnServer(buf);
+
+ _sendToClient(getIdentifier(), server, List.of(player), buf);
+ }
+ }
+
+ @Environment(EnvType.CLIENT)
+ @Override
+ final void sendToServer(Minecraft client) {
+ BCLib.LOGGER.error("[Internal Error] The message '" + getIdentifier() + "' must originate from the server!");
+ }
+ }
+}
diff --git a/src/main/java/ru/bclib/api/dataexchange/DataHandlerDescriptor.java b/src/main/java/ru/bclib/api/dataexchange/DataHandlerDescriptor.java
new file mode 100644
index 00000000..2f9f80e5
--- /dev/null
+++ b/src/main/java/ru/bclib/api/dataexchange/DataHandlerDescriptor.java
@@ -0,0 +1,49 @@
+package ru.bclib.api.dataexchange;
+
+import net.minecraft.resources.ResourceLocation;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Objects;
+import java.util.function.Supplier;
+
+public class DataHandlerDescriptor {
+ public DataHandlerDescriptor(@NotNull ResourceLocation identifier, @NotNull Supplier instancer){
+ this(identifier, instancer, instancer, false, false);
+ }
+
+ public DataHandlerDescriptor(@NotNull ResourceLocation identifier,@NotNull Supplier instancer, boolean sendOnJoin, boolean sendBeforeEnter){
+ this(identifier, instancer, instancer, sendOnJoin, sendBeforeEnter);
+ }
+ public DataHandlerDescriptor(@NotNull ResourceLocation identifier, @NotNull Supplier receiv_instancer, @NotNull Supplier join_instancer, boolean sendOnJoin, boolean sendBeforeEnter){
+ this.INSTANCE = receiv_instancer;
+ this.JOIN_INSTANCE = join_instancer;
+ this.IDENTIFIER = identifier;
+
+ this.sendOnJoin = sendOnJoin;
+ this.sendBeforeEnter = sendBeforeEnter;
+ }
+
+ public final boolean sendOnJoin;
+ public final boolean sendBeforeEnter;
+ @NotNull
+ public final ResourceLocation IDENTIFIER;
+ @NotNull
+ public final Supplier INSTANCE;
+ @NotNull
+ public final Supplier JOIN_INSTANCE;
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) return true;
+ if (o instanceof ResourceLocation){
+ return o.equals(IDENTIFIER);
+ }
+ if (!(o instanceof DataHandlerDescriptor that)) return false;
+ return IDENTIFIER.equals(that.IDENTIFIER);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(IDENTIFIER);
+ }
+}
diff --git a/src/main/java/ru/bclib/api/dataexchange/FileHash.java b/src/main/java/ru/bclib/api/dataexchange/FileHash.java
new file mode 100644
index 00000000..de87f686
--- /dev/null
+++ b/src/main/java/ru/bclib/api/dataexchange/FileHash.java
@@ -0,0 +1,161 @@
+package ru.bclib.api.dataexchange;
+
+import net.minecraft.network.FriendlyByteBuf;
+import org.jetbrains.annotations.NotNull;
+import ru.bclib.BCLib;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.Arrays;
+import java.util.Objects;
+
+public class FileHash {
+ private static int ERR_DOES_NOT_EXIST = -10;
+ private static int ERR_IO_ERROR = -20;
+
+ /**
+ * The md5-hash of the file
+ */
+ @NotNull
+ public final byte[] md5;
+
+ /**
+ * The size (in bytes) of the input.
+ */
+ public final int size;
+
+ /**
+ * a value that is directly calculated from defined byte positions.
+ */
+ public final int value;
+
+ FileHash(byte[] md5, int size, int value) {
+ Objects.nonNull(md5);
+
+ this.md5 = md5;
+ this.size = size;
+ this.value = value;
+ }
+
+ static FileHash createForEmpty(int errCode) {
+ return new FileHash(new byte[0], 0, errCode);
+ }
+
+ public boolean noFile() {
+ return md5.length == 0;
+ }
+
+ /**
+ * Serializes the Object to a buffer
+ *
+ * @param buf The buffer to write to
+ */
+ public void serialize(FriendlyByteBuf buf) {
+ buf.writeInt(size);
+ buf.writeInt(value);
+ buf.writeByteArray(md5);
+ }
+
+ /**
+ * Deserialize a Buffer to a new {@link SyncFileHash}-Object
+ *
+ * @param buf Thea buffer to read from
+ * @return The received String
+ */
+ public static FileHash deserialize(FriendlyByteBuf buf) {
+ final int size = buf.readInt();
+ final int value = buf.readInt();
+ final byte[] md5 = buf.readByteArray();
+
+ return new FileHash(md5, size, value);
+ }
+
+ /**
+ * Convert the md5-hash to a human readable string
+ *
+ * @return The converted String
+ */
+ public String getMd5String() {
+ return toHexString(md5);
+ }
+
+ /**
+ * Converts a byte-array to a hex-string representation
+ *
+ * @param bytes The source array
+ * @return The resulting string, or an empty String if the input was {@code null}
+ */
+ public static String toHexString(byte[] bytes) {
+ if (bytes == null) return "";
+
+ StringBuilder sb = new StringBuilder();
+ for (byte b : bytes) {
+ sb.append(String.format("%02x", b));
+ }
+ return sb.toString();
+ }
+
+ /**
+ * Create a new {@link FileHash}.
+ *
+ * @param file The input file
+ * @return A new Instance. You can compare instances using {@link #equals(Object)} to determine if two files are
+ * identical. Will return {@code null} when an error occurs or the File does not exist
+ */
+ public static FileHash create(File file) {
+ if (!file.exists()) return createForEmpty(ERR_DOES_NOT_EXIST);
+ final Path path = file.toPath();
+
+ int size = 0;
+ byte[] md5 = new byte[0];
+ int value = 0;
+
+ try {
+ byte[] data = Files.readAllBytes(path);
+
+ size = data.length;
+
+ value = size > 0 ? (data[size / 3] | (data[size / 2] << 8) | (data[size / 5] << 16)) : -1;
+ if (size > 20) value |= data[20] << 24;
+
+ MessageDigest md = MessageDigest.getInstance("MD5");
+ md.update(data);
+ md5 = md.digest();
+
+ return new FileHash(md5, size, value);
+ }
+ catch (IOException e) {
+ BCLib.LOGGER.error("Failed to read file: " + file);
+ return null;
+ }
+ catch (NoSuchAlgorithmException e) {
+ BCLib.LOGGER.error("Unable to build hash for file: " + file);
+ }
+
+ return createForEmpty(ERR_IO_ERROR);
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) return true;
+ if (!(o instanceof FileHash)) return false;
+ FileHash fileHash = (FileHash) o;
+ return size == fileHash.size && value == fileHash.value && Arrays.equals(md5, fileHash.md5);
+ }
+
+ @Override
+ public int hashCode() {
+ int result = Objects.hash(size, value);
+ result = 31 * result + Arrays.hashCode(md5);
+ return result;
+ }
+
+ @Override
+ public String toString() {
+ return String.format("%08x", size) + "-" + String.format("%08x", value) + "-" + getMd5String();
+ }
+}
diff --git a/src/main/java/ru/bclib/api/dataexchange/SyncFileHash.java b/src/main/java/ru/bclib/api/dataexchange/SyncFileHash.java
new file mode 100644
index 00000000..81a3c853
--- /dev/null
+++ b/src/main/java/ru/bclib/api/dataexchange/SyncFileHash.java
@@ -0,0 +1,108 @@
+package ru.bclib.api.dataexchange;
+
+import net.minecraft.network.FriendlyByteBuf;
+import ru.bclib.api.dataexchange.handler.autosync.AutoSync.NeedTransferPredicate;
+import ru.bclib.api.dataexchange.handler.autosync.AutoSyncID;
+
+import java.io.File;
+import java.util.Objects;
+
+/**
+ * Calculates a hash based on the contents of a File.
+ *
+ * A File-Hash contains the md5-sum of the File, as well as its size and byte-values from defined positions
+ *
+ * You can compare instances using {@link #equals(Object)} to determine if two files are
+ * identical.
+ */
+public class SyncFileHash extends AutoSyncID {
+ public final FileHash hash;
+
+ SyncFileHash(String modID, File file, byte[] md5, int size, int value) {
+ this(modID, file.getName(), md5, size, value);
+ }
+
+ SyncFileHash(String modID, String uniqueID, byte[] md5, int size, int value) {
+ this(modID, uniqueID, new FileHash(md5, size, value));
+ }
+
+ SyncFileHash(String modID, File file, FileHash hash) {
+ this(modID, file.getName(), hash);
+ }
+
+ SyncFileHash(String modID, String uniqueID, FileHash hash) {
+ super(modID, uniqueID);
+ this.hash = hash;
+ }
+
+
+ final static NeedTransferPredicate NEED_TRANSFER = (clientHash, serverHash, content)-> !clientHash.equals(serverHash);
+
+ @Override
+ public String toString() {
+ return super.toString()+": "+hash.toString();
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) return true;
+ if (!(o instanceof SyncFileHash)) return false;
+ if (!super.equals(o)) return false;
+ SyncFileHash that = (SyncFileHash) o;
+ return hash.equals(that.hash);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(super.hashCode(), hash);
+ }
+
+ /**
+ * Serializes the Object to a buffer
+ * @param buf The buffer to write to
+ */
+ public void serialize(FriendlyByteBuf buf) {
+ hash.serialize(buf);
+ DataHandler.writeString(buf, modID);
+ DataHandler.writeString(buf, uniqueID);
+ }
+
+ /**
+ *Deserialize a Buffer to a new {@link SyncFileHash}-Object
+ * @param buf Thea buffer to read from
+ * @return The received String
+ */
+ public static SyncFileHash deserialize(FriendlyByteBuf buf){
+ final FileHash hash = FileHash.deserialize(buf);
+ final String modID = DataHandler.readString(buf);
+ final String uniqueID = DataHandler.readString(buf);
+
+ return new SyncFileHash(modID, uniqueID, hash);
+ }
+
+ /**
+ * Create a new {@link SyncFileHash}.
+ *
+ * Will call {@link #create(String, File, String)} using the name of the File as {@code uniqueID}.
+ * @param modID ID of the calling Mod
+ * @param file The input file
+ *
+ * @return A new Instance. You can compare instances using {@link #equals(Object)} to determine if two files are
+ * identical. Will return {@code null} when an error occurs or the File does not exist
+ */
+ public static SyncFileHash create(String modID, File file){
+ return create(modID, file, file.getName());
+ }
+
+ /**
+ * Create a new {@link SyncFileHash}.
+ * @param modID ID of the calling Mod
+ * @param file The input file
+ * @param uniqueID The unique ID that is used for this File (see {@link SyncFileHash#uniqueID} for Details.
+ * @return A new Instance. You can compare instances using {@link #equals(Object)} to determine if two files are
+ * identical. Will return {@code null} when an error occurs or the File does not exist
+ */
+ public static SyncFileHash create(String modID, File file, String uniqueID){
+ return new SyncFileHash(modID, uniqueID, FileHash.create(file));
+ }
+}
diff --git a/src/main/java/ru/bclib/api/dataexchange/handler/DataExchange.java b/src/main/java/ru/bclib/api/dataexchange/handler/DataExchange.java
new file mode 100644
index 00000000..a11ddb6d
--- /dev/null
+++ b/src/main/java/ru/bclib/api/dataexchange/handler/DataExchange.java
@@ -0,0 +1,113 @@
+package ru.bclib.api.dataexchange.handler;
+
+import net.fabricmc.api.EnvType;
+import net.fabricmc.api.Environment;
+import net.fabricmc.fabric.api.client.networking.v1.ClientPlayConnectionEvents;
+import net.fabricmc.fabric.api.networking.v1.ServerPlayConnectionEvents;
+import net.minecraft.resources.ResourceLocation;
+import ru.bclib.api.dataexchange.BaseDataHandler;
+import ru.bclib.api.dataexchange.ConnectorClientside;
+import ru.bclib.api.dataexchange.ConnectorServerside;
+import ru.bclib.api.dataexchange.DataExchangeAPI;
+import ru.bclib.api.dataexchange.DataHandler;
+import ru.bclib.api.dataexchange.DataHandlerDescriptor;
+
+import java.util.HashSet;
+import java.util.Set;
+
+abstract public class DataExchange {
+
+
+ private static DataExchangeAPI instance;
+
+ protected static DataExchangeAPI getInstance() {
+ if (instance == null) {
+ instance = new DataExchangeAPI();
+ }
+ return instance;
+ }
+
+ protected ConnectorServerside server;
+ protected ConnectorClientside client;
+ protected final Set descriptors;
+
+
+ private boolean didLoadSyncFolder = false;
+
+ abstract protected ConnectorClientside clientSupplier(DataExchange api);
+
+ abstract protected ConnectorServerside serverSupplier(DataExchange api);
+
+ protected DataExchange() {
+ descriptors = new HashSet<>();
+ }
+
+ public Set getDescriptors() { return descriptors; }
+
+ public static DataHandlerDescriptor getDescriptor(ResourceLocation identifier){
+ return getInstance().descriptors.stream().filter(d -> d.equals(identifier)).findFirst().orElse(null);
+ }
+
+ @Environment(EnvType.CLIENT)
+ protected void initClientside() {
+ if (client != null) return;
+ client = clientSupplier(this);
+
+ ClientPlayConnectionEvents.INIT.register(client::onPlayInit);
+ ClientPlayConnectionEvents.JOIN.register(client::onPlayReady);
+ ClientPlayConnectionEvents.DISCONNECT.register(client::onPlayDisconnect);
+ }
+
+ protected void initServerSide() {
+ if (server != null) return;
+ server = serverSupplier(this);
+
+ ServerPlayConnectionEvents.INIT.register(server::onPlayInit);
+ ServerPlayConnectionEvents.JOIN.register(server::onPlayReady);
+ ServerPlayConnectionEvents.DISCONNECT.register(server::onPlayDisconnect);
+ }
+
+ /**
+ * Initializes all datastructures that need to exist in the client component.
+ *
+ * This is automatically called by BCLib. You can register {@link DataHandler}-Objects before this Method is called
+ */
+ @Environment(EnvType.CLIENT)
+ public static void prepareClientside() {
+ DataExchange api = DataExchange.getInstance();
+ api.initClientside();
+
+ }
+
+ /**
+ * Initializes all datastructures that need to exist in the server component.
+ *
+ * This is automatically called by BCLib. You can register {@link DataHandler}-Objects before this Method is called
+ */
+ public static void prepareServerside() {
+ DataExchange api = DataExchange.getInstance();
+ api.initServerSide();
+ }
+
+
+ /**
+ * Automatically called before the player enters the world.
+ *
+ * This is automatically called by BCLib. It will send all {@link DataHandler}-Objects that have {@link DataHandlerDescriptor#sendBeforeEnter} set to*
+ * {@code true},
+ */
+ @Environment(EnvType.CLIENT)
+ public static void sendOnEnter() {
+ getInstance().descriptors.forEach((desc) -> {
+ if (desc.sendBeforeEnter) {
+ BaseDataHandler h = desc.JOIN_INSTANCE.get();
+ if (!h.getOriginatesOnServer()) {
+ getInstance().client.sendToServer(h);
+ }
+ }
+ });
+ }
+
+
+
+}
diff --git a/src/main/java/ru/bclib/api/dataexchange/handler/autosync/AutoFileSyncEntry.java b/src/main/java/ru/bclib/api/dataexchange/handler/autosync/AutoFileSyncEntry.java
new file mode 100644
index 00000000..83e4ff0b
--- /dev/null
+++ b/src/main/java/ru/bclib/api/dataexchange/handler/autosync/AutoFileSyncEntry.java
@@ -0,0 +1,237 @@
+package ru.bclib.api.dataexchange.handler.autosync;
+
+import net.minecraft.network.FriendlyByteBuf;
+import ru.bclib.BCLib;
+import ru.bclib.api.dataexchange.DataHandler;
+import ru.bclib.api.dataexchange.SyncFileHash;
+import ru.bclib.api.dataexchange.handler.autosync.AutoSync.NeedTransferPredicate;
+import ru.bclib.api.dataexchange.handler.autosync.SyncFolderDescriptor.SubFile;
+import ru.bclib.util.ModUtil;
+import ru.bclib.util.ModUtil.ModInfo;
+import ru.bclib.util.Pair;
+import ru.bclib.util.PathUtil;
+import ru.bclib.util.Triple;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+class AutoFileSyncEntry extends AutoSyncID {
+ static class ForDirectFileRequest extends AutoFileSyncEntry {
+ final File relFile;
+
+ ForDirectFileRequest(String syncID, File relFile, File absFile) {
+ super(AutoSyncID.ForDirectFileRequest.MOD_ID, syncID, absFile, false, (a, b, c) -> false);
+ this.relFile = relFile;
+ }
+
+ @Override
+ public int serializeContent(FriendlyByteBuf buf) {
+ int res = super.serializeContent(buf);
+ DataHandler.writeString(buf, relFile.toString());
+
+ return res;
+ }
+
+ static AutoFileSyncEntry.ForDirectFileRequest finishDeserializeContent(String syncID, FriendlyByteBuf buf) {
+ final String relFile = DataHandler.readString(buf);
+ SyncFolderDescriptor desc = AutoSync.getSyncFolderDescriptor(syncID);
+ if (desc != null) {
+ //ensures that the file is not above the base-folder
+ if (desc.acceptChildElements(desc.mapAbsolute(relFile))) {
+ return new AutoFileSyncEntry.ForDirectFileRequest(syncID, new File(relFile), desc.localFolder.resolve(relFile)
+ .normalize()
+ .toFile());
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public String toString() {
+ return uniqueID + " - " + relFile;
+ }
+ }
+
+ static class ForModFileRequest extends AutoFileSyncEntry {
+ public static File getLocalPathForID(String modID, boolean matchLocalVersion){
+ ModInfo mi = ModUtil.getModInfo(modID, matchLocalVersion);
+ if (mi!=null){
+ return mi.jarPath.toFile();
+ }
+ return null;
+ }
+
+ public final String version;
+ ForModFileRequest(String modID, boolean matchLocalVersion, String version) {
+ super(modID, AutoSyncID.ForModFileRequest.UNIQUE_ID, getLocalPathForID(modID, matchLocalVersion), false, (a, b, c) -> false);
+ if (this.fileName == null && matchLocalVersion){
+ BCLib.LOGGER.error("Unknown mod '"+modID+"'.");
+ }
+ if (version==null)
+ this.version = ModUtil.getModVersion(modID);
+ else
+ this.version = version;
+ }
+
+ @Override
+ public int serializeContent(FriendlyByteBuf buf) {
+ final int res = super.serializeContent(buf);
+ buf.writeInt(ModUtil.convertModVersion(version));
+ return res;
+ }
+
+ static AutoFileSyncEntry.ForModFileRequest finishDeserializeContent(String modID, FriendlyByteBuf buf) {
+ final String version = ModUtil.convertModVersion(buf.readInt());
+ return new AutoFileSyncEntry.ForModFileRequest(modID, false, version);
+ }
+
+ @Override
+ public String toString() {
+ return "Mod " + modID + " (v" + version + ")";
+ }
+ }
+
+ public final NeedTransferPredicate needTransfer;
+ public final File fileName;
+ public final boolean requestContent;
+ private SyncFileHash hash;
+
+ AutoFileSyncEntry(String modID, File fileName, boolean requestContent, NeedTransferPredicate needTransfer) {
+ this(modID, fileName.getName(), fileName, requestContent, needTransfer);
+ }
+
+ AutoFileSyncEntry(String modID, String uniqueID, File fileName, boolean requestContent, NeedTransferPredicate needTransfer) {
+ super(modID, uniqueID);
+ this.needTransfer = needTransfer;
+ this.fileName = fileName;
+ this.requestContent = requestContent;
+ }
+
+
+ public SyncFileHash getFileHash() {
+ if (hash == null) {
+ hash = SyncFileHash.create(modID, fileName, uniqueID);
+ }
+ return hash;
+ }
+
+ public byte[] getContent() {
+ if (!fileName.exists()) return new byte[0];
+ final Path path = fileName.toPath();
+
+ try {
+ return Files.readAllBytes(path);
+ }
+ catch (IOException e) {
+
+ }
+ return new byte[0];
+ }
+
+ public int serializeContent(FriendlyByteBuf buf) {
+ DataHandler.writeString(buf, modID);
+ DataHandler.writeString(buf, uniqueID);
+ return serializeFileContent(buf);
+ }
+
+ public static Triple deserializeContent(FriendlyByteBuf buf) {
+ final String modID = DataHandler.readString(buf);
+ final String uniqueID = DataHandler.readString(buf);
+ byte[] data = deserializeFileContent(buf);
+
+ AutoFileSyncEntry entry;
+ if (AutoSyncID.ForDirectFileRequest.MOD_ID.equals(modID)) {
+ entry = AutoFileSyncEntry.ForDirectFileRequest.finishDeserializeContent(uniqueID, buf);
+ }
+ else if (AutoSyncID.ForModFileRequest.UNIQUE_ID.equals(uniqueID)) {
+ entry = AutoFileSyncEntry.ForModFileRequest.finishDeserializeContent(modID, buf);
+ }
+ else {
+ entry = AutoFileSyncEntry.findMatching(modID, uniqueID);
+ }
+ return new Triple<>(entry, data, new AutoSyncID(modID, uniqueID));
+ }
+
+
+ public void serialize(FriendlyByteBuf buf) {
+ getFileHash().serialize(buf);
+ buf.writeBoolean(requestContent);
+
+ if (requestContent) {
+ serializeFileContent(buf);
+ }
+ }
+
+ public static AutoSync.AutoSyncTriple deserializeAndMatch(FriendlyByteBuf buf) {
+ Pair e = deserialize(buf);
+ AutoFileSyncEntry match = findMatching(e.first);
+ return new AutoSync.AutoSyncTriple(e.first, e.second, match);
+ }
+
+ public static Pair deserialize(FriendlyByteBuf buf) {
+ SyncFileHash hash = SyncFileHash.deserialize(buf);
+ boolean withContent = buf.readBoolean();
+ byte[] data = null;
+ if (withContent) {
+ data = deserializeFileContent(buf);
+ }
+
+ return new Pair(hash, data);
+ }
+
+ private int serializeFileContent(FriendlyByteBuf buf) {
+ if (!PathUtil.isChildOf(PathUtil.GAME_FOLDER, fileName.toPath())){
+ BCLib.LOGGER.error(fileName + " is not within game folder " + PathUtil.GAME_FOLDER + ". Pretending it does not exist.");
+ buf.writeInt(0);
+ return 0;
+ }
+
+ byte[] content = getContent();
+ buf.writeInt(content.length);
+ buf.writeByteArray(content);
+ return content.length;
+ }
+
+ private static byte[] deserializeFileContent(FriendlyByteBuf buf) {
+ byte[] data;
+ int size = buf.readInt();
+ data = buf.readByteArray(size);
+ return data;
+ }
+
+
+ public static AutoFileSyncEntry findMatching(SyncFileHash hash) {
+ return findMatching(hash.modID, hash.uniqueID);
+ }
+
+ public static AutoFileSyncEntry findMatching(AutoSyncID aid) {
+ if (aid instanceof AutoSyncID.ForDirectFileRequest) {
+ AutoSyncID.ForDirectFileRequest freq = (AutoSyncID.ForDirectFileRequest) aid;
+ SyncFolderDescriptor desc = AutoSync.getSyncFolderDescriptor(freq.uniqueID);
+ if (desc != null) {
+ SubFile subFile = desc.getLocalSubFile(freq.relFile.toString());
+ if (subFile != null) {
+ final File absPath = desc.localFolder.resolve(subFile.relPath)
+ .normalize()
+ .toFile();
+ return new AutoFileSyncEntry.ForDirectFileRequest(freq.uniqueID, new File(subFile.relPath), absPath);
+ }
+ }
+ return null;
+ } else if (aid instanceof AutoSyncID.ForModFileRequest) {
+ AutoSyncID.ForModFileRequest mreq = (AutoSyncID.ForModFileRequest) aid;
+ return new AutoFileSyncEntry.ForModFileRequest(mreq.modID, true, null);
+ }
+ return findMatching(aid.modID, aid.uniqueID);
+ }
+
+ public static AutoFileSyncEntry findMatching(String modID, String uniqueID) {
+ return AutoSync.getAutoSyncFiles()
+ .stream()
+ .filter(asf -> asf.modID.equals(modID) && asf.uniqueID.equals(uniqueID))
+ .findFirst()
+ .orElse(null);
+ }
+}
diff --git a/src/main/java/ru/bclib/api/dataexchange/handler/autosync/AutoSync.java b/src/main/java/ru/bclib/api/dataexchange/handler/autosync/AutoSync.java
new file mode 100644
index 00000000..89a33463
--- /dev/null
+++ b/src/main/java/ru/bclib/api/dataexchange/handler/autosync/AutoSync.java
@@ -0,0 +1,187 @@
+package ru.bclib.api.dataexchange.handler.autosync;
+
+import net.fabricmc.loader.api.FabricLoader;
+import ru.bclib.BCLib;
+import ru.bclib.api.dataexchange.DataExchangeAPI;
+import ru.bclib.api.dataexchange.SyncFileHash;
+import ru.bclib.config.Configs;
+import ru.bclib.config.ServerConfig;
+import ru.bclib.util.PathUtil;
+
+import java.io.File;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.BiConsumer;
+
+public class AutoSync {
+ public static final String SYNC_CATEGORY = "auto_sync";
+ public final static SyncFolderDescriptor SYNC_FOLDER = new SyncFolderDescriptor("BCLIB-SYNC", FabricLoader.getInstance()
+ .getGameDir()
+ .resolve("bclib-sync")
+ .normalize()
+ .toAbsolutePath(), true);
+
+ @FunctionalInterface
+ public interface NeedTransferPredicate {
+ public boolean test(SyncFileHash clientHash, SyncFileHash serverHash, FileContentWrapper content);
+ }
+
+ final static class AutoSyncTriple {
+ public final SyncFileHash serverHash;
+ public final byte[] serverContent;
+ public final AutoFileSyncEntry localMatch;
+
+ public AutoSyncTriple(SyncFileHash serverHash, byte[] serverContent, AutoFileSyncEntry localMatch) {
+ this.serverHash = serverHash;
+ this.serverContent = serverContent;
+ this.localMatch = localMatch;
+ }
+
+ @Override
+ public String toString() {
+ return serverHash.modID + "." + serverHash.uniqueID;
+ }
+ }
+
+
+ // ##### File Syncing
+ protected final static List> onWriteCallbacks = new ArrayList<>(2);
+ /**
+ * Register a function that is called whenever the client receives a file from the server and replaced toe local
+ * file with the new content.
+ *
+ * This callback is usefull if you need to reload the new content before the game is quit.
+ *
+ * @param callback A Function that receives the AutoSyncID as well as the Filename.
+ */
+ public static void addOnWriteCallback(BiConsumer callback) {
+ onWriteCallbacks.add(callback);
+ }
+ private static final List autoSyncFiles = new ArrayList<>(4);
+
+ public static List getAutoSyncFiles() {
+ return autoSyncFiles;
+ }
+
+ /**
+ * Registers a File for automatic client syncing.
+ *
+ * @param modID The ID of the calling Mod
+ * @param needTransfer If the predicate returns true, the file needs to get copied to the server.
+ * @param fileName The name of the File
+ * @param requestContent When {@code true} the content of the file is requested for comparison. This will copy the
+ * entire file from the client to the server.
+ *
+ * You should only use this option, if you need to compare parts of the file in order to decide
+ * If the File needs to be copied. Normally using the {@link SyncFileHash}
+ * for comparison is sufficient.
+ */
+ public static void addAutoSyncFileData(String modID, File fileName, boolean requestContent, NeedTransferPredicate needTransfer) {
+ if (!PathUtil.isChildOf(PathUtil.GAME_FOLDER, fileName.toPath())){
+ BCLib.LOGGER.error(fileName + " is outside of Game Folder " + PathUtil.GAME_FOLDER);
+ } else {
+ autoSyncFiles.add(new AutoFileSyncEntry(modID, fileName, requestContent, needTransfer));
+ }
+ }
+
+ /**
+ * Registers a File for automatic client syncing.
+ *
+ * @param modID The ID of the calling Mod
+ * @param uniqueID A unique Identifier for the File. (see {@link SyncFileHash#uniqueID} for
+ * Details
+ * @param needTransfer If the predicate returns true, the file needs to get copied to the server.
+ * @param fileName The name of the File
+ * @param requestContent When {@code true} the content of the file is requested for comparison. This will copy the
+ * entire file from the client to the server.
+ *
+ * You should only use this option, if you need to compare parts of the file in order to decide
+ * If the File needs to be copied. Normally using the {@link SyncFileHash}
+ * for comparison is sufficient.
+ */
+ public static void addAutoSyncFileData(String modID, String uniqueID, File fileName, boolean requestContent, NeedTransferPredicate needTransfer) {
+ if (!PathUtil.isChildOf(PathUtil.GAME_FOLDER, fileName.toPath())){
+ BCLib.LOGGER.error(fileName + " is outside of Game Folder " + PathUtil.GAME_FOLDER);
+ } else {
+ autoSyncFiles.add(new AutoFileSyncEntry(modID, uniqueID, fileName, requestContent, needTransfer));
+ }
+ }
+
+ /**
+ * Called when {@code SendFiles} received a File on the Client and wrote it to the FileSystem.
+ *
+ * This is the place where reload Code should go.
+ *
+ * @param aid The ID of the received File
+ * @param file The location of the FIle on the client
+ */
+ static void didReceiveFile(AutoSyncID aid, File file) {
+ onWriteCallbacks.forEach(fkt -> fkt.accept(aid, file));
+ }
+
+
+ // ##### Folder Syncing
+ static final List syncFolderDescriptions = Arrays.asList(SYNC_FOLDER);
+
+ private List syncFolderContent;
+
+ protected List getSyncFolderContent() {
+ if (syncFolderContent == null) {
+ return new ArrayList<>(0);
+ }
+ return syncFolderContent;
+ }
+
+ private static boolean didRegisterAdditionalMods = false;
+ //we call this from HelloClient on the Server to prepare transfer
+ protected static void loadSyncFolder() {
+ if (Configs.SERVER_CONFIG.isOfferingFiles()) {
+ syncFolderDescriptions.forEach(desc -> desc.loadCache());
+ }
+
+ if (!didRegisterAdditionalMods && Configs.SERVER_CONFIG.isOfferingMods()){
+ didRegisterAdditionalMods = true;
+ List modIDs = Configs.SERVER_CONFIG.get(ServerConfig.ADDITIONAL_MODS);
+ if (modIDs != null){
+ modIDs.stream().forEach(modID -> DataExchangeAPI.registerModDependency(modID));
+ }
+ }
+
+ }
+
+ protected static SyncFolderDescriptor getSyncFolderDescriptor(String folderID) {
+ return syncFolderDescriptions.stream()
+ .filter(d -> d.equals(folderID))
+ .findFirst()
+ .orElse(null);
+ }
+
+ protected static Path localBasePathForFolderID(String folderID) {
+ final SyncFolderDescriptor desc = getSyncFolderDescriptor(folderID);
+ if (desc != null) {
+ return desc.localFolder;
+ }
+ else {
+ BCLib.LOGGER.warning("Unknown Sync-Folder ID '" + folderID + "'");
+ return null;
+ }
+ }
+
+ public static void registerSyncFolder(String folderID, Path localBaseFolder, boolean removeAdditionalFiles) {
+ localBaseFolder = localBaseFolder.normalize();
+ if (PathUtil.isChildOf(PathUtil.GAME_FOLDER, localBaseFolder)) {
+ final SyncFolderDescriptor desc = new SyncFolderDescriptor(folderID, localBaseFolder, removeAdditionalFiles);
+ if (syncFolderDescriptions.contains(desc)) {
+ BCLib.LOGGER.warning("Tried to override Folder Sync '" + folderID + "' again.");
+ }
+ else {
+ syncFolderDescriptions.add(desc);
+ }
+ }
+ else {
+ BCLib.LOGGER.error(localBaseFolder + " (from " + folderID + ") is outside the game directory " + PathUtil.GAME_FOLDER + ". Sync is not allowed.");
+ }
+ }
+}
diff --git a/src/main/java/ru/bclib/api/dataexchange/handler/autosync/AutoSyncID.java b/src/main/java/ru/bclib/api/dataexchange/handler/autosync/AutoSyncID.java
new file mode 100644
index 00000000..9ffbc64f
--- /dev/null
+++ b/src/main/java/ru/bclib/api/dataexchange/handler/autosync/AutoSyncID.java
@@ -0,0 +1,142 @@
+package ru.bclib.api.dataexchange.handler.autosync;
+
+import net.minecraft.network.FriendlyByteBuf;
+import org.jetbrains.annotations.NotNull;
+import ru.bclib.api.dataexchange.DataHandler;
+import ru.bclib.config.Config;
+import ru.bclib.util.ModUtil;
+
+import java.io.File;
+import java.util.Objects;
+
+public class AutoSyncID {
+ static class WithContentOverride extends AutoSyncID {
+ final FileContentWrapper contentWrapper;
+ final File localFile;
+
+ WithContentOverride(String modID, String uniqueID, FileContentWrapper contentWrapper, File localFile) {
+ super(modID, uniqueID);
+ this.contentWrapper = contentWrapper;
+ this.localFile = localFile;
+ }
+
+ @Override
+ public String toString() {
+ return super.toString() + " (Content override)";
+ }
+ }
+
+ static class ForDirectFileRequest extends AutoSyncID {
+ public final static String MOD_ID = "bclib::FILE";
+ final File relFile;
+
+ ForDirectFileRequest(String syncID, File relFile) {
+ super(ForDirectFileRequest.MOD_ID, syncID);
+ this.relFile = relFile;
+ }
+
+ @Override
+ void serializeData(FriendlyByteBuf buf) {
+ super.serializeData(buf);
+ DataHandler.writeString(buf, relFile.toString());
+ }
+
+ static ForDirectFileRequest finishDeserialize(String modID, String uniqueID, FriendlyByteBuf buf){
+ final File fl = new File(DataHandler.readString(buf));
+ return new ForDirectFileRequest(uniqueID, fl);
+ }
+
+ @Override
+ public String toString() {
+ return super.uniqueID + " (" + this.relFile + ")";
+ }
+ }
+
+ static class ForModFileRequest extends AutoSyncID {
+ public final static String UNIQUE_ID = "bclib::MOD";
+ private final String version;
+ ForModFileRequest(String modID, String version) {
+ super(modID, ForModFileRequest.UNIQUE_ID);
+ this.version = version;
+ }
+
+ @Override
+ void serializeData(FriendlyByteBuf buf) {
+ super.serializeData(buf);
+ buf.writeInt(ModUtil.convertModVersion(version));
+ }
+
+ static ForModFileRequest finishDeserialize(String modID, String uniqueID, FriendlyByteBuf buf){
+ final String version = ModUtil.convertModVersion(buf.readInt());
+ return new ForModFileRequest(modID, version);
+ }
+
+ @Override
+ public String toString() {
+ return super.modID + " (v" + this.version + ")";
+ }
+ }
+
+ /**
+ * A Unique ID for the referenced File.
+ *
+ * Files with the same {@link #modID} need to have a unique IDs. Normally the filename from FileHash(String, File, byte[], int, int)
+ * is used to generated that ID, but you can directly specify one using FileHash(String, String, byte[], int, int).
+ */
+ @NotNull
+ public final String uniqueID;
+
+ /**
+ * The ID of the Mod that is registering the File
+ */
+ @NotNull
+ public final String modID;
+
+ public AutoSyncID(String modID, String uniqueID) {
+ Objects.nonNull(modID);
+ Objects.nonNull(uniqueID);
+
+ this.modID = modID;
+ this.uniqueID = uniqueID;
+ }
+
+ @Override
+ public String toString() {
+ return modID + "." + uniqueID;
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) return true;
+ if (!(o instanceof AutoSyncID)) return false;
+ AutoSyncID that = (AutoSyncID) o;
+ return uniqueID.equals(that.uniqueID) && modID.equals(that.modID);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(uniqueID, modID);
+ }
+
+ void serializeData(FriendlyByteBuf buf) {
+ DataHandler.writeString(buf, modID);
+ DataHandler.writeString(buf, uniqueID);
+ }
+
+ static AutoSyncID deserializeData(FriendlyByteBuf buf){
+ String modID = DataHandler.readString(buf);
+ String uID = DataHandler.readString(buf);
+
+ if (ForDirectFileRequest.MOD_ID.equals(modID)){
+ return ForDirectFileRequest.finishDeserialize(modID, uID, buf);
+ } else if (ForModFileRequest.UNIQUE_ID.equals(uID)){
+ return ForModFileRequest.finishDeserialize(modID, uID, buf);
+ } else{
+ return new AutoSyncID(modID, uID);
+ }
+ }
+
+ public boolean isConfigFile(){
+ return this.uniqueID.startsWith(Config.CONFIG_SYNC_PREFIX);
+ }
+}
diff --git a/src/main/java/ru/bclib/api/dataexchange/handler/autosync/Chunker.java b/src/main/java/ru/bclib/api/dataexchange/handler/autosync/Chunker.java
new file mode 100644
index 00000000..bc669f3b
--- /dev/null
+++ b/src/main/java/ru/bclib/api/dataexchange/handler/autosync/Chunker.java
@@ -0,0 +1,270 @@
+package ru.bclib.api.dataexchange.handler.autosync;
+
+import net.fabricmc.fabric.api.networking.v1.PacketByteBufs;
+import net.fabricmc.fabric.api.networking.v1.PacketSender;
+import net.fabricmc.fabric.api.networking.v1.ServerPlayNetworking;
+import net.minecraft.client.Minecraft;
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.util.ProgressListener;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import ru.bclib.BCLib;
+import ru.bclib.api.dataexchange.BaseDataHandler;
+import ru.bclib.api.dataexchange.DataHandler;
+import ru.bclib.api.dataexchange.DataHandlerDescriptor;
+import ru.bclib.api.dataexchange.handler.DataExchange;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.UUID;
+
+/**
+ * Used to seperate large data transfers into multiple smaller messages.
+ *
+ * {@link DataHandler} will automatically convert larger messages into Chunks on the Server
+ * and assemble the original message from those chunks on the client.
+ */
+public class Chunker extends DataHandler.FromServer {
+
+ /**
+ * Responsible for assembling the original ByteBuffer created by {@link PacketChunkSender} on the
+ * receiving end. Automatically created from the header {@link Chunker}-Message (where the serialNo==-1)
+ */
+ static class PacketChunkReceiver {
+ @NotNull
+ public final UUID uuid;
+ public final int chunkCount;
+ @NotNull
+ private final FriendlyByteBuf networkedBuf;
+ @Nullable
+ private final DataHandlerDescriptor descriptor;
+
+ private static List active = new ArrayList<>(1);
+ private static PacketChunkReceiver newReceiver(@NotNull UUID uuid, int chunkCount, ResourceLocation origin){
+ DataHandlerDescriptor desc = DataExchange.getDescriptor(origin);
+ final PacketChunkReceiver r = new PacketChunkReceiver(uuid, chunkCount, desc);
+ active.add(r);
+ return r;
+ }
+
+ private static PacketChunkReceiver getOrCreate(@NotNull UUID uuid, int chunkCount, ResourceLocation origin){
+ return active.stream().filter(r -> r.uuid.equals(uuid)).findFirst().orElse(newReceiver(uuid, chunkCount, origin));
+ }
+
+ public static PacketChunkReceiver get(@NotNull UUID uuid){
+ return active.stream().filter(r -> r.uuid.equals(uuid)).findFirst().orElse(null);
+ }
+
+ private PacketChunkReceiver(@NotNull UUID uuid, int chunkCount, @Nullable DataHandlerDescriptor descriptor){
+ this.uuid = uuid;
+ this.chunkCount = chunkCount;
+ networkedBuf = PacketByteBufs.create();
+ this.descriptor = descriptor;
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) return true;
+ if (!(o instanceof PacketChunkReceiver)) return false;
+ PacketChunkReceiver that = (PacketChunkReceiver) o;
+ return uuid.equals(that.uuid);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(uuid);
+ }
+
+ public boolean testFinished(){
+ ProgressListener listener = ChunkerProgress.getProgressListener();
+ if (listener!=null){
+ listener.progressStagePercentage((100*receivedCount)/chunkCount);
+ }
+ if (incomingBuffer == null){
+ return true;
+ } if (lastReadSerial>=chunkCount-1){
+ onFinish();
+ return true;
+ }
+ return false;
+ }
+
+ private void addBuffer(FriendlyByteBuf input){
+ final int size = input.readableBytes();
+ final int cap = networkedBuf.capacity()-networkedBuf.writerIndex();
+
+ if (cap < size){
+ networkedBuf.capacity(networkedBuf.writerIndex() + size);
+ }
+ input.readBytes(networkedBuf, size);
+ input.clear();
+ }
+
+ protected void onFinish(){
+ incomingBuffer.clear();
+ incomingBuffer = null;
+
+ final BaseDataHandler baseHandler = descriptor.INSTANCE.get();
+ if (baseHandler instanceof DataHandler.FromServer handler){
+ handler.receiveFromMemory(networkedBuf);
+ }
+ }
+
+ Map