Import all versions (#8)

* Import all versions * Prepare first workflow * Cleanup build scripts * More cleanup * Cleanup more stuff and 1.7 on server * Run multiple tasks in parallel * Use version in job name * Error on missing files * Backport EULA mixin * Update upload artifact * Prevent build getting stuck * Cleanup code * More code cleanup * Update build.yml * Fix compilation --------- Co-authored-by: Romain Beaumont <romain.rom1@gmail.com>
2023-12-31 20:25:13 +01:00
parent 5441b07c50
commit a48fb9912d
556 changed files with 30777 additions and 814 deletions
@@ -0,0 +1,63 @@
+plugins {
+    id 'fabric-loom'
+}
+
+repositories {
+    maven {
+        name = "legacy-fabric"
+        url = "https://maven.legacyfabric.net"
+    }
+}
+
+loom {
+    setIntermediaryUrl('https://maven.legacyfabric.net/net/fabricmc/intermediary/%1$s/intermediary-%1$s-v2.jar');
+    customMinecraftManifest.set("https://meta.legacyfabric.net/v2/manifest/${minecraft_version}")
+}
+
+dependencies {
+    minecraft "com.mojang:minecraft:${project.minecraft_version}"
+    mappings "net.fabricmc:yarn:${project.yarn_mappings}:v2"
+    modImplementation "net.fabricmc:fabric-loader:${project.loader_version}"
+
+    // Fabric API provides hooks for events, item registration, and more. As most mods will need this, it's included by default.
+    // If you know for a fact you don't, it's not required and can be safely removed.
+//    modImplementation ("net.legacyfabric.legacy-fabric-api:legacy-fabric-api:${fabric_version}") {
+//        exclude module: "legacy-fabric-entity-events-v1"
+//    }
+
+    if (System.getProperty("os.name").toLowerCase().contains("mac")) {
+        implementation 'org.lwjgl.lwjgl:lwjgl_util:2.9.4-nightly-20150209'
+        implementation 'org.lwjgl.lwjgl:lwjgl:2.9.4-nightly-20150209'
+        implementation 'org.lwjgl.lwjgl:lwjgl-platform:2.9.4-nightly-20150209'
+    }
+}
+
+if (System.getProperty("os.name").toLowerCase().contains("mac")) {
+    configurations.configureEach {
+        resolutionStrategy {
+            dependencySubstitution {
+                substitute module('org.lwjgl.lwjgl:lwjgl_util:2.9.2-nightly-201408222') with module('org.lwjgl.lwjgl:lwjgl_util:2.9.4-nightly-20150209')
+                substitute module('org.lwjgl.lwjgl:lwjgl:2.9.2-nightly-201408222') with module('org.lwjgl.lwjgl:lwjgl:2.9.4-nightly-20150209')
+            }
+            force 'org.lwjgl.lwjgl:lwjgl-platform:2.9.4-nightly-20150209'
+        }
+    }
+}
+
+processResources {
+    filteringCharset "UTF-8"
+
+    filesMatching("fabric.mod.json") {
+        expand "version": project.version
+    }
+}
+
+tasks.withType(JavaCompile).configureEach {
+    it.options.encoding = "UTF-8"
+}
+
+java {
+    toolchain {
+        languageVersion.set(JavaLanguageVersion.of(17))
+    }
+}
@@ -0,0 +1,7 @@
+# Fabric Properties
+# More versions available at: https://grayray75.github.io/LegacyFabric-Versions/
+minecraft_version=1.8.9
+yarn_mappings=1.8.9+build.202206020145
+loader_version=0.14.3
+# Dependencies
+# More versions available at: https://grayray75.github.io/LegacyFabric-Versions/
@@ -0,0 +1,81 @@
+package dev.u9g.minecraftdatagenerator.ClientSideAnnoyances;
+
+import dev.u9g.minecraftdatagenerator.util.EmptyBlockView;
+import net.minecraft.block.*;
+import net.minecraft.client.color.world.BiomeColors;
+import net.minecraft.client.color.world.FoliageColors;
+import net.minecraft.util.math.BlockPos;
+
+import static net.minecraft.block.RedstoneWireBlock.POWER;
+
+public class BiomeBlockColors {
+    // generated manually from each Biome's Biome#getBlockColor
+    public static int getBlockColor(Block block, BlockState state) {
+        if (block instanceof AbstractFluidBlock) {
+            return BiomeColors.getWaterColor(EmptyBlockView.INSTANCE, BlockPos.ORIGIN);
+        } else if (block instanceof AttachedStemBlock) {
+            return getAttachedStemColor(state, block);
+        } else if (block instanceof DoublePlantBlock) {
+            EmptyBlockView bv = new EmptyBlockView() {
+                @Override
+                public BlockState getBlockState(BlockPos pos) {
+                    return state;
+                }
+            };
+            DoublePlantBlock.DoublePlantType doublePlantType = ((DoublePlantBlock) block).getVariant(bv, BlockPos.ORIGIN);
+            if (doublePlantType == DoublePlantBlock.DoublePlantType.GRASS || doublePlantType == DoublePlantBlock.DoublePlantType.FERN) {
+                return BiomeColors.getGrassColor(bv, BlockPos.ORIGIN);
+            }
+        } else if (block instanceof FlowerPotBlock) {
+            // FIXME: Yeah, flower pot block's color depends on the block inside of it, since we dont compute that, let's just not do anything
+//            Item item;
+//            BlockEntity blockEntity = view.getBlockEntity(pos);
+//            if (blockEntity instanceof FlowerPotBlockEntity && (item = ((FlowerPotBlockEntity)blockEntity).getItem()) instanceof BlockItem) {
+//                return Block.getBlockFromItem(item).getBlockColor(view, pos, id);
+//            }
+        } else if (block instanceof GrassBlock) {
+            return BiomeColors.getGrassColor(EmptyBlockView.INSTANCE, BlockPos.ORIGIN);
+        } else if (block instanceof Leaves1Block) {
+            return getLeaves1Color(state, block);
+        } else if (block instanceof LeavesBlock) {
+            return getLeavesColor();
+        } else if (block instanceof RedstoneWireBlock) {
+            if (state.getBlock() == block) {
+                return ServerSideRedstoneWireBlock.getWireColor(state.get(POWER));
+            }
+        } else if (block instanceof SugarCaneBlock || block instanceof TallPlantBlock) {
+            return GrassColors.getGrassColor(EmptyBlockView.INSTANCE.getBiome(BlockPos.ORIGIN));
+        } else if (block instanceof VineBlock) {
+            return dev.u9g.minecraftdatagenerator.ClientSideAnnoyances.FoliageColors.getFoliageColor(EmptyBlockView.INSTANCE.getBiome(BlockPos.ORIGIN));
+        }
+        return 0xFFFFFF;
+    }
+
+    private static int getLeaves1Color(BlockState blockState, Block block) {
+        if (blockState.getBlock() == block) {
+            PlanksBlock.WoodType woodType = blockState.get(Leaves1Block.VARIANT);
+            if (woodType == PlanksBlock.WoodType.SPRUCE) {
+                return net.minecraft.client.color.world.FoliageColors.getSpruceColor();
+            }
+            if (woodType == PlanksBlock.WoodType.BIRCH) {
+                return FoliageColors.getBirchColor();
+            }
+        }
+        return getLeavesColor();
+    }
+
+    private static int getLeavesColor() {
+        return FoliageColors.getColor(0.5, 1.0);
+    }
+
+    private static int getAttachedStemColor(BlockState state, Block block) {
+        if (state.getBlock() != block) {
+            return 0xFFFFFF;
+        }
+        int i = state.get(AttachedStemBlock.AGE);
+        int j = i * 32;
+        int k = 255 - i * 8;
+        int l = i * 4;
+        return j << 16 | k << 8 | l;
+    }
+}
@@ -0,0 +1,46 @@
+package dev.u9g.minecraftdatagenerator.ClientSideAnnoyances;
+
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.BlockView;
+import net.minecraft.world.biome.Biome;
+
+import java.util.Iterator;
+
+public class BiomeColors {
+    private static final ColorProvider GRASS_COLOR = (biome, pos) -> biome.getGrassColor(pos);
+    private static final ColorProvider FOLIAGE_COLOR = (biome, pos) -> biome.getFoliageColor(pos);
+    private static final ColorProvider WATER_COLOR = (biome, pos) -> biome.waterColor;
+
+    private static int getColor(BlockView view, BlockPos pos, ColorProvider provider) {
+        int i = 0;
+        int j = 0;
+        int k = 0;
+
+        int l;
+        for (Iterator iterator = BlockPos.mutableIterate(pos.add(-1, 0, -1), pos.add(1, 0, 1)).iterator(); iterator.hasNext(); k += l & 255) {
+            BlockPos.Mutable mutable = (BlockPos.Mutable) iterator.next();
+            l = provider.getColorAtPos(view.getBiome(mutable), mutable);
+            i += (l & 16711680) >> 16;
+            j += (l & '\uff00') >> 8;
+        }
+
+        return (i / 9 & 255) << 16 | (j / 9 & 255) << 8 | k / 9 & 255;
+    }
+
+    public static int getGrassColor(BlockView view, BlockPos pos) {
+        return getColor(view, pos, GRASS_COLOR);
+    }
+
+    public static int getFoliageColor(BlockView view, BlockPos pos) {
+        return getColor(view, pos, FOLIAGE_COLOR);
+    }
+
+    public static int getWaterColor(BlockView view, BlockPos pos) {
+        return getColor(view, pos, WATER_COLOR);
+    }
+
+    interface ColorProvider {
+        int getColorAtPos(Biome biome, BlockPos pos);
+    }
+}
+
@@ -0,0 +1,38 @@
+package dev.u9g.minecraftdatagenerator.ClientSideAnnoyances;
+
+import net.minecraft.util.math.MathHelper;
+import net.minecraft.world.biome.Biome;
+
+public class FoliageColors {
+    private static int[] colorMap = new int[65536];
+
+    public static void setColorMap(int[] pixels) {
+        colorMap = pixels;
+    }
+
+    public static int getColor(double temperature, double humidity) {
+        humidity *= temperature;
+        int i = (int) ((1.0D - temperature) * 255.0D);
+        int j = (int) ((1.0D - humidity) * 255.0D);
+        return colorMap[j << 8 | i];
+    }
+
+    public static int getSpruceColor() {
+        return 6396257;
+    }
+
+    public static int getBirchColor() {
+        return 8431445;
+    }
+
+    public static int getDefaultColor() {
+        return 4764952;
+    }
+
+    public static int getFoliageColor(Biome biome) {
+        double d = MathHelper.clamp(biome.temperature, 0.0f, 1.0f);
+        double e = MathHelper.clamp(biome.downfall, 0.0f, 1.0f);
+        return FoliageColors.getColor(d, e);
+    }
+}
+
@@ -0,0 +1,29 @@
+package dev.u9g.minecraftdatagenerator.ClientSideAnnoyances;
+
+import net.minecraft.util.math.MathHelper;
+import net.minecraft.world.biome.Biome;
+
+public class GrassColors {
+    private static int[] colorMap = new int[65536];
+
+    public static void setColorMap(int[] map) {
+        colorMap = map;
+    }
+
+    public static int getColor(double temperature, double humidity) {
+        humidity *= temperature;
+        int i = (int) ((1.0D - temperature) * 255.0D);
+        int j = (int) ((1.0D - humidity) * 255.0D);
+        int k = j << 8 | i;
+        return k > colorMap.length ? -65281 : colorMap[k];
+    }
+
+    public static int getGrassColor(Biome biome) {
+        double d = MathHelper.clamp(biome.temperature, 0.0f, 1.0f);
+        double e = MathHelper.clamp(biome.downfall, 0.0f, 1.0f);
+        return GrassColors.getColor(d, e);
+    }
+}
+
+
+
@@ -0,0 +1,28 @@
+package dev.u9g.minecraftdatagenerator.ClientSideAnnoyances;
+
+import net.minecraft.util.math.MathHelper;
+
+public class ServerSideRedstoneWireBlock {
+    public static int getWireColor(int powerLevel) {
+        float f = (float) powerLevel / 15.0F;
+        float g = f * 0.6F + 0.4F;
+        if (powerLevel == 0) {
+            g = 0.3F;
+        }
+
+        float h = f * f * 0.7F - 0.5F;
+        float j = f * f * 0.6F - 0.7F;
+        if (h < 0.0F) {
+            h = 0.0F;
+        }
+
+        if (j < 0.0F) {
+            j = 0.0F;
+        }
+
+        int k = MathHelper.clamp((int) (g * 255.0F), 0, 255);
+        int l = MathHelper.clamp((int) (h * 255.0F), 0, 255);
+        int m = MathHelper.clamp((int) (j * 255.0F), 0, 255);
+        return -16777216 | k << 16 | l << 8 | m;
+    }
+}
@@ -0,0 +1,13 @@
+package dev.u9g.minecraftdatagenerator;
+
+import net.fabricmc.api.ModInitializer;
+
+import java.util.logging.Logger;
+
+public class Main implements ModInitializer {
+    public static final Logger LOGGER = Logger.getLogger("mc-data-gen-serv");
+
+    @Override
+    public void onInitialize() {
+    }
+}
@@ -0,0 +1,33 @@
+package dev.u9g.minecraftdatagenerator.generators;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import dev.u9g.minecraftdatagenerator.mixin.LanguageAccessor;
+import net.minecraft.util.Language;
+
+import java.util.Map;
+
+public class AttributesDataGenerator implements IDataGenerator {
+    @Override
+    public String getDataName() {
+        return "attributes";
+    }
+
+    @Override
+    public JsonElement generateDataJson() {
+        Language lang = new Language();
+        Map<String, String> translations = ((LanguageAccessor) lang).translations();
+        JsonArray arr = new JsonArray();
+        for (Map.Entry<String, String> translation : translations.entrySet()) {
+            String key = translation.getKey();
+            if (!key.startsWith("attribute.name.")) continue;
+            JsonObject obj = new JsonObject();
+            key = key.replace("attribute.name.", "");
+            obj.addProperty("name", key.split("\\.")[1]);
+            obj.addProperty("resource", key);
+            arr.add(obj);
+        }
+        return arr;
+    }
+}
@@ -0,0 +1,190 @@
+package dev.u9g.minecraftdatagenerator.generators;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+import dev.u9g.minecraftdatagenerator.mixin.BiomeAccessor;
+import dev.u9g.minecraftdatagenerator.util.Registries;
+import net.minecraft.world.biome.*;
+import org.apache.commons.lang3.StringUtils;
+
+import java.util.Locale;
+
+public class BiomesDataGenerator implements IDataGenerator {
+
+    private static String guessBiomeDimensionFromCategory(Biome biome) {
+        if (biome instanceof NetherBiome) {
+            return "nether";
+        } else if (biome instanceof EndBiome) {
+            return "end";
+        }
+        return "overworld";
+    }
+
+    private static int getBiomeColorFor(String biomeDisplayNamed) {
+        if (biomeDisplayNamed.equals("Redwood Taiga Hills M")) {
+            biomeDisplayNamed = "MegaTaigaHills";
+        }
+        String biomeDisplayName = StringUtils.join(biomeDisplayNamed.split(" "), "");
+        return switch (biomeDisplayName) {
+            case "Ocean" -> 112;
+            case "Plains" -> 9286496;
+            case "Desert" -> 16421912;
+            case "ExtremeHills", "Extreme Hills" -> 6316128;
+            case "Forest" -> 353825;
+            case "Taiga" -> 747097;
+            case "Swampland" -> 522674;
+            case "River" -> 255;
+            case "Hell" -> 16711680;
+            case "TheEnd", "The End" -> 8421631;
+            case "FrozenOcean", "Frozen Ocean" -> 7368918;
+            case "FrozenRiver", "Frozen River" -> 10526975;
+            case "IcePlains", "Ice Plains" -> 16777215;
+            case "IceMountains", "Ice Mountains" -> 10526880;
+            case "MushroomIsland", "Mushroom Island" -> 16711935;
+            case "MushroomIslandShore", "Mushroom Island Shore" -> 10486015;
+            case "Beach" -> 16440917;
+            case "DesertHills", "Desert Hills" -> 13786898;
+            case "ForestHills", "Forest Hills" -> 2250012;
+            case "TaigaHills", "Taiga Hills" -> 1456435;
+            case "ExtremeHillsEdge", "Extreme Hills Edge" -> 7501978;
+            case "Jungle" -> 5470985;
+            case "JungleHills", "Jungle Hills" -> 2900485;
+            case "JungleEdge", "Jungle Edge" -> 6458135;
+            case "DeepOcean", "Deep Ocean" -> 48;
+            case "StoneBeach", "Stone Beach" -> 10658436;
+            case "ColdBeach", "Cold Beach" -> 16445632;
+            case "BirchForest", "Birch Forest" -> 3175492;
+            case "BirchForestHills", "Birch Forest Hills" -> 2055986;
+            case "RoofedForest", "Roofed Forest" -> 4215066;
+            case "ColdTaiga", "Cold Taiga" -> 3233098;
+            case "ColdTaigaHills", "Cold Taiga Hills" -> 2375478;
+            case "MegaTaiga", "Mega Taiga" -> 5858897;
+            case "MegaTaigaHills", "Mega Taiga Hills" -> 4542270;
+            case "ExtremeHills+", "Extreme Hills+" -> 5271632;
+            case "Savanna" -> 12431967;
+            case "SavannaPlateau", "Savanna Plateau" -> 10984804;
+            case "Mesa" -> 14238997;
+            case "MesaPlateauF", "Mesa Plateau F" -> 11573093;
+            case "MesaPlateau", "Mesa Plateau" -> 13274213;
+            case "TheEnd-Floatingislands", "The End - Floating islands" -> 8421631;
+            case "TheEnd-Mediumisland", "The End - Medium island" -> 8421631;
+            case "TheEnd-Highisland", "The End - High island" -> 8421631;
+            case "TheEnd-Barrenisland", "The End - Barren island" -> 8421631;
+            case "WarmOcean", "Warm Ocean" -> 172;
+            case "LukewarmOcean", "Lukewarm Ocean" -> 144;
+            case "ColdOcean", "Cold Ocean" -> 2105456;
+            case "WarmDeepOcean", "Warm Deep Ocean" -> 80;
+            case "LukewarmDeepOcean", "Lukewarm Deep Ocean" -> 64;
+            case "ColdDeepOcean", "Cold Deep Ocean" -> 2105400;
+            case "FrozenDeepOcean", "Frozen Deep Ocean" -> 4210832;
+            case "TheVoid", "The Void" -> 0;
+            case "SunflowerPlains", "Sunflower Plains" -> 11918216;
+            case "DesertM", "Desert M" -> 16759872;
+            case "ExtremeHillsM", "Extreme Hills M" -> 8947848;
+            case "FlowerForest", "Flower Forest" -> 2985545;
+            case "TaigaM", "Taiga M" -> 3378817;
+            case "SwamplandM", "Swampland M" -> 3145690;
+            case "IcePlainsSpikes", "Ice Plains Spikes" -> 11853020;
+            case "JungleM", "Jungle M" -> 8102705;
+            case "JungleEdgeM", "Jungle Edge M" -> 9089855;
+            case "BirchForestM", "Birch Forest M" -> 5807212;
+            case "BirchForestHillsM", "Birch Forest Hills M" -> 4687706;
+            case "RoofedForestM", "Roofed Forest M" -> 6846786;
+            case "ColdTaigaM", "Cold Taiga M" -> 5864818;
+            case "MegaSpruceTaiga", "Mega Spruce Taiga" -> 8490617;
+            case "MegaSpruceTaiga(Hills)", "Mega Spruce Taiga (Hills)" -> 7173990;
+            case "ExtremeHills+M", "Extreme Hills+ M" -> 7903352;
+            case "SavannaM", "Savanna M" -> 15063687;
+            case "SavannaPlateauM", "Savanna Plateau M" -> 13616524;
+            case "Mesa(Bryce)", "Mesa (Bryce)" -> 16739645;
+            case "MesaPlateauFM", "Mesa Plateau F M" -> 14204813;
+            case "MesaPlateauM", "Mesa Plateau M" -> 15905933;
+            case "BambooJungle", "Bamboo Jungle" -> 7769620;
+            case "BambooJungleHills", "Bamboo Jungle Hills" -> 3884810;
+            default -> throw new Error("Unexpected biome, with name: '" + biomeDisplayName + "'");
+        };
+    }
+
+    public static JsonObject generateBiomeInfo(Biome biome) {
+        JsonObject biomeDesc = new JsonObject();
+//        Identifier registryKey = registry.getIdentifier(biome);
+
+        biomeDesc.addProperty("id", Registries.BIOMES.getRawId(biome));
+        biomeDesc.addProperty("name", String.join("_", ((BiomeAccessor) biome).name().toLowerCase(Locale.ENGLISH).split(" ")));
+        biomeDesc.addProperty("category", category(biome));
+        biomeDesc.addProperty("temperature", biome.temperature);
+        biomeDesc.addProperty("precipitation", precipitation(biome));
+        biomeDesc.addProperty("depth", biome.depth);
+        biomeDesc.addProperty("dimension", guessBiomeDimensionFromCategory(biome));
+        biomeDesc.addProperty("displayName", ((BiomeAccessor) biome).name());
+        biomeDesc.addProperty("color", getBiomeColorFor(((BiomeAccessor) biome).name()));
+        biomeDesc.addProperty("rainfall", biome.downfall);
+
+        return biomeDesc;
+    }
+
+    private static String category(Biome biome) {
+        if (biome instanceof ForestBiome) {
+            return "forest";
+        } else if (biome instanceof OceanBiome) {
+            return "ocean";
+        } else if (biome instanceof PlainsBiome) {
+            return "plains";
+        } else if (biome instanceof DesertBiome) {
+            return "desert";
+        } else if (biome instanceof ExtremeHillsBiome) {
+            return "extreme_hills";
+        } else if (biome instanceof TaigaBiome) {
+            return "taiga";
+        } else if (biome instanceof SwampBiome) {
+            return "swamp";
+        } else if (biome instanceof RiverBiome) {
+            return "river";
+        } else if (biome instanceof NetherBiome) {
+            return "nether";
+        } else if (biome instanceof EndBiome) {
+            return "the_end";
+        } else if (biome instanceof IceBiome) {
+            return "icy";
+        } else if (biome instanceof MushroomBiome) {
+            return "mushroom";
+        } else if (biome instanceof BeachBiome) {
+            return "beach";
+        } else if (biome instanceof JungleBiome) {
+            return "jungle";
+        } else if (biome instanceof SavannaBiome) {
+            return "savanna";
+        } else if (biome instanceof MesaBiome) {
+            return "mesa";
+        } else if (biome instanceof StoneBeachBiome) {
+            return "none"; // Should StoneBeachBiome be beach too? this is how it is now in mcdata
+        }
+        throw new Error("Unable to find biome category for " + biome.getClass().getName());
+    }
+
+    private static String precipitation(Biome biome) {
+        float rainfall = biome.downfall;
+        float temperature = biome.temperature;
+        if (rainfall == 0) {
+            return "none";
+        } else if (temperature < 0.2f) {
+            return "snow";
+        }
+        return "rain";
+    }
+
+    @Override
+    public String getDataName() {
+        return "biomes";
+    }
+
+    @Override
+    public JsonArray generateDataJson() {
+        JsonArray biomesArray = new JsonArray();
+
+        for (Biome biome : Registries.BIOMES) {
+            biomesArray.add(generateBiomeInfo(biome));
+        }
+        return biomesArray;
+    }
+}
@@ -0,0 +1,126 @@
+package dev.u9g.minecraftdatagenerator.generators;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonPrimitive;
+import dev.u9g.minecraftdatagenerator.util.DGU;
+import dev.u9g.minecraftdatagenerator.util.Registries;
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockState;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Box;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+public class BlockCollisionShapesDataGenerator implements IDataGenerator {
+    private static final Box ENTITY_BOX = new Box(0.0D, 0.0D, 0.0D, 1.0D, 2.0D, 1.0D);
+
+    private static String nameOf(Block block) {
+        return Objects.requireNonNull(Registries.BLOCKS.getIdentifier(block)).getPath();
+    }
+
+    private static JsonArray jsonOf(Box box) {
+        JsonArray arr = new JsonArray();
+        if (box == null) return arr;
+        arr.add(new JsonPrimitive(box.minX));
+        arr.add(new JsonPrimitive(box.minY));
+        arr.add(new JsonPrimitive(box.minZ));
+        arr.add(new JsonPrimitive(box.maxX));
+        arr.add(new JsonPrimitive(box.maxY));
+        arr.add(new JsonPrimitive(box.maxZ));
+        return arr;
+    }
+
+    @Override
+    public String getDataName() {
+        return "blockCollisionShapes";
+    }
+
+    @Override
+    public JsonObject generateDataJson() {
+        ShapeCache shapeCache = new ShapeCache();
+        JsonObject blocksObject = new JsonObject();
+        for (Block block : Registries.BLOCKS) {
+            Object val = shapeCache.addShapesFrom(block);
+            if (val instanceof JsonArray) {
+                blocksObject.add(nameOf(block), (JsonElement) val);
+            } else {
+                blocksObject.addProperty(nameOf(block), (Integer) val);
+            }
+        }
+        JsonObject resultObject = new JsonObject();
+        resultObject.add("blocks", blocksObject);
+        resultObject.add("shapes", shapeCache.toJSON());
+        return resultObject;
+    }
+
+    public static class ShapeCache {
+        private final ArrayList<Shapes> shapesCache = new ArrayList<>();
+
+        public Object addShapesFrom(Block block) {
+            List<Integer> indexesOfBoxesInTheShapesCache = new ArrayList<>();
+            for (BlockState state : block.getStateManager().getBlockStates().reverse()) {
+                List<Box> boxes = new ArrayList<>();
+                try {
+                    block.appendCollisionBoxes(DGU.getWorld(), BlockPos.ORIGIN, state, ENTITY_BOX, boxes, null);
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+                Shapes thisBlockStateShapes = new Shapes(boxes);
+                int indexOfThisBlockStatesShapes = shapesCache.indexOf(thisBlockStateShapes);
+                if (indexOfThisBlockStatesShapes != -1) {
+                    indexesOfBoxesInTheShapesCache.add(indexOfThisBlockStatesShapes);
+                } else {
+                    shapesCache.add(thisBlockStateShapes);
+                    indexesOfBoxesInTheShapesCache.add(shapesCache.size() - 1);
+                }
+            }
+            if (indexesOfBoxesInTheShapesCache.stream().distinct().count() < 2) {
+                return indexesOfBoxesInTheShapesCache.get(0);
+            } else {
+                JsonArray shapeIndexes = new JsonArray();
+                indexesOfBoxesInTheShapesCache.forEach(shapeIndex -> shapeIndexes.add(new JsonPrimitive(shapeIndex)));
+                return shapeIndexes;
+            }
+        }
+
+        public JsonObject toJSON() {
+            JsonObject shapes = new JsonObject();
+            int i = 0;
+            for (Shapes s : shapesCache) {
+                shapes.add(String.valueOf(i++), s.toJSON());
+            }
+            return shapes;
+        }
+
+        private static class Shapes {
+            final List<Box> boxes;
+
+            public Shapes(List<Box> boxes) {
+                this.boxes = boxes;
+            }
+
+            public JsonArray toJSON() {
+                JsonArray arr = new JsonArray();
+                boxes.forEach(box -> arr.add(jsonOf(box)));
+                return arr;
+            }
+
+            @Override
+            public boolean equals(Object o) {
+                if (this == o) return true;
+                if (o == null || getClass() != o.getClass()) return false;
+                Shapes shapes = (Shapes) o;
+                return Objects.equals(boxes, shapes.boxes);
+            }
+
+            @Override
+            public int hashCode() {
+                return boxes != null ? boxes.hashCode() : 0;
+            }
+        }
+    }
+}
@@ -0,0 +1,151 @@
+package dev.u9g.minecraftdatagenerator.generators;
+
+import com.google.common.base.CaseFormat;
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonPrimitive;
+import dev.u9g.minecraftdatagenerator.Main;
+import dev.u9g.minecraftdatagenerator.mixin.BlockAccessor;
+import dev.u9g.minecraftdatagenerator.mixin.MiningToolItemAccessor;
+import dev.u9g.minecraftdatagenerator.util.DGU;
+import dev.u9g.minecraftdatagenerator.util.Registries;
+import net.minecraft.block.AirBlock;
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockState;
+import net.minecraft.block.TransparentBlock;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.ToolItem;
+import net.minecraft.state.property.BooleanProperty;
+import net.minecraft.state.property.EnumProperty;
+import net.minecraft.state.property.IntProperty;
+import net.minecraft.state.property.Property;
+import net.minecraft.util.Identifier;
+import net.minecraft.util.math.BlockPos;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Objects;
+import java.util.logging.Logger;
+
+public class BlocksDataGenerator implements IDataGenerator {
+
+    private static final Logger logger = Main.LOGGER;
+
+    private static List<Item> getItemsEffectiveForBlock(Block block) {
+        List<Item> items = new ArrayList<>();
+        for (Item item : Registries.ITEMS) {
+            if (item instanceof ToolItem && ((MiningToolItemAccessor) item).getEffectiveBlocks().contains(block)) {
+                items.add(item);
+            }
+        }
+        return items;
+    }
+
+    private static List<ItemStack> populateDropsIfPossible(BlockState blockState, Item firstToolItem) {
+        return new ArrayList<>();
+    }
+
+    private static String getPropertyTypeName(Property<?> property) {
+        //Explicitly handle default minecraft properties
+        if (property instanceof BooleanProperty) {
+            return "bool";
+        }
+        if (property instanceof IntProperty) {
+            return "int";
+        }
+        if (property instanceof EnumProperty) {
+            return "enum";
+        }
+
+        //Use simple class name as fallback, this code will give something like
+        //example_type for ExampleTypeProperty class name
+        String rawPropertyName = property.getClass().getSimpleName().replace("Property", "");
+        return CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_UNDERSCORE, rawPropertyName);
+    }
+
+    private static <T extends Comparable<T>> JsonObject generateStateProperty(Property<T> property) {
+        JsonObject propertyObject = new JsonObject();
+        Collection<T> propertyValues = property.getValues();
+
+        propertyObject.addProperty("name", property.getName());
+        propertyObject.addProperty("type", getPropertyTypeName(property));
+        propertyObject.addProperty("num_values", propertyValues.size());
+
+        //Do not add values for vanilla boolean properties, they are known by default
+        if (!(property instanceof BooleanProperty)) {
+            JsonArray propertyValuesArray = new JsonArray();
+            for (T propertyValue : propertyValues) {
+                propertyValuesArray.add(new JsonPrimitive(property.name(propertyValue)));
+            }
+            propertyObject.add("values", propertyValuesArray);
+        }
+        return propertyObject;
+    }
+
+    public static JsonObject generateBlock(Block block) {
+        JsonObject blockDesc = new JsonObject();
+
+        List<BlockState> blockStates = block.getStateManager().getBlockStates();
+        BlockState defaultState = block.getDefaultState();
+        Identifier registryKey = Registries.BLOCKS.getIdentifier(block);
+        List<Item> effectiveTools = getItemsEffectiveForBlock(block);
+
+        blockDesc.addProperty("id", Registries.BLOCKS.getRawId(block));
+        blockDesc.addProperty("name", Objects.requireNonNull(registryKey).getPath());
+        if (!block.getTranslatedName().startsWith("tile.")) {
+            blockDesc.addProperty("displayName", block.getTranslatedName());
+        }
+
+        float hardness = block.getStrength(null, null);
+
+        blockDesc.addProperty("hardness", hardness);
+        blockDesc.addProperty("resistance", ((BlockAccessor) block).getBlastResistance());
+        blockDesc.addProperty("diggable", hardness != -1.0f && !(block instanceof AirBlock));
+        JsonObject effTools = new JsonObject();
+        effectiveTools.forEach(item -> effTools.addProperty(
+                String.valueOf(Registries.ITEMS.getRawId(item)), // key
+                item.getMiningSpeedMultiplier(DGU.stackFor(item), block) // value
+        ));
+        blockDesc.add("effectiveTools", effTools);
+        blockDesc.addProperty("transparent", block instanceof TransparentBlock);
+        blockDesc.addProperty("emitLight", block.getLightLevel());
+        blockDesc.addProperty("filterLight", block.getOpacity());
+
+        JsonArray stateProperties = new JsonArray();
+        for (Property<?> property : block.getStateManager().getProperties()) {
+            stateProperties.add(generateStateProperty(property));
+        }
+        blockDesc.add("states", stateProperties);
+        blockDesc.add("drops", new JsonArray());
+        blockDesc.addProperty("boundingBox", boundingBox(block, defaultState));
+
+        return blockDesc;
+    }
+
+    private static String boundingBox(Block block, BlockState state) {
+        if (block.getCollisionBox(DGU.getWorld(), BlockPos.ORIGIN, state) == null) {
+            return "empty";
+        }
+        return "block";
+    }
+
+    private static Item getItemFromBlock(Block block) {
+        return Registries.ITEMS.get(Registries.BLOCKS.getIdentifier(block));
+    }
+
+    @Override
+    public String getDataName() {
+        return "blocks";
+    }
+
+    @Override
+    public JsonArray generateDataJson() {
+        JsonArray resultBlocksArray = new JsonArray();
+        for (Block block : Registries.BLOCKS) {
+            resultBlocksArray.add(generateBlock(block));
+        }
+        return resultBlocksArray;
+    }
+}
@@ -0,0 +1,80 @@
+package dev.u9g.minecraftdatagenerator.generators;
+
+import com.google.gson.JsonElement;
+import com.google.gson.internal.Streams;
+import com.google.gson.stream.JsonWriter;
+import dev.u9g.minecraftdatagenerator.Main;
+
+import java.io.IOException;
+import java.io.Writer;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardOpenOption;
+import java.text.MessageFormat;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+public class DataGenerators {
+
+    private static final List<IDataGenerator> GENERATORS = new ArrayList<>();
+    private static final Logger logger = Main.LOGGER;
+
+    static {
+        register(new BiomesDataGenerator());
+        register(new BlockCollisionShapesDataGenerator());
+        register(new BlocksDataGenerator());
+        register(new EffectsDataGenerator());
+        register(new EnchantmentsDataGenerator());
+        register(new EntitiesDataGenerator());
+        register(new FoodsDataGenerator());
+        register(new ItemsDataGenerator());
+        register(new ParticlesDataGenerator());
+        register(new TintsDataGenerator());
+        register(new LanguageDataGenerator());
+        register(new InstrumentsDataGenerator());
+        register(new AttributesDataGenerator());
+    }
+
+    public static void register(IDataGenerator generator) {
+        GENERATORS.add(generator);
+    }
+
+    public static boolean runDataGenerators(Path outputDirectory) {
+        try {
+            Files.createDirectories(outputDirectory);
+        } catch (IOException exception) {
+            logger.log(Level.INFO, "Failed to create data generator output directory at " + outputDirectory);
+            exception.printStackTrace();
+            return false;
+        }
+
+        int generatorsFailed = 0;
+        logger.log(Level.INFO, MessageFormat.format("Running minecraft data generators, output at {0}", outputDirectory));
+
+        for (IDataGenerator dataGenerator : GENERATORS) {
+            logger.log(Level.INFO, MessageFormat.format("Running generator {0}", dataGenerator.getDataName()));
+            try {
+                String outputFileName = String.format("%s.json", dataGenerator.getDataName());
+                JsonElement outputElement = dataGenerator.generateDataJson();
+                Path outputFilePath = outputDirectory.resolve(outputFileName);
+
+                try (Writer writer = Files.newBufferedWriter(outputFilePath, StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING)) {
+                    JsonWriter jsonWriter = new JsonWriter(writer);
+                    jsonWriter.setIndent("  ");
+                    Streams.write(outputElement, jsonWriter);
+                }
+                logger.log(Level.INFO, MessageFormat.format("Generator: {0} -> {1}", dataGenerator.getDataName(), outputFileName));
+
+            } catch (Throwable exception) {
+                logger.log(Level.INFO, MessageFormat.format("Failed to run data generator {0}", dataGenerator.getDataName()));
+                exception.printStackTrace();
+                generatorsFailed++;
+            }
+        }
+
+        logger.log(Level.INFO, "Finishing running data generators");
+        return generatorsFailed == 0;
+    }
+}
@@ -0,0 +1,44 @@
+package dev.u9g.minecraftdatagenerator.generators;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+import dev.u9g.minecraftdatagenerator.mixin.StatusEffectAccessor;
+import dev.u9g.minecraftdatagenerator.util.DGU;
+import dev.u9g.minecraftdatagenerator.util.Registries;
+import net.minecraft.entity.effect.StatusEffect;
+import net.minecraft.util.Identifier;
+import org.apache.commons.lang3.StringUtils;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Arrays;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+public class EffectsDataGenerator implements IDataGenerator {
+
+    public static JsonObject generateEffect(StatusEffect statusEffect) {
+        JsonObject effectDesc = new JsonObject();
+        @NotNull Identifier registryKey = Objects.requireNonNull(Registries.STATUS_EFFECTS.getIdentifier(statusEffect));
+
+        effectDesc.addProperty("id", Registries.STATUS_EFFECTS.getRawId(statusEffect));
+        effectDesc.addProperty("name", Arrays.stream(registryKey.getPath().split("_")).map(StringUtils::capitalize).collect(Collectors.joining()));
+        effectDesc.addProperty("displayName", DGU.translateText(statusEffect.getTranslationKey()));
+
+        effectDesc.addProperty("type", !((StatusEffectAccessor) statusEffect).negative() ? "good" : "bad");
+        return effectDesc;
+    }
+
+    @Override
+    public String getDataName() {
+        return "effects";
+    }
+
+    @Override
+    public JsonArray generateDataJson() {
+        JsonArray resultsArray = new JsonArray();
+        for (StatusEffect effect : Registries.STATUS_EFFECTS) {
+            resultsArray.add(generateEffect(effect));
+        }
+        return resultsArray;
+    }
+}
@@ -0,0 +1,108 @@
+package dev.u9g.minecraftdatagenerator.generators;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonPrimitive;
+import dev.u9g.minecraftdatagenerator.util.DGU;
+import dev.u9g.minecraftdatagenerator.util.Registries;
+import net.minecraft.enchantment.Enchantment;
+import net.minecraft.enchantment.EnchantmentTarget;
+import net.minecraft.util.Identifier;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+import java.util.Objects;
+
+public class EnchantmentsDataGenerator implements IDataGenerator {
+
+    private static final ImmutableMap<EnchantmentTarget, String> ENCHANTMENT_TARGET_NAMES = ImmutableMap.<EnchantmentTarget, String>builder()
+            .put(EnchantmentTarget.ALL_ARMOR, "armor")
+            .put(EnchantmentTarget.FEET, "armor_feet")
+            .put(EnchantmentTarget.LEGS, "armor_legs")
+            .put(EnchantmentTarget.TORSO, "armor_chest")
+            .put(EnchantmentTarget.HEAD, "armor_head")
+            .put(EnchantmentTarget.WEAPON, "weapon")
+            .put(EnchantmentTarget.DIGGER, "digger")
+            .put(EnchantmentTarget.FISHING_ROD, "fishing_rod")
+            .put(EnchantmentTarget.BREAKABLE, "breakable")
+            .put(EnchantmentTarget.BOW, "bow")
+            .build();
+
+    public static String getEnchantmentTargetName(EnchantmentTarget target) {
+        return ENCHANTMENT_TARGET_NAMES.getOrDefault(target, target.name().toLowerCase(Locale.ROOT));
+    }
+
+    // Equation enchantment costs follow is a * level + b, so we can easily retrieve a and b by passing zero level
+    private static JsonObject generateEnchantmentMinPowerCoefficients(Enchantment enchantment) {
+        int b = enchantment.getMinimumPower(0);
+        int a = enchantment.getMinimumPower(1) - b;
+
+        JsonObject resultObject = new JsonObject();
+        resultObject.addProperty("a", a);
+        resultObject.addProperty("b", b);
+        return resultObject;
+    }
+
+    private static JsonObject generateEnchantmentMaxPowerCoefficients(Enchantment enchantment) {
+        int b = enchantment.getMaximumPower(0);
+        int a = enchantment.getMaximumPower(1) - b;
+
+        JsonObject resultObject = new JsonObject();
+        resultObject.addProperty("a", a);
+        resultObject.addProperty("b", b);
+        return resultObject;
+    }
+
+    public static JsonObject generateEnchantment(Enchantment enchantment) {
+        JsonObject enchantmentDesc = new JsonObject();
+        Identifier registryKey = Registries.ENCHANTMENTS.getIdentifier(enchantment);
+
+        enchantmentDesc.addProperty("id", Registries.ENCHANTMENTS.getRawId(enchantment));
+        enchantmentDesc.addProperty("name", Objects.requireNonNull(registryKey).getPath());
+        enchantmentDesc.addProperty("displayName", DGU.translateText(enchantment.getTranslationKey()));
+
+        enchantmentDesc.addProperty("maxLevel", enchantment.getMaximumLevel());
+        enchantmentDesc.add("minCost", generateEnchantmentMinPowerCoefficients(enchantment));
+        enchantmentDesc.add("maxCost", generateEnchantmentMaxPowerCoefficients(enchantment));
+
+        enchantmentDesc.addProperty("treasureOnly", false); // 1.9 added treasure enchants
+        enchantmentDesc.addProperty("curse", false); // 1.10 added curse enchants
+
+        List<Enchantment> incompatibleEnchantments = new ArrayList<>();
+        for (Enchantment other : Registries.ENCHANTMENTS) {
+            if (!enchantment.differs(other) && !other.differs(enchantment) && other != enchantment) {
+                incompatibleEnchantments.add(other);
+            }
+        }
+
+        JsonArray excludes = new JsonArray();
+        for (Enchantment excludedEnchantment : incompatibleEnchantments) {
+            Identifier otherKey = Registries.ENCHANTMENTS.getIdentifier(excludedEnchantment);
+            excludes.add(new JsonPrimitive(Objects.requireNonNull(otherKey).getPath()));
+        }
+        enchantmentDesc.add("exclude", excludes);
+
+        enchantmentDesc.addProperty("category", getEnchantmentTargetName(enchantment.target));
+        enchantmentDesc.addProperty("weight", enchantment.getEnchantmentType()); // see AnvilScreenhandler L209
+        enchantmentDesc.addProperty("tradeable", true); // the first non-tradeable enchant came in 1.16, soul speed
+        enchantmentDesc.addProperty("discoverable", true); // the first non-enchantable enchant came in 1.16, soul speed
+
+        return enchantmentDesc;
+    }
+
+    @Override
+    public String getDataName() {
+        return "enchantments";
+    }
+
+    @Override
+    public JsonArray generateDataJson() {
+        JsonArray resultsArray = new JsonArray();
+        for (Enchantment enchantment : Registries.ENCHANTMENTS) {
+            resultsArray.add(generateEnchantment(enchantment));
+        }
+        return resultsArray;
+    }
+}
@@ -0,0 +1,138 @@
+package dev.u9g.minecraftdatagenerator.generators;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+import dev.u9g.minecraftdatagenerator.mixin.EntityTypeAccessor;
+import dev.u9g.minecraftdatagenerator.util.DGU;
+import dev.u9g.minecraftdatagenerator.util.Registries;
+import net.minecraft.entity.*;
+import net.minecraft.entity.mob.AmbientEntity;
+import net.minecraft.entity.mob.HostileEntity;
+import net.minecraft.entity.mob.MobEntity;
+import net.minecraft.entity.mob.WaterCreatureEntity;
+import net.minecraft.entity.passive.AnimalEntity;
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.entity.projectile.FishingBobberEntity;
+import net.minecraft.entity.projectile.Projectile;
+import net.minecraft.util.Identifier;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Objects;
+
+public class EntitiesDataGenerator implements IDataGenerator {
+
+    public static JsonObject generateEntity(Class<? extends Entity> entityClass) {
+        JsonObject entityDesc = new JsonObject();
+        Identifier registryKey = Registries.ENTITY_TYPES.getIdentifier(entityClass);
+        int entityRawId = Registries.ENTITY_TYPES.getRawId(entityClass);
+        @Nullable Entity entity = makeEntity(entityClass);
+        // FIXME: ENTITY ID IS WRONG
+        int id = entityId(entity);
+        entityDesc.addProperty("id", id);
+        entityDesc.addProperty("internalId", id);
+        entityDesc.addProperty("name", Objects.requireNonNull(registryKey).getPath());
+        String displayName = entity != null ? entity.getTranslationKey() : null;
+        if (displayName != null && !displayName.startsWith("entity.")) {
+            entityDesc.addProperty("displayName", displayName);
+        }
+        entityDesc.addProperty("width", entity == null ? 0 : entity.width);
+        entityDesc.addProperty("height", entity == null ? 0 : entity.height);
+
+        String entityTypeString = "UNKNOWN";
+        entityTypeString = getEntityTypeForClass(entityClass);
+        entityDesc.addProperty("type", entityTypeString);
+        entityDesc.addProperty("category", getCategoryFrom(entityClass));
+
+        return entityDesc;
+    }
+
+    private static Entity makeEntity(Class<? extends Entity> type) {
+        String name = EntityTypeAccessor.CLASS_NAME_MAP().get(type);
+        return EntityType.createInstanceFromName(name, DGU.getWorld());
+    }
+
+    private static String getCategoryFrom(@NotNull Class<?> entityClass) {
+        if (entityClass == PlayerEntity.class) return "other"; // fail early for player entities
+        String packageName = entityClass.getPackage().getName();
+        String category = switch (packageName) {
+            case "net.minecraft.entity.decoration", "net.minecraft.entity.decoration.painting" -> "Immobile";
+            case "net.minecraft.entity.boss", "net.minecraft.entity.mob", "net.minecraft.entity.boss.dragon" ->
+                    "Hostile mobs";
+            case "net.minecraft.entity.projectile", "net.minecraft.entity.thrown" -> "Projectiles";
+            case "net.minecraft.entity.passive" -> "Passive mobs";
+            case "net.minecraft.entity.vehicle" -> "Vehicles";
+            case "net.minecraft.entity" -> "other";
+            default -> throw new Error("Unexpected entity type: " + packageName);
+        };
+        return category;
+    }
+
+    //Honestly, both "type" and "category" fields in the schema and examples do not contain any useful information
+    //Since category is optional, I will just leave it out, and for type I will assume general entity classification
+    //by the Entity class hierarchy (which has some weirdness too by the way)
+    private static String getEntityTypeForClass(Class<? extends Entity> entityClass) {
+        //Top-level classifications
+        if (WaterCreatureEntity.class.isAssignableFrom(entityClass)) {
+            return "water_creature";
+        }
+        if (AnimalEntity.class.isAssignableFrom(entityClass)) {
+            return "animal";
+        }
+        if (HostileEntity.class.isAssignableFrom(entityClass)) {
+            return "hostile";
+        }
+        if (AmbientEntity.class.isAssignableFrom(entityClass)) {
+            return "ambient";
+        }
+
+        //Second level classifications. PathAwareEntity is not included because it
+        //doesn't really make much sense to categorize by it
+        if (PathAwareEntity.class.isAssignableFrom(entityClass)) {
+            return "passive";
+        }
+        if (MobEntity.class.isAssignableFrom(entityClass)) {
+            return "mob";
+        }
+
+        //Other classifications only include living entities and projectiles. everything else is categorized as other
+        if (LivingEntity.class.isAssignableFrom(entityClass)) {
+            return "living";
+        }
+        if (Projectile.class.isAssignableFrom(entityClass)) {
+            return "projectile";
+        }
+        return "other";
+    }
+
+    private static int entityId(Entity entity) {
+        if (!DGU.getCurrentlyRunningServer().getVersion().equals("1.8.9")) {
+            throw new Error("These ids were gotten manually for 1.8.9, remake for " + DGU.getCurrentlyRunningServer().getVersion());
+        }
+        int rawId = Registries.ENTITY_TYPES.getRawId(entity.getClass());
+        if (rawId == -1) { // see TrackedEntityInstance
+            if (entity instanceof ItemEntity) {
+                return 2;
+            } else if (entity instanceof FishingBobberEntity) {
+                return 90;
+            } else {
+                throw new Error("unable to find rawId for entity: " + entity.getEntity().getClass().getName());
+            }
+        }
+        return rawId;
+    }
+
+    @Override
+    public String getDataName() {
+        return "entities";
+    }
+
+    @Override
+    public JsonArray generateDataJson() {
+        JsonArray resultArray = new JsonArray();
+        for (Class<? extends Entity> entityType : Registries.ENTITY_TYPES) {
+            resultArray.add(generateEntity(entityType));
+        }
+        return resultArray;
+    }
+}
@@ -0,0 +1,50 @@
+package dev.u9g.minecraftdatagenerator.generators;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+import dev.u9g.minecraftdatagenerator.util.DGU;
+import dev.u9g.minecraftdatagenerator.util.Registries;
+import net.minecraft.item.FoodItem;
+import net.minecraft.item.Item;
+import net.minecraft.util.Identifier;
+
+import java.util.Objects;
+
+public class FoodsDataGenerator implements IDataGenerator {
+
+    public static JsonObject generateFoodDescriptor(FoodItem foodItem) {
+        JsonObject foodDesc = new JsonObject();
+        Identifier registryKey = Registries.ITEMS.getIdentifier(foodItem);
+
+        foodDesc.addProperty("id", Registries.ITEMS.getRawId(foodItem));
+        foodDesc.addProperty("name", Objects.requireNonNull(registryKey).getPath());
+
+        foodDesc.addProperty("stackSize", foodItem.getMaxCount());
+        foodDesc.addProperty("displayName", foodItem.getDisplayName(DGU.stackFor(foodItem)));
+        float foodPoints = foodItem.getHungerPoints(DGU.stackFor(foodItem));
+        float saturationRatio = foodItem.getSaturation(DGU.stackFor(foodItem)) * 2.0F;
+        float saturation = foodPoints * saturationRatio;
+
+        foodDesc.addProperty("foodPoints", foodPoints);
+        foodDesc.addProperty("saturation", saturation);
+
+        foodDesc.addProperty("effectiveQuality", foodPoints + saturation);
+        foodDesc.addProperty("saturationRatio", saturationRatio);
+        return foodDesc;
+    }
+
+    @Override
+    public String getDataName() {
+        return "foods";
+    }
+
+    public JsonArray generateDataJson() {
+        JsonArray resultsArray = new JsonArray();
+        for (Item item : Registries.ITEMS) {
+            if (item instanceof FoodItem) {
+                resultsArray.add(generateFoodDescriptor((FoodItem) item));
+            }
+        }
+        return resultsArray;
+    }
+}
@@ -0,0 +1,10 @@
+package dev.u9g.minecraftdatagenerator.generators;
+
+import com.google.gson.JsonElement;
+
+public interface IDataGenerator {
+
+    String getDataName();
+
+    JsonElement generateDataJson();
+}
@@ -0,0 +1,28 @@
+package dev.u9g.minecraftdatagenerator.generators;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import dev.u9g.minecraftdatagenerator.mixin.NoteBlockAccessor;
+
+import java.util.Objects;
+
+public class InstrumentsDataGenerator implements IDataGenerator {
+    @Override
+    public String getDataName() {
+        return "instruments";
+    }
+
+    @Override
+    public JsonElement generateDataJson() {
+        JsonArray array = new JsonArray();
+        int i = 0;
+        for (String soundName : Objects.requireNonNull(NoteBlockAccessor.TUNES())) {
+            JsonObject object = new JsonObject();
+            object.addProperty("id", i++);
+            object.addProperty("name", soundName);
+            array.add(object);
+        }
+        return array;
+    }
+}
@@ -0,0 +1,90 @@
+package dev.u9g.minecraftdatagenerator.generators;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonPrimitive;
+import dev.u9g.minecraftdatagenerator.util.DGU;
+import dev.u9g.minecraftdatagenerator.util.Registries;
+import net.minecraft.enchantment.EnchantmentTarget;
+import net.minecraft.item.Item;
+import net.minecraft.util.Identifier;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+public class ItemsDataGenerator implements IDataGenerator {
+
+    private static List<Item> calculateItemsToRepairWith(Item sourceItem) {
+        List<Item> items = new ArrayList<>();
+        for (Item otherItem : Registries.ITEMS) {
+            if (sourceItem.canRepair(DGU.stackFor(sourceItem), DGU.stackFor(otherItem))) {
+                items.add(otherItem);
+            }
+        }
+        return items;
+    }
+
+    private static List<EnchantmentTarget> getApplicableEnchantmentTargets(Item sourceItem) {
+        List<EnchantmentTarget> targets = new ArrayList<>();
+        for (EnchantmentTarget target : EnchantmentTarget.values()) {
+            if (!target.isCompatible(sourceItem)) continue;
+            targets.add(target);
+        }
+        return targets;
+    }
+
+    public static JsonObject generateItem(Item item) {
+        JsonObject itemDesc = new JsonObject();
+        Identifier registryKey = Registries.ITEMS.getIdentifier(item);
+
+        itemDesc.addProperty("id", Registries.ITEMS.getRawId(item));
+        itemDesc.addProperty("name", Objects.requireNonNull(registryKey).getPath());
+
+        itemDesc.addProperty("displayName", item.getDisplayName(DGU.stackFor(item)));
+        itemDesc.addProperty("stackSize", item.getMaxCount());
+
+        List<EnchantmentTarget> enchantmentTargets = getApplicableEnchantmentTargets(item);
+
+        if (item.isDamageable()) {
+            JsonArray enchantCategoriesArray = new JsonArray();
+            for (EnchantmentTarget target : enchantmentTargets) {
+                enchantCategoriesArray.add(new JsonPrimitive(EnchantmentsDataGenerator.getEnchantmentTargetName(target)));
+            }
+            if (enchantCategoriesArray.size() > 0) {
+                itemDesc.add("enchantCategories", enchantCategoriesArray);
+            }
+        }
+
+        if (item.isDamageable()) {
+            List<Item> repairWithItems = calculateItemsToRepairWith(item);
+
+            JsonArray fixedWithArray = new JsonArray();
+            for (Item repairWithItem : repairWithItems) {
+                Identifier repairWithName = Registries.ITEMS.getIdentifier(repairWithItem);
+                fixedWithArray.add(new JsonPrimitive(Objects.requireNonNull(repairWithName).getPath()));
+            }
+            if (fixedWithArray.size() > 0) {
+                itemDesc.add("repairWith", fixedWithArray);
+            }
+
+            int maxDurability = item.getMaxDamage();
+            itemDesc.addProperty("maxDurability", maxDurability);
+        }
+        return itemDesc;
+    }
+
+    @Override
+    public String getDataName() {
+        return "items";
+    }
+
+    @Override
+    public JsonArray generateDataJson() {
+        JsonArray resultArray = new JsonArray();
+        for (Item item : Registries.ITEMS) {
+            resultArray.add(generateItem(item));
+        }
+        return resultArray;
+    }
+}
@@ -0,0 +1,29 @@
+package dev.u9g.minecraftdatagenerator.generators;
+
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import dev.u9g.minecraftdatagenerator.mixin.LanguageAccessor;
+import dev.u9g.minecraftdatagenerator.util.Registries;
+
+import java.util.Map;
+
+public class LanguageDataGenerator implements IDataGenerator {
+    @Override
+    public String getDataName() {
+        return "language";
+    }
+
+    @Override
+    public JsonElement generateDataJson() {
+        try {
+            JsonObject obj = new JsonObject();
+            Map<String, String> translations = ((LanguageAccessor) Registries.LANGUAGE).translations();
+            for (Map.Entry<String, String> entry : translations.entrySet()) {
+                obj.addProperty(entry.getKey(), entry.getValue());
+            }
+            return obj;
+        } catch (Exception ignored) {
+        }
+        throw new RuntimeException("Failed to generate language file");
+    }
+}
@@ -0,0 +1,31 @@
+package dev.u9g.minecraftdatagenerator.generators;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+import net.minecraft.client.particle.ParticleType;
+
+public class ParticlesDataGenerator implements IDataGenerator {
+
+    public static JsonObject generateParticleType(int id, ParticleType particleType) {
+        JsonObject effectDesc = new JsonObject();
+
+        effectDesc.addProperty("id", id);
+        effectDesc.addProperty("name", particleType.getName());
+        return effectDesc;
+    }
+
+    @Override
+    public String getDataName() {
+        return "particles";
+    }
+
+    @Override
+    public JsonArray generateDataJson() {
+        JsonArray resultsArray = new JsonArray();
+        int i = 0;
+        for (ParticleType particleType : ParticleType.values()) {
+            resultsArray.add(generateParticleType(i++, particleType));
+        }
+        return resultsArray;
+    }
+}
@@ -0,0 +1,119 @@
+package dev.u9g.minecraftdatagenerator.generators;
+
+import com.google.gson.JsonElement;
+import com.google.gson.JsonNull;
+
+public class RecipeDataGenerator implements IDataGenerator {
+
+    @Override
+    public String getDataName() {
+        return "recipes";
+    }
+
+    @Override
+    public JsonElement generateDataJson() {
+//        JsonObject finalObj = new JsonObject();
+//        Multimap<Integer, JsonObject> recipes = ArrayListMultimap.create();
+//        for (Recipe<?> recipe : Objects.requireNonNull(DGU.getWorld()).getRecipeManager().values()) {
+//            if (recipe instanceof ShapedRecipe sr) {
+//                var ingredients = sr.getIngredients();
+//                List<Integer> ingr = new ArrayList<>();
+//                for (int i = 0; i < 9; i++) {
+//                    if (i >= ingredients.size()) {
+//                        ingr.add(-1);
+//                        continue;
+//                    }
+//                    var stacks = ingredients.get(i);
+////                    var matching = stacks.getMatchingStacks();
+////                    if (matching.length == 0) {
+////                        ingr.add(-1);
+////                    } else {
+////                        ingr.add(getRawIdFor(matching[0].getItem()));
+////                    }
+//                }
+//                Lists.reverse(ingr);
+//
+//                JsonArray inShape = new JsonArray();
+//
+//                var iter = ingr.iterator();
+//                for (int y = 0; y < 3; y++) {
+//                    var jsonRow = new JsonArray();
+//                    int one = iter.next();
+//                    int two = iter.next();
+//                    int three = iter.next();
+//                    if (y > 0 && one == -1 && two == -1 && three == -1) continue;
+//                    jsonRow.add(one);
+//                    jsonRow.add(two);
+//                    jsonRow.add(three);
+//                    inShape.add(jsonRow);
+//                }
+//
+//                JsonObject finalRecipe = new JsonObject();
+//                finalRecipe.add("inShape", inShape);
+//
+//                var resultObject = new JsonObject();
+//                resultObject.addProperty("id", getRawIdFor(sr.getOutput().getItem()));
+//                resultObject.addProperty("count", sr.getOutput().getCount());
+//                finalRecipe.add("result", resultObject);
+//
+//                String id = ((Integer) getRawIdFor(sr.getOutput().getItem())).toString();
+//
+//                if (!finalObj.has(id)) {
+//                    finalObj.add(id, new JsonArray());
+//                }
+//                finalObj.get(id).getAsJsonArray().add(finalRecipe);
+////                var input = new JsonArray();
+////                var ingredients = sr.getIngredients().stream().toList();
+////                for (int y = 0; y < sr.getHeight(); y++) {
+////                    var arr = new JsonArray();
+////                    for (int x = 0; x < sr.getWidth(); x++) {
+////                        if ((y*3)+x >= ingredients.size()) {
+////                            arr.add(JsonNull.INSTANCE);
+////                            continue;
+////                        }
+////                        var ingredient = ingredients.get((y*3)+x).getMatchingStacks(); // FIXME: fix when there are more than one matching stack
+////                        if (ingredient.length == 0) {
+////                            arr.add(JsonNull.INSTANCE);
+////                        } else {
+////                            arr.add(getRawIdFor(ingredient[0].getItem()));
+////                        }
+////                    }
+////                    input.add(arr);
+////                }
+////                var rootRecipeObject = new JsonObject();
+////                rootRecipeObject.add("inShape", input);
+////                var resultObject = new JsonObject();
+////                resultObject.addProperty("id", getRawIdFor(sr.getOutput().getItem()));
+////                resultObject.addProperty("count", sr.getOutput().getCount());
+////                rootRecipeObject.add("result", resultObject);
+////                recipes.put(getRawIdFor(sr.getOutput().getItem()), rootRecipeObject);
+//            } else if (recipe instanceof ShapelessRecipe sl) {
+
+//                var ingredients = new JsonArray();
+//                for (Ingredient ingredient : sl.getIngredients()) {
+//                    if (ingredient.isEmpty()) continue;
+////                    ingredients.add(getRawIdFor(ingredient.getMatchingStacks()[0].getItem()));
+//                }
+//                var rootRecipeObject = new JsonObject();
+//                rootRecipeObject.add("ingredients", ingredients);
+//                var resultObject = new JsonObject();
+//                resultObject.addProperty("id", getRawIdFor(sl.getOutput().getItem()));
+//                resultObject.addProperty("count", sl.getOutput().getCount());
+//                rootRecipeObject.add("result", resultObject);
+//                recipes.put(getRawIdFor(sl.getOutput().getItem()), rootRecipeObject);
+//            }
+//        }
+//        recipes.forEach((a, b) -> {
+//            if (!finalObj.has(a.toString())) {
+//                finalObj.add(a.toString(), new JsonArray());
+//            }
+//            finalObj.get(a.toString()).getAsJsonArray().add(b);
+//        });
+//        return finalObj;
+        return JsonNull.INSTANCE;
+    }
+//
+//    private static int getRawIdFor (Item item) {
+//        return Registry.ITEM.getRawId(item);
+//    }
+}
@@ -0,0 +1,161 @@
+package dev.u9g.minecraftdatagenerator.generators;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonPrimitive;
+import dev.u9g.minecraftdatagenerator.ClientSideAnnoyances.BiomeBlockColors;
+import dev.u9g.minecraftdatagenerator.ClientSideAnnoyances.FoliageColors;
+import dev.u9g.minecraftdatagenerator.ClientSideAnnoyances.GrassColors;
+import dev.u9g.minecraftdatagenerator.ClientSideAnnoyances.ServerSideRedstoneWireBlock;
+import dev.u9g.minecraftdatagenerator.mixin.BiomeAccessor;
+import dev.u9g.minecraftdatagenerator.util.EmptyBlockView;
+import dev.u9g.minecraftdatagenerator.util.Registries;
+import net.minecraft.block.Block;
+import net.minecraft.block.Blocks;
+import net.minecraft.block.RedstoneWireBlock;
+import net.minecraft.util.Identifier;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.biome.Biome;
+
+import java.util.*;
+
+public class TintsDataGenerator implements IDataGenerator {
+
+    public static BiomeTintColors generateBiomeTintColors() {
+        BiomeTintColors colors = new BiomeTintColors();
+
+        for (Biome biome : Registries.BIOMES) {
+            EmptyBlockView bv = new EmptyBlockView() {
+                @Override
+                public Biome getBiome(BlockPos pos) {
+                    return biome;
+                }
+            };
+            int biomeGrassColor = GrassColors.getGrassColor(bv.getBiome(BlockPos.ORIGIN));
+            int biomeFoliageColor = FoliageColors.getFoliageColor(bv.getBiome(BlockPos.ORIGIN));
+            int biomeWaterColor = ((BiomeAccessor) biome).waterColor();
+
+            colors.grassColoursMap.computeIfAbsent(biomeGrassColor, k -> new ArrayList<>()).add(biome);
+            colors.foliageColoursMap.computeIfAbsent(biomeFoliageColor, k -> new ArrayList<>()).add(biome);
+            colors.waterColourMap.computeIfAbsent(biomeWaterColor, k -> new ArrayList<>()).add(biome);
+        }
+        return colors;
+    }
+
+    public static Map<Integer, Integer> generateRedstoneTintColors() {
+        Map<Integer, Integer> resultColors = new HashMap<>();
+
+        for (int redstoneLevel : RedstoneWireBlock.POWER.getValues()) {
+            int color = ServerSideRedstoneWireBlock.getWireColor(redstoneLevel);
+            resultColors.put(redstoneLevel, color);
+        }
+        return resultColors;
+    }
+
+    private static int getBlockColor(Block block) {
+        return BiomeBlockColors.getBlockColor(block, block.getDefaultState());
+    }
+
+    public static Map<Block, Integer> generateConstantTintColors() {
+        Map<Block, Integer> resultColors = new HashMap<>();
+        // FIXME: ?
+        // resultColors.put(Blocks.BIRCH_LEAVES, FoliageColors.getBirchColor());
+        // resultColors.put(Blocks.SPRUCE_LEAVES, FoliageColors.getSpruceColor());
+
+        resultColors.put(Blocks.LILY_PAD, getBlockColor(Blocks.LILY_PAD));
+        // FIXME: ?
+        // resultColors.put(Blocks.ATTACHED_MELON_STEM, getBlockColor(Blocks.ATTACHED_MELON_STEM, blockColors));
+        // resultColors.put(Blocks.ATTACHED_PUMPKIN_STEM, getBlockColor(Blocks.ATTACHED_PUMPKIN_STEM, blockColors));
+
+        //not really constant, depend on the block age, but kinda have to be handled since textures are literally white without them
+        resultColors.put(Blocks.MELON_STEM, getBlockColor(Blocks.MELON_STEM));
+        resultColors.put(Blocks.PUMPKIN_STEM, getBlockColor(Blocks.PUMPKIN_STEM));
+
+        return resultColors;
+    }
+
+    private static JsonObject encodeBiomeColorMap(Map<Integer, List<Biome>> colorsMap) {
+        JsonArray resultColorsArray = new JsonArray();
+        for (Map.Entry<Integer, List<Biome>> entry : colorsMap.entrySet()) {
+            JsonObject entryObject = new JsonObject();
+
+            JsonArray keysArray = new JsonArray();
+            for (Biome biome : entry.getValue()) {
+                keysArray.add(new JsonPrimitive(biome.name));
+            }
+
+            entryObject.add("keys", keysArray);
+            entryObject.addProperty("color", entry.getKey());
+            resultColorsArray.add(entryObject);
+        }
+
+        JsonObject resultObject = new JsonObject();
+        resultObject.add("data", resultColorsArray);
+        return resultObject;
+    }
+
+    private static JsonObject encodeRedstoneColorMap(Map<Integer, Integer> colorsMap) {
+        JsonArray resultColorsArray = new JsonArray();
+        for (Map.Entry<Integer, Integer> entry : colorsMap.entrySet()) {
+            JsonObject entryObject = new JsonObject();
+
+            JsonArray keysArray = new JsonArray();
+            keysArray.add(new JsonPrimitive(entry.getKey()));
+
+            entryObject.add("keys", keysArray);
+            entryObject.addProperty("color", entry.getValue());
+            resultColorsArray.add(entryObject);
+        }
+
+        JsonObject resultObject = new JsonObject();
+        resultObject.add("data", resultColorsArray);
+        return resultObject;
+    }
+
+    private static JsonObject encodeBlocksColorMap(Map<Block, Integer> colorsMap) {
+        JsonArray resultColorsArray = new JsonArray();
+        for (Map.Entry<Block, Integer> entry : colorsMap.entrySet()) {
+            JsonObject entryObject = new JsonObject();
+            JsonArray keysArray = new JsonArray();
+            Identifier registryKey = Registries.BLOCKS.getIdentifier(entry.getKey());
+            keysArray.add(new JsonPrimitive(Objects.requireNonNull(registryKey).getPath()));
+
+            entryObject.add("keys", keysArray);
+            entryObject.addProperty("color", entry.getValue());
+            resultColorsArray.add(entryObject);
+        }
+
+        JsonObject resultObject = new JsonObject();
+        resultObject.add("data", resultColorsArray);
+        return resultObject;
+    }
+
+    @Override
+    public String getDataName() {
+        return "tints";
+    }
+
+    @Override
+    public JsonObject generateDataJson() {
+        BiomeTintColors biomeTintColors = generateBiomeTintColors();
+        Map<Integer, Integer> redstoneColors = generateRedstoneTintColors();
+        Map<Block, Integer> constantTintColors = generateConstantTintColors();
+
+        JsonObject resultObject = new JsonObject();
+
+        resultObject.add("grass", encodeBiomeColorMap(biomeTintColors.grassColoursMap));
+        resultObject.add("foliage", encodeBiomeColorMap(biomeTintColors.foliageColoursMap));
+        resultObject.add("water", encodeBiomeColorMap(biomeTintColors.waterColourMap));
+
+        resultObject.add("redstone", encodeRedstoneColorMap(redstoneColors));
+        resultObject.add("constant", encodeBlocksColorMap(constantTintColors));
+
+        return resultObject;
+    }
+
+    public static class BiomeTintColors {
+        final Map<Integer, List<Biome>> grassColoursMap = new HashMap<>();
+        final Map<Integer, List<Biome>> foliageColoursMap = new HashMap<>();
+        final Map<Integer, List<Biome>> waterColourMap = new HashMap<>();
+    }
+}
@@ -0,0 +1,21 @@
+package dev.u9g.minecraftdatagenerator.mixin;
+
+import net.minecraft.world.biome.Biome;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+
+import java.util.Set;
+
+@Mixin(Biome.class)
+public interface BiomeAccessor {
+    @Accessor("BIOMESET")
+    static Set<Biome> BIOMESET() {
+        throw new Error();
+    }
+
+    @Accessor("waterColor")
+    int waterColor();
+
+    @Accessor("name")
+    String name();
+}
@@ -0,0 +1,11 @@
+package dev.u9g.minecraftdatagenerator.mixin;
+
+import net.minecraft.block.Block;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+
+@Mixin(Block.class)
+public interface BlockAccessor {
+    @Accessor("blastResistance")
+    float getBlastResistance();
+}
@@ -0,0 +1,15 @@
+package dev.u9g.minecraftdatagenerator.mixin;
+
+import net.minecraft.server.dedicated.EulaReader;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+@Mixin(EulaReader.class)
+public class EULAMixin {
+    @Inject(method = "isEulaAgreedTo()Z", at = @At("TAIL"), cancellable = true)
+    public void init(CallbackInfoReturnable<Boolean> cir) {
+        cir.setReturnValue(true);
+    }
+}
@@ -0,0 +1,16 @@
+package dev.u9g.minecraftdatagenerator.mixin;
+
+import net.minecraft.enchantment.Enchantment;
+import net.minecraft.util.Identifier;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+
+import java.util.Map;
+
+@Mixin(Enchantment.class)
+public interface EnchantmentAccessor {
+    @Accessor("ENCHANTMENT_MAP")
+    static Map<Identifier, Enchantment> ENCHANTMENT_MAP() {
+        throw new Error();
+    }
+}
@@ -0,0 +1,36 @@
+package dev.u9g.minecraftdatagenerator.mixin;
+
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityType;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+
+import java.util.Map;
+
+@Mixin(EntityType.class)
+public interface EntityTypeAccessor {
+    @Accessor("NAME_CLASS_MAP")
+    static Map<String, Class<? extends Entity>> NAME_CLASS_MAP() {
+        throw new Error();
+    }
+
+    @Accessor("CLASS_NAME_MAP")
+    static Map<Class<? extends Entity>, String> CLASS_NAME_MAP() {
+        throw new Error();
+    }
+
+    @Accessor("ID_CLASS_MAP")
+    static Map<Integer, Class<? extends Entity>> ID_CLASS_MAP() {
+        throw new Error();
+    }
+
+    @Accessor("CLASS_ID_MAP")
+    static Map<Class<? extends Entity>, Integer> CLASS_ID_MAP() {
+        throw new Error();
+    }
+
+    @Accessor("NAME_ID_MAP")
+    static Map<String, Integer> NAME_ID_MAP() {
+        throw new Error();
+    }
+}
@@ -0,0 +1,13 @@
+package dev.u9g.minecraftdatagenerator.mixin;
+
+import net.minecraft.util.Language;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+
+import java.util.Map;
+
+@Mixin(Language.class)
+public interface LanguageAccessor {
+    @Accessor("translations")
+    Map<String, String> translations();
+}
@@ -0,0 +1,15 @@
+package dev.u9g.minecraftdatagenerator.mixin;
+
+import net.minecraft.block.Block;
+import net.minecraft.item.ToolItem;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+
+import java.util.Set;
+
+@Mixin(ToolItem.class)
+public interface MiningToolItemAccessor {
+
+    @Accessor
+    Set<Block> getEffectiveBlocks();
+}
@@ -0,0 +1,15 @@
+package dev.u9g.minecraftdatagenerator.mixin;
+
+import net.minecraft.block.NoteBlock;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+
+import java.util.List;
+
+@Mixin(NoteBlock.class)
+public interface NoteBlockAccessor {
+    @Accessor("TUNES")
+    static List<String> TUNES() {
+        return null;
+    }
+}
@@ -0,0 +1,27 @@
+package dev.u9g.minecraftdatagenerator.mixin;
+
+import dev.u9g.minecraftdatagenerator.Main;
+import dev.u9g.minecraftdatagenerator.generators.DataGenerators;
+import dev.u9g.minecraftdatagenerator.util.DGU;
+import net.minecraft.server.dedicated.MinecraftDedicatedServer;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+import java.nio.file.Path;
+import java.util.logging.Level;
+
+@Mixin(MinecraftDedicatedServer.class)
+public class ReadyMixin {
+    @Inject(method = "setupServer()Z", at = @At("TAIL"))
+    private void init(CallbackInfoReturnable<Boolean> cir) {
+        Main.LOGGER.log(Level.INFO, "Starting data generation!");
+        String versionName = DGU.getCurrentlyRunningServer().getVersion();
+        Path serverRootDirectory = DGU.getCurrentlyRunningServer().getRunDirectory().toPath().toAbsolutePath();
+        Path dataDumpDirectory = serverRootDirectory.resolve("minecraft-data").resolve(versionName);
+        DataGenerators.runDataGenerators(dataDumpDirectory);
+        Main.LOGGER.log(Level.INFO, "Done data generation!");
+        System.exit(0);
+    }
+}
@@ -0,0 +1,19 @@
+package dev.u9g.minecraftdatagenerator.mixin;
+
+import net.minecraft.entity.effect.StatusEffect;
+import net.minecraft.util.Identifier;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+
+import java.util.Map;
+
+@Mixin(StatusEffect.class)
+public interface StatusEffectAccessor {
+    @Accessor("STATUS_EFFECTS_BY_ID")
+    static Map<Identifier, StatusEffect> STATUS_EFFECTS_BY_ID() {
+        throw new Error();
+    }
+
+    @Accessor("negative")
+    boolean negative();
+}
@@ -0,0 +1,41 @@
+package dev.u9g.minecraftdatagenerator.mixin.overwrite;
+
+import net.minecraft.block.BlockState;
+import net.minecraft.block.CocoaBlock;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Box;
+import net.minecraft.util.math.Direction;
+import net.minecraft.world.World;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Overwrite;
+
+@Mixin(CocoaBlock.class)
+public class CocoaBlockOverwrite {
+    private static Box collisionBox(BlockState state) {
+        Direction direction = state.get(CocoaBlock.FACING);
+        int i = state.get(CocoaBlock.AGE);
+        int j = 4 + i * 2;
+        int k = 5 + i * 2;
+        float f = (float) j / 2.0f;
+        return switch (direction) {
+            case SOUTH ->
+                    new Box((8.0f - f) / 16.0f, (12.0f - (float) k) / 16.0f, (15.0f - (float) j) / 16.0f, (8.0f + f) / 16.0f, 0.75f, 0.9375f);
+            case NORTH ->
+                    new Box((8.0f - f) / 16.0f, (12.0f - (float) k) / 16.0f, 0.0625f, (8.0f + f) / 16.0f, 0.75f, (1.0f + (float) j) / 16.0f);
+            case WEST ->
+                    new Box(0.0625f, (12.0f - (float) k) / 16.0f, (8.0f - f) / 16.0f, (1.0f + (float) j) / 16.0f, 0.75f, (8.0f + f) / 16.0f);
+            case EAST ->
+                    new Box((15.0f - (float) j) / 16.0f, (12.0f - (float) k) / 16.0f, (8.0f - f) / 16.0f, 0.9375f, 0.75f, (8.0f + f) / 16.0f);
+            default -> throw new Error("Should never hit here");
+        };
+    }
+
+    /**
+     * @author a
+     * @reason a
+     */
+    @Overwrite
+    public Box getCollisionBox(World world, BlockPos pos, BlockState state) {
+        return collisionBox(state);
+    }
+}
@@ -0,0 +1,34 @@
+package dev.u9g.minecraftdatagenerator.mixin.overwrite;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockState;
+import net.minecraft.block.EndPortalFrameBlock;
+import net.minecraft.block.Material;
+import net.minecraft.entity.Entity;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Box;
+import net.minecraft.world.World;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Overwrite;
+
+import java.util.List;
+
+@Mixin(EndPortalFrameBlock.class)
+public class EndPortalFrameBlockOverwrite extends Block {
+    protected EndPortalFrameBlockOverwrite(Material material) {
+        super(material);
+    }
+
+    /**
+     * @author a
+     * @reason a
+     */
+    @Overwrite()
+    public void appendCollisionBoxes(World world, BlockPos pos, BlockState state, Box box, List<Box> list, Entity entity) {
+        this.setBoundingBox(0.0F, 0.0F, 0.0F, 1.0F, 0.8125F, 1.0F);
+        super.appendCollisionBoxes(world, pos, state, box, list, entity);
+        this.setBoundingBox(0.3125F, 0.8125F, 0.3125F, 0.6875F, 1.0F, 0.6875F);
+        super.appendCollisionBoxes(world, pos, state, box, list, entity);
+        this.setBlockItemBounds();
+    }
+}
@@ -0,0 +1,24 @@
+package dev.u9g.minecraftdatagenerator.mixin.overwrite;
+
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.ItemEntity;
+import net.minecraft.world.World;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Overwrite;
+
+@Mixin(ItemEntity.class)
+public abstract class ItemEntityOverwrite extends Entity {
+
+    public ItemEntityOverwrite(World world) {
+        super(world);
+    }
+
+    /**
+     * @author a
+     * @reason a
+     */
+    @Overwrite
+    public String getTranslationKey() {
+        return super.getTranslationKey();
+    }
+}
@@ -0,0 +1,25 @@
+package dev.u9g.minecraftdatagenerator.mixin.overwrite;
+
+import net.minecraft.block.BlockState;
+import net.minecraft.block.SkeletonSkullBlock;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Box;
+import net.minecraft.world.World;
+import org.spongepowered.asm.mixin.Mixin;
+
+@Mixin(SkeletonSkullBlock.class)
+public class SkeletonSkullBlockOverwrite {
+    private static Box boundingBox(BlockState state) {
+        return switch (state.get(SkeletonSkullBlock.FACING)) {
+            default -> new Box(0.25f, 0.0f, 0.25f, 0.75f, 0.5f, 0.75f);
+            case NORTH -> new Box(0.25f, 0.25f, 0.5f, 0.75f, 0.75f, 1.0f);
+            case SOUTH -> new Box(0.25f, 0.25f, 0.0f, 0.75f, 0.75f, 0.5f);
+            case WEST -> new Box(0.5f, 0.25f, 0.25f, 1.0f, 0.75f, 0.75f);
+            case EAST -> new Box(0.0f, 0.25f, 0.25f, 0.5f, 0.75f, 0.75f);
+        };
+    }
+
+    public Box getCollisionBox(World world, BlockPos pos, BlockState state) {
+        return boundingBox(state);
+    }
+}
@@ -0,0 +1,150 @@
+package dev.u9g.minecraftdatagenerator.mixin.overwrite;
+
+import dev.u9g.minecraftdatagenerator.util.EmptyBlockView;
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockState;
+import net.minecraft.block.Material;
+import net.minecraft.block.StairsBlock;
+import net.minecraft.entity.Entity;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Box;
+import net.minecraft.util.math.Direction;
+import net.minecraft.world.BlockView;
+import net.minecraft.world.World;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Overwrite;
+import org.spongepowered.asm.mixin.Shadow;
+
+import java.util.List;
+
+import static net.minecraft.block.StairsBlock.HALF;
+
+@Mixin(StairsBlock.class)
+public abstract class StairBlockOverwrite extends Block {
+    protected StairBlockOverwrite(Material material) {
+        super(material);
+    }
+
+    @Shadow
+    public abstract void setBoundingBox(BlockView view, BlockPos pos);
+
+    @Shadow
+    public abstract boolean method_8911(BlockView blockView, BlockPos blockPos);
+
+    /**
+     * @author a
+     * @reason a
+     */
+    @Overwrite
+    public void appendCollisionBoxes(World world, BlockPos pos, BlockState state, Box box, List<Box> list, Entity entity) {
+        list.add(someFuncThatIRemade(state));
+        super.appendCollisionBoxes(world, pos, state, box, list, entity);
+        EmptyBlockView bv = new EmptyBlockView() {
+            @Override
+            public BlockState getBlockState(BlockPos pos) {
+                return state;
+            }
+        };
+        boolean bl = this.method_8911(bv, pos);
+        list.add(this.getCollisionBox(world, pos, state));
+        if (bl && calculateWhichTypeOfStairThisIsButDoesntWorkBecauseWeDontHaveAdjBlocks(state)) {
+            list.add(this.getCollisionBox(world, pos, state));
+        }
+        this.setBoundingBox(0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f);
+    }
+
+    public Box someFuncThatIRemade(BlockState state) {
+        if (state.get(HALF) == StairsBlock.Half.TOP) {
+            return new Box(0.0f, 0.5f, 0.0f, 1.0f, 1.0f, 1.0f);
+        } else {
+            return new Box(0.0f, 0.0f, 0.0f, 1.0f, 0.5f, 1.0f);
+        }
+    }
+
+    public boolean calculateWhichTypeOfStairThisIsButDoesntWorkBecauseWeDontHaveAdjBlocks(BlockState state) {
+        EmptyBlockView blockView = new EmptyBlockView() {
+            @Override
+            public BlockState getBlockState(BlockPos pos) {
+                return state;
+            }
+        };
+        BlockState blockState2;
+        Block block;
+        BlockState blockState = blockView.getBlockState(BlockPos.ORIGIN);
+        Direction direction = blockState.get(StairsBlock.FACING);
+        StairsBlock.Half half = blockState.get(HALF);
+        boolean bl = half == StairsBlock.Half.TOP;
+        float f = 0.5f;
+        float g = 1.0f;
+        if (bl) {
+            f = 0.0f;
+            g = 0.5f;
+        }
+        float h = 0.0f;
+        float i = 0.5f;
+        float j = 0.5f;
+        float k = 1.0f;
+        boolean bl2 = false;
+        if (direction == Direction.EAST) {
+            BlockState blockState22 = blockView.getBlockState(BlockPos.ORIGIN);
+            Block block2 = blockState22.getBlock();
+            if (StairsBlock.method_6513(block2) && half == blockState22.get(HALF)) {
+                Direction direction2 = blockState22.get(StairsBlock.FACING);
+                if (direction2 == Direction.NORTH && !StairsBlock.method_8907(blockView, BlockPos.ORIGIN, blockState)) {
+                    j = 0.0f;
+                    k = 0.5f;
+                    bl2 = true;
+                } else if (direction2 == Direction.SOUTH && !StairsBlock.method_8907(blockView, BlockPos.ORIGIN, blockState)) {
+                    j = 0.5f;
+                    k = 1.0f;
+                    bl2 = true;
+                }
+            }
+        } else if (direction == Direction.WEST) {
+            BlockState blockState23 = blockView.getBlockState(BlockPos.ORIGIN);
+            Block block3 = blockState23.getBlock();
+            if (StairsBlock.method_6513(block3) && half == blockState23.get(HALF)) {
+                h = 0.5f;
+                i = 1.0f;
+                Direction direction2 = blockState23.get(StairsBlock.FACING);
+                if (direction2 == Direction.NORTH && !StairsBlock.method_8907(blockView, BlockPos.ORIGIN, blockState)) {
+                    j = 0.0f;
+                    k = 0.5f;
+                    bl2 = true;
+                } else if (direction2 == Direction.SOUTH && !StairsBlock.method_8907(blockView, BlockPos.ORIGIN, blockState)) {
+                    j = 0.5f;
+                    k = 1.0f;
+                    bl2 = true;
+                }
+            }
+        } else if (direction == Direction.SOUTH) {
+            BlockState blockState24 = blockView.getBlockState(BlockPos.ORIGIN);
+            Block block4 = blockState24.getBlock();
+            if (StairsBlock.method_6513(block4) && half == blockState24.get(HALF)) {
+                j = 0.0f;
+                k = 0.5f;
+                Direction direction2 = blockState24.get(StairsBlock.FACING);
+                if (direction2 == Direction.WEST && !StairsBlock.method_8907(blockView, BlockPos.ORIGIN, blockState)) {
+                    bl2 = true;
+                } else if (direction2 == Direction.EAST && !StairsBlock.method_8907(blockView, BlockPos.ORIGIN, blockState)) {
+                    h = 0.5f;
+                    i = 1.0f;
+                    bl2 = true;
+                }
+            }
+        } else if (direction == Direction.NORTH && StairsBlock.method_6513(block = (blockState2 = blockView.getBlockState(BlockPos.ORIGIN)).getBlock()) && half == blockState2.get(HALF)) {
+            Direction direction2 = blockState2.get(StairsBlock.FACING);
+            if (direction2 == Direction.WEST && !StairsBlock.method_8907(blockView, BlockPos.ORIGIN, blockState)) {
+                bl2 = true;
+            } else if (direction2 == Direction.EAST && !StairsBlock.method_8907(blockView, BlockPos.ORIGIN, blockState)) {
+                h = 0.5f;
+                i = 1.0f;
+                bl2 = true;
+            }
+        }
+        if (bl2) {
+            this.setBoundingBox(h, f, j, i, g, k);
+        }
+        return bl2;
+    }
+}
@@ -0,0 +1,47 @@
+package dev.u9g.minecraftdatagenerator.util;
+
+import net.fabricmc.api.EnvType;
+import net.fabricmc.api.Environment;
+import net.fabricmc.loader.api.FabricLoader;
+import net.minecraft.client.resource.language.I18n;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.world.World;
+import org.jetbrains.annotations.NotNull;
+
+public class DGU {
+    public static MinecraftServer getCurrentlyRunningServer() {
+        return (MinecraftServer) FabricLoader.getInstance().getGameInstance();
+    }
+
+    @Environment(EnvType.CLIENT)
+    private static String translateTextClient(String translationKey) {
+        return I18n.translate(translationKey);
+    }
+
+    private static String translateTextFallback(String translationKey) {
+        try {
+            return Registries.LANGUAGE.translate(translationKey);
+        } catch (Exception ignored) {
+        }
+        throw new RuntimeException("Failed to translate: '" + translationKey + "'");
+    }
+
+    public static String translateText(String translationKey) {
+        EnvType environmentType = FabricLoader.getInstance().getEnvironmentType();
+        if (environmentType == EnvType.CLIENT) {
+            return translateTextClient(translationKey);
+        }
+        return translateTextFallback(translationKey);
+    }
+
+    @NotNull
+    public static World getWorld() {
+        return getCurrentlyRunningServer().getWorld();
+    }
+
+    public static ItemStack stackFor(Item ic) {
+        return new ItemStack(ic);
+    }
+}
@@ -0,0 +1,54 @@
+package dev.u9g.minecraftdatagenerator.util;
+
+import net.minecraft.block.BlockState;
+import net.minecraft.block.Blocks;
+import net.minecraft.block.entity.BlockEntity;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Direction;
+import net.minecraft.world.BlockView;
+import net.minecraft.world.biome.Biome;
+import net.minecraft.world.level.LevelGeneratorType;
+import org.jetbrains.annotations.Nullable;
+
+public class EmptyBlockView implements BlockView {
+    public static final EmptyBlockView INSTANCE = new EmptyBlockView();
+
+    @Nullable
+    public BlockEntity getBlockEntity(BlockPos pos) {
+        return null;
+    }
+
+    @Override
+    public int getLight(BlockPos pos, int minBlockLight) {
+        return 0;
+    }
+
+    public BlockState getBlockState(BlockPos pos) {
+        return Blocks.AIR.getDefaultState();
+    }
+
+    @Override
+    public boolean isAir(BlockPos pos) {
+        return false;
+    }
+
+    @Override
+    public Biome getBiome(BlockPos pos) {
+        return null;
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return false;
+    }
+
+    @Override
+    public int getStrongRedstonePower(BlockPos pos, Direction direction) {
+        return 0;
+    }
+
+    @Override
+    public LevelGeneratorType getGeneratorType() {
+        return null;
+    }
+}
@@ -0,0 +1,64 @@
+package dev.u9g.minecraftdatagenerator.util;
+
+import dev.u9g.minecraftdatagenerator.mixin.BiomeAccessor;
+import dev.u9g.minecraftdatagenerator.mixin.EnchantmentAccessor;
+import dev.u9g.minecraftdatagenerator.mixin.EntityTypeAccessor;
+import dev.u9g.minecraftdatagenerator.mixin.StatusEffectAccessor;
+import net.minecraft.block.Block;
+import net.minecraft.enchantment.Enchantment;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.effect.StatusEffect;
+import net.minecraft.item.Item;
+import net.minecraft.util.Identifier;
+import net.minecraft.util.Language;
+import net.minecraft.util.registry.SimpleRegistry;
+import net.minecraft.world.biome.Biome;
+
+import java.util.Map;
+
+public class Registries {
+    public static final SimpleRegistry<String, Biome> BIOMES = setupBiomeRegistry();
+    public static final SimpleRegistry<Identifier, Block> BLOCKS = Block.REGISTRY;
+    public static final SimpleRegistry<Identifier, Item> ITEMS = Item.REGISTRY;
+    public static final SimpleRegistry<Identifier, StatusEffect> STATUS_EFFECTS = setupStatusEffectRegistry();
+    public static final SimpleRegistry<Identifier, Enchantment> ENCHANTMENTS = setupEnchantmentRegistry();
+    public static final SimpleRegistry<Identifier, Class<? extends Entity>> ENTITY_TYPES = setupEntityTypesRegistry();
+    public static final Language LANGUAGE = new Language();
+
+    private static SimpleRegistry<Identifier, Class<? extends Entity>> setupEntityTypesRegistry() {
+        SimpleRegistry<Identifier, Class<? extends Entity>> registry = new SimpleRegistry<>();
+        for (Map.Entry<Integer, Class<? extends Entity>> entry : EntityTypeAccessor.ID_CLASS_MAP().entrySet()) {
+            String name = EntityTypeAccessor.CLASS_NAME_MAP().get(entry.getValue());
+            if (name.equals("Mob") || name.equals("Monster")) {
+                continue;
+            }
+            registry.add(entry.getKey(), new Identifier(name), entry.getValue());
+        }
+
+        return registry;
+    }
+
+    private static SimpleRegistry<Identifier, Enchantment> setupEnchantmentRegistry() {
+        SimpleRegistry<Identifier, Enchantment> registry = new SimpleRegistry<>();
+        for (Map.Entry<Identifier, Enchantment> entry : EnchantmentAccessor.ENCHANTMENT_MAP().entrySet()) {
+            registry.add(entry.getValue().id, entry.getKey(), entry.getValue());
+        }
+        return registry;
+    }
+
+    private static SimpleRegistry<String, Biome> setupBiomeRegistry() {
+        SimpleRegistry<String, Biome> registry = new SimpleRegistry<>();
+        for (Biome biome : BiomeAccessor.BIOMESET()) {
+            registry.add(biome.id, biome.name, biome);
+        }
+        return registry;
+    }
+
+    private static SimpleRegistry<Identifier, StatusEffect> setupStatusEffectRegistry() {
+        SimpleRegistry<Identifier, StatusEffect> registry = new SimpleRegistry<>();
+        for (Map.Entry<Identifier, StatusEffect> entry : StatusEffectAccessor.STATUS_EFFECTS_BY_ID().entrySet()) {
+            registry.add(entry.getValue().id, entry.getKey(), entry.getValue());
+        }
+        return registry;
+    }
+}
@@ -0,0 +1,26 @@
+{
+  "schemaVersion": 1,
+  "id": "minecraft-data-generator",
+  "version": "${version}",
+  "name": "Minecraft Data Generator",
+  "description": "",
+  "authors": [
+    "Archengius",
+    "U9G"
+  ],
+  "contact": {},
+  "license": "MIT",
+  "environment": "server",
+  "entrypoints": {
+    "main": [
+      "dev.u9g.minecraftdatagenerator.Main"
+    ]
+  },
+  "mixins": [
+    "minecraft-data-generator.mixins.json"
+  ],
+  "depends": {
+    "fabricloader": ">=0.13.3",
+    "minecraft": ">=1.8.9"
+  }
+}
@@ -0,0 +1,30 @@
+{
+  "required": true,
+  "minVersion": "0.8",
+  "package": "dev.u9g.minecraftdatagenerator.mixin",
+  "compatibilityLevel": "JAVA_17",
+  "mixins": [
+    "BiomeAccessor",
+    "BlockAccessor",
+    "EnchantmentAccessor",
+    "EntityTypeAccessor",
+    "LanguageAccessor",
+    "MiningToolItemAccessor",
+    "NoteBlockAccessor",
+    "ReadyMixin",
+    "StatusEffectAccessor",
+    "overwrite.CocoaBlockOverwrite",
+    "overwrite.EndPortalFrameBlockOverwrite",
+    "overwrite.ItemEntityOverwrite",
+    "overwrite.SkeletonSkullBlockOverwrite",
+    "overwrite.StairBlockOverwrite"
+  ],
+  "client": [
+  ],
+  "injectors": {
+    "defaultRequire": 1
+  },
+  "server": [
+    "EULAMixin"
+  ]
+}