From 256219880fae32906975fee52882f063a10b10c5 Mon Sep 17 00:00:00 2001 From: SuperGamerTron Date: Sat, 26 Oct 2024 19:02:54 -0600 Subject: [PATCH 01/12] Add 1.21.3 --- .github/workflows/build.yml | 4 +- 1.21.3/build.gradle | 47 ++++ .../generators/BiomesDataGenerator.java | 115 ++++++++++ .../BlockCollisionShapesDataGenerator.java | 110 +++++++++ .../generators/BlocksDataGenerator.java | 197 ++++++++++++++++ .../generators/EffectsDataGenerator.java | 46 ++++ .../generators/EnchantmentsDataGenerator.java | 108 +++++++++ .../generators/EntitiesDataGenerator.java | 119 ++++++++++ .../generators/FoodsDataGenerator.java | 52 +++++ .../generators/InstrumentsDataGenerator.java | 25 +++ .../generators/ItemsDataGenerator.java | 83 +++++++ .../generators/LanguageDataGenerator.java | 27 +++ .../generators/MaterialsDataGenerator.java | 211 ++++++++++++++++++ .../generators/ParticlesDataGenerator.java | 33 +++ .../generators/RecipeDataGenerator.java | 128 +++++++++++ .../generators/TintsDataGenerator.java | 158 +++++++++++++ .../mixin/EULAMixin.java | 15 ++ .../mixin/ReadyMixin.java | 22 ++ .../u9g/minecraftdatagenerator/util/DGU.java | 21 ++ .../util/EmptyRenderBlockView.java | 72 ++++++ 1.21.3/src/main/resources/fabric.mod.json | 20 ++ .../minecraft-data-generator.mixins.json | 15 ++ settings.gradle | 2 + 23 files changed, 1629 insertions(+), 1 deletion(-) create mode 100644 1.21.3/build.gradle create mode 100644 1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/BiomesDataGenerator.java create mode 100644 1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/BlockCollisionShapesDataGenerator.java create mode 100644 1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/BlocksDataGenerator.java create mode 100644 1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/EffectsDataGenerator.java create mode 100644 1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/EnchantmentsDataGenerator.java create mode 100644 1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/EntitiesDataGenerator.java create mode 100644 1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/FoodsDataGenerator.java create mode 100644 1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/InstrumentsDataGenerator.java create mode 100644 1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/ItemsDataGenerator.java create mode 100644 1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/LanguageDataGenerator.java create mode 100644 1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/MaterialsDataGenerator.java create mode 100644 1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/ParticlesDataGenerator.java create mode 100644 1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/RecipeDataGenerator.java create mode 100644 1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/TintsDataGenerator.java create mode 100644 1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/mixin/EULAMixin.java create mode 100644 1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/mixin/ReadyMixin.java create mode 100644 1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/util/DGU.java create mode 100644 1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/util/EmptyRenderBlockView.java create mode 100644 1.21.3/src/main/resources/fabric.mod.json create mode 100644 1.21.3/src/main/resources/minecraft-data-generator.mixins.json diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index a6ec2a5b..cf97facf 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -29,7 +29,9 @@ jobs: "1.19.2", "1.20", "1.20.4", - "1.20.5" + "1.20.5", + "1.21" + "1.21.3" ] name: Build ${{ matrix.version }} diff --git a/1.21.3/build.gradle b/1.21.3/build.gradle new file mode 100644 index 00000000..85b6813a --- /dev/null +++ b/1.21.3/build.gradle @@ -0,0 +1,47 @@ +import xyz.wagyourtail.unimined.api.minecraft.task.RemapJarTask +import xyz.wagyourtail.unimined.internal.minecraft.MinecraftProvider + +plugins { + id 'xyz.wagyourtail.unimined' +} + +unimined.minecraft { + version "1.21.3" + + mappings { + intermediary() + yarn(1) + + devFallbackNamespace "intermediary" + } + + runs.config("server") { + javaVersion = JavaVersion.VERSION_21 + } + + customPatcher(new CustomOfficialFabricMinecraftTransformer(project, delegate as MinecraftProvider)) { + it.loader libs.versions.fabric.loader.get() + } + + defaultRemapJar = true +} + +dependencies { + implementation project(":common") +} + +processResources { + filteringCharset "UTF-8" + + filesMatching("fabric.mod.json") { + expand "version": project.version + } +} + +tasks.withType(RemapJarTask).configureEach { + onlyIf { false} +} + +tasks.withType(JavaCompile).configureEach { + it.options.encoding = "UTF-8" +} diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/BiomesDataGenerator.java b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/BiomesDataGenerator.java new file mode 100644 index 00000000..a35d00fd --- /dev/null +++ b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/BiomesDataGenerator.java @@ -0,0 +1,115 @@ +package dev.u9g.minecraftdatagenerator.generators; + +import com.google.gson.JsonArray; +import com.google.gson.JsonObject; +import dev.u9g.minecraftdatagenerator.util.DGU; +import net.minecraft.registry.DynamicRegistryManager; +import net.minecraft.registry.Registry; +import net.minecraft.registry.RegistryKeys; +import net.minecraft.registry.tag.BiomeTags; +import net.minecraft.util.Identifier; +import net.minecraft.world.biome.Biome; + +public class BiomesDataGenerator implements IDataGenerator { + private static String guessBiomeDimensionFromCategory(Biome biome) { + var biomeRegistry = DGU.getWorld().getRegistryManager().getOrThrow(RegistryKeys.BIOME); + if (biomeRegistry.getEntry(biome).isIn(BiomeTags.IS_NETHER)) { + return "nether"; + } else if (biomeRegistry.getEntry(biome).isIn(BiomeTags.IS_END)) { + return "end"; + } else { + return "overworld"; + } + } + + private static String guessCategoryBasedOnName(String name, String dimension) { + if (dimension.equals("nether")) { + return "nether"; + } else if (dimension.equals("end")) { + return "the_end"; + } + + if (name.contains("end")) { + System.out.println(); + } + + if (name.contains("hills")) { + return "extreme_hills"; + } else if (name.contains("ocean")) { + return "ocean"; + } else if (name.contains("plains")) { + return "plains"; + } else if (name.contains("ice") || name.contains("frozen")) { + return "ice"; + } else if (name.contains("jungle")) { + return "jungle"; + } else if (name.contains("desert")) { + return "desert"; + } else if (name.contains("forest") || name.contains("grove")) { + return "forest"; + } else if (name.contains("taiga")) { + return "taiga"; + } else if (name.contains("swamp")) { + return "swamp"; + } else if (name.contains("river")) { + return "river"; + } else if (name.equals("the_end")) { + return "the_end"; + } else if (name.contains("mushroom")) { + return "mushroom"; + } else if (name.contains("beach") || name.equals("stony_shore")) { + return "beach"; + } else if (name.contains("savanna")) { + return "savanna"; + } else if (name.contains("badlands")) { + return "mesa"; + } else if (name.contains("peaks") || name.equals("snowy_slopes") || name.equals("meadow")) { + return "mountain"; + } else if (name.equals("the_void")) { + return "none"; + } else if (name.contains("cave") || name.equals("deep_dark")) { + return "underground"; + } else { + System.out.println("Unable to find biome category for biome with name: '" + name + "'"); + return "none"; + } + } + + public static JsonObject generateBiomeInfo(Registry registry, Biome biome) { + JsonObject biomeDesc = new JsonObject(); + Identifier registryKey = registry.getKey(biome).orElseThrow().getValue(); + String localizationKey = String.format("biome.%s.%s", registryKey.getNamespace(), registryKey.getPath()); + String name = registryKey.getPath(); + biomeDesc.addProperty("id", registry.getRawId(biome)); + biomeDesc.addProperty("name", name); + String dimension = guessBiomeDimensionFromCategory(biome); + biomeDesc.addProperty("category", guessCategoryBasedOnName(name, dimension)); + biomeDesc.addProperty("temperature", biome.getTemperature()); + //biomeDesc.addProperty("precipitation", biome.getPrecipitation().getName());// - removed in 1.19.4 + biomeDesc.addProperty("has_precipitation", biome.hasPrecipitation()); + //biomeDesc.addProperty("depth", biome.getDepth()); - Doesn't exist anymore in minecraft source + biomeDesc.addProperty("dimension", dimension); + biomeDesc.addProperty("displayName", DGU.translateText(localizationKey)); + biomeDesc.addProperty("color", biome.getSkyColor()); + //biomeDesc.addProperty("rainfall", biome.getDownfall());// - removed in 1.19.4 + + return biomeDesc; + } + + @Override + public String getDataName() { + return "biomes"; + } + + @Override + public JsonArray generateDataJson() { + JsonArray biomesArray = new JsonArray(); + DynamicRegistryManager registryManager = DGU.getWorld().getRegistryManager(); + Registry biomeRegistry = registryManager.get(RegistryKeys.BIOME); + + biomeRegistry.stream() + .map(biome -> generateBiomeInfo(biomeRegistry, biome)) + .forEach(biomesArray::add); + return biomesArray; + } +} diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/BlockCollisionShapesDataGenerator.java b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/BlockCollisionShapesDataGenerator.java new file mode 100644 index 00000000..68a169cd --- /dev/null +++ b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/BlockCollisionShapesDataGenerator.java @@ -0,0 +1,110 @@ +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 net.minecraft.block.Block; +import net.minecraft.block.BlockState; +import net.minecraft.registry.Registry; +import net.minecraft.registry.RegistryKeys; +import net.minecraft.util.Identifier; +import net.minecraft.util.math.BlockPos; +import net.minecraft.util.shape.VoxelShape; +import net.minecraft.world.EmptyBlockView; + +import java.util.*; + +public class BlockCollisionShapesDataGenerator implements IDataGenerator { + + @Override + public String getDataName() { + return "blockCollisionShapes"; + } + + @Override + public JsonObject generateDataJson() { + Registry blockRegistry = DGU.getWorld().getRegistryManager().get(RegistryKeys.BLOCK); + BlockShapesCache blockShapesCache = new BlockShapesCache(); + + blockRegistry.forEach(blockShapesCache::processBlock); + + JsonObject resultObject = new JsonObject(); + + resultObject.add("blocks", blockShapesCache.dumpBlockShapeIndices(blockRegistry)); + resultObject.add("shapes", blockShapesCache.dumpShapesObject()); + + return resultObject; + } + + private static class BlockShapesCache { + public final Map uniqueBlockShapes = new LinkedHashMap<>(); + public final Map> blockCollisionShapes = new LinkedHashMap<>(); + private int lastCollisionShapeId = 0; + + public void processBlock(Block block) { + List blockStates = block.getStateManager().getStates(); + List blockCollisionShapes = new ArrayList<>(); + + for (BlockState blockState : blockStates) { + VoxelShape blockShape = blockState.getCollisionShape(EmptyBlockView.INSTANCE, BlockPos.ORIGIN); + Integer blockShapeIndex = uniqueBlockShapes.get(blockShape); + + if (blockShapeIndex == null) { + blockShapeIndex = lastCollisionShapeId++; + uniqueBlockShapes.put(blockShape, blockShapeIndex); + } + blockCollisionShapes.add(blockShapeIndex); + } + + this.blockCollisionShapes.put(block, blockCollisionShapes); + } + + public JsonObject dumpBlockShapeIndices(Registry blockRegistry) { + JsonObject resultObject = new JsonObject(); + + for (var entry : blockCollisionShapes.entrySet()) { + List blockCollisions = entry.getValue(); + long distinctShapesCount = blockCollisions.stream().distinct().count(); + JsonElement blockCollision; + if (distinctShapesCount == 1L) { + blockCollision = new JsonPrimitive(blockCollisions.getFirst()); + } else { + blockCollision = new JsonArray(); + for (int collisionId : blockCollisions) { + ((JsonArray) blockCollision).add(collisionId); + } + } + + Identifier registryKey = blockRegistry.getKey(entry.getKey()).orElseThrow().getValue(); + resultObject.add(registryKey.getPath(), blockCollision); + } + + return resultObject; + } + + public JsonObject dumpShapesObject() { + JsonObject shapesObject = new JsonObject(); + + for (var entry : uniqueBlockShapes.entrySet()) { + JsonArray boxesArray = new JsonArray(); + entry.getKey().forEachBox((x1, y1, z1, x2, y2, z2) -> { + JsonArray oneBoxJsonArray = new JsonArray(); + + oneBoxJsonArray.add(x1); + oneBoxJsonArray.add(y1); + oneBoxJsonArray.add(z1); + + oneBoxJsonArray.add(x2); + oneBoxJsonArray.add(y2); + oneBoxJsonArray.add(z2); + + boxesArray.add(oneBoxJsonArray); + }); + shapesObject.add(Integer.toString(entry.getValue()), boxesArray); + } + return shapesObject; + } + } +} diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/BlocksDataGenerator.java b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/BlocksDataGenerator.java new file mode 100644 index 00000000..324b4d90 --- /dev/null +++ b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/BlocksDataGenerator.java @@ -0,0 +1,197 @@ +package dev.u9g.minecraftdatagenerator.generators; + +import com.google.common.base.CaseFormat; +import com.google.gson.JsonArray; +import com.google.gson.JsonObject; +import dev.u9g.minecraftdatagenerator.util.DGU; +import net.minecraft.block.AirBlock; +import net.minecraft.block.Block; +import net.minecraft.block.BlockState; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.item.Items; +import net.minecraft.loot.context.LootContextParameterSet; +import net.minecraft.loot.context.LootContextParameters; +import net.minecraft.registry.Registries; +import net.minecraft.registry.RegistryKeys; +import net.minecraft.server.MinecraftServer; +import net.minecraft.server.world.ServerWorld; +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 net.minecraft.util.math.Vec3d; +import net.minecraft.util.shape.VoxelShape; +import net.minecraft.world.EmptyBlockView; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; +import java.util.stream.Collectors; + +public class BlocksDataGenerator implements IDataGenerator { + + private static final Logger logger = LoggerFactory.getLogger(BlocksDataGenerator.class); + + private static List getItemsEffectiveForBlock(BlockState blockState) { + return DGU.getWorld().getRegistryManager().get(RegistryKeys.ITEM).stream() + .filter(item -> item.getDefaultStack().isSuitableFor(blockState)) + .collect(Collectors.toList()); + } + + private static void populateDropsIfPossible(BlockState blockState, Item firstToolItem, List outDrops) { + MinecraftServer minecraftServer = DGU.getCurrentlyRunningServer(); + if (minecraftServer != null) { + //If we have local world context, we can actually evaluate loot tables and determine actual data + ServerWorld serverWorld = minecraftServer.getOverworld(); + LootContextParameterSet.Builder lootContextParameterSet = new LootContextParameterSet.Builder(serverWorld) + .add(LootContextParameters.BLOCK_STATE, blockState) + .add(LootContextParameters.ORIGIN, Vec3d.ZERO) + .add(LootContextParameters.TOOL, firstToolItem.getDefaultStack()); + outDrops.addAll(blockState.getDroppedStacks(lootContextParameterSet)); + } else { + //If we're lacking world context to correctly determine drops, assume that default drop is ItemBlock stack in quantity of 1 + Item itemBlock = blockState.getBlock().asItem(); + if (itemBlock != Items.AIR) { + outDrops.add(itemBlock.getDefaultStack()); + } + } + } + + 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 > JsonObject generateStateProperty(Property property) { + JsonObject propertyObject = new JsonObject(); + Collection 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(property.name(propertyValue)); + } + propertyObject.add("values", propertyValuesArray); + } + return propertyObject; + } + + private static String findMatchingBlockMaterial(BlockState blockState, List materials) { + List matchingMaterials = materials.stream() + .filter(material -> material.getPredicate().test(blockState)) + .collect(Collectors.toList()); + + if (matchingMaterials.size() > 1) { + var firstMaterial = matchingMaterials.getFirst(); + var otherMaterials = matchingMaterials.subList(1, matchingMaterials.size()); + + if (!otherMaterials.stream().allMatch(firstMaterial::includesMaterial)) { + logger.error("Block {} matches multiple materials: {}", blockState.getBlock(), matchingMaterials); + } + } + if (matchingMaterials.isEmpty()) { + return "default"; + } + return matchingMaterials.getFirst().getMaterialName(); + } + + public static JsonObject generateBlock(List materials, Block block) { + JsonObject blockDesc = new JsonObject(); + + List blockStates = block.getStateManager().getStates(); + BlockState defaultState = block.getDefaultState(); + Identifier registryKey = Registries.BLOCK.getKey(block).orElseThrow().getValue(); + String localizationKey = block.getTranslationKey(); + List effectiveTools = getItemsEffectiveForBlock(defaultState); + + blockDesc.addProperty("id", Registries.BLOCK.getRawId(block)); + blockDesc.addProperty("name", registryKey.getPath()); + blockDesc.addProperty("displayName", DGU.translateText(localizationKey)); + + blockDesc.addProperty("hardness", block.getHardness()); + blockDesc.addProperty("resistance", block.getBlastResistance()); + blockDesc.addProperty("stackSize", block.asItem().getMaxCount()); + blockDesc.addProperty("diggable", block.getHardness() != -1.0f && !(block instanceof AirBlock)); +// JsonObject effTools = new JsonObject(); +// effectiveTools.forEach(item -> effTools.addProperty( +// String.valueOf(Registry.ITEM.getRawId(item)), // key +// item.getMiningSpeedMultiplier(item.getDefaultStack(), defaultState) // value +// )); +// blockDesc.add("effectiveTools", effTools); + blockDesc.addProperty("material", findMatchingBlockMaterial(defaultState, materials)); + + blockDesc.addProperty("transparent", !defaultState.isOpaque()); + blockDesc.addProperty("emitLight", defaultState.getLuminance()); + blockDesc.addProperty("filterLight", defaultState.getOpacity(EmptyBlockView.INSTANCE, BlockPos.ORIGIN)); + + blockDesc.addProperty("defaultState", Block.getRawIdFromState(defaultState)); + blockDesc.addProperty("minStateId", Block.getRawIdFromState(blockStates.getFirst())); + blockDesc.addProperty("maxStateId", Block.getRawIdFromState(blockStates.getLast())); + + JsonArray stateProperties = new JsonArray(); + for (Property property : block.getStateManager().getProperties()) { + stateProperties.add(generateStateProperty(property)); + } + blockDesc.add("states", stateProperties); + + //Only add harvest tools if tool is required for harvesting this block + if (defaultState.isToolRequired()) { + JsonObject effectiveToolsObject = new JsonObject(); + for (Item effectiveItem : effectiveTools) { + effectiveToolsObject.addProperty(Integer.toString(Item.getRawId(effectiveItem)), true); + } + blockDesc.add("harvestTools", effectiveToolsObject); + } + + List actualBlockDrops = new ArrayList<>(); + populateDropsIfPossible(defaultState, effectiveTools.isEmpty() ? Items.AIR : effectiveTools.getFirst(), actualBlockDrops); + + JsonArray dropsArray = new JsonArray(); + for (ItemStack dropStack : actualBlockDrops) { + dropsArray.add(Item.getRawId(dropStack.getItem())); + } + blockDesc.add("drops", dropsArray); + + VoxelShape blockCollisionShape = defaultState.getCollisionShape(EmptyBlockView.INSTANCE, BlockPos.ORIGIN); + blockDesc.addProperty("boundingBox", blockCollisionShape.isEmpty() ? "empty" : "block"); + + return blockDesc; + } + + @Override + public String getDataName() { + return "blocks"; + } + + @Override + public JsonArray generateDataJson() { + JsonArray resultBlocksArray = new JsonArray(); + List availableMaterials = MaterialsDataGenerator.getGlobalMaterialInfo(); + + Registries.BLOCK.forEach(block -> resultBlocksArray.add(generateBlock(availableMaterials, block))); + return resultBlocksArray; + } +} diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/EffectsDataGenerator.java b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/EffectsDataGenerator.java new file mode 100644 index 00000000..dd6dc019 --- /dev/null +++ b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/EffectsDataGenerator.java @@ -0,0 +1,46 @@ +package dev.u9g.minecraftdatagenerator.generators; + +import com.google.gson.JsonArray; +import com.google.gson.JsonObject; +import dev.u9g.minecraftdatagenerator.util.DGU; +import net.minecraft.entity.effect.StatusEffect; +import net.minecraft.entity.effect.StatusEffects; +import net.minecraft.registry.Registry; +import net.minecraft.registry.RegistryKeys; +import net.minecraft.util.Identifier; +import org.apache.commons.lang3.StringUtils; + +import java.util.Arrays; +import java.util.stream.Collectors; + +public class EffectsDataGenerator implements IDataGenerator { + public static JsonObject generateEffect(Registry registry, StatusEffect statusEffect) { + JsonObject effectDesc = new JsonObject(); + Identifier registryKey = registry.getKey(statusEffect).orElseThrow().getValue(); + + effectDesc.addProperty("id", registry.getRawId(statusEffect)); + if (statusEffect == StatusEffects.UNLUCK) { + effectDesc.addProperty("name", "BadLuck"); + effectDesc.addProperty("displayName", "Bad Luck"); + } else { + effectDesc.addProperty("name", Arrays.stream(registryKey.getPath().split("_")).map(StringUtils::capitalize).collect(Collectors.joining())); + effectDesc.addProperty("displayName", DGU.translateText(statusEffect.getTranslationKey())); + } + + effectDesc.addProperty("type", statusEffect.isBeneficial() ? "good" : "bad"); + return effectDesc; + } + + @Override + public String getDataName() { + return "effects"; + } + + @Override + public JsonArray generateDataJson() { + JsonArray resultsArray = new JsonArray(); + Registry statusEffectRegistry = DGU.getWorld().getRegistryManager().get(RegistryKeys.STATUS_EFFECT); + statusEffectRegistry.forEach(effect -> resultsArray.add(generateEffect(statusEffectRegistry, effect))); + return resultsArray; + } +} diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/EnchantmentsDataGenerator.java b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/EnchantmentsDataGenerator.java new file mode 100644 index 00000000..bf77d6fa --- /dev/null +++ b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/EnchantmentsDataGenerator.java @@ -0,0 +1,108 @@ +package dev.u9g.minecraftdatagenerator.generators; + +import com.google.gson.JsonArray; +import com.google.gson.JsonObject; +import dev.u9g.minecraftdatagenerator.util.DGU; +import net.minecraft.enchantment.Enchantment; +import net.minecraft.item.Item; +import net.minecraft.registry.Registry; +import net.minecraft.registry.RegistryKeys; +import net.minecraft.registry.tag.TagKey; +import net.minecraft.registry.entry.RegistryEntryList; +import net.minecraft.util.Identifier; +import net.minecraft.registry.entry.RegistryEntry; + + +import java.util.List; +import java.util.Set; + +public class EnchantmentsDataGenerator implements IDataGenerator { + public static String getEnchantmentTargetName(RegistryEntryList target) { + TagKey tagKey = target.getTagKey().orElseThrow(); + return tagKey.id().getPath().split("/")[1]; + } + + private static boolean isEnchantmentInTag(Enchantment enchantment, String tag) { + return DGU.getWorld() + .getRegistryManager() + .get(RegistryKeys.ENCHANTMENT) + .streamTagsAndEntries() + .filter(tagKeyNamedPair -> tagKeyNamedPair.getFirst().id().equals(Identifier.of(tag))) + .flatMap(tagKeyNamedPair -> tagKeyNamedPair.getSecond().stream()) + .anyMatch(enchantmentRegistryEntry -> enchantmentRegistryEntry.value() == enchantment); + } + + //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.getMinPower(0); + int a = enchantment.getMinPower(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.getMaxPower(0); + int a = enchantment.getMaxPower(1) - b; + + JsonObject resultObject = new JsonObject(); + resultObject.addProperty("a", a); + resultObject.addProperty("b", b); + return resultObject; + } + + public static JsonObject generateEnchantment(Registry registry, Enchantment enchantment) { + JsonObject enchantmentDesc = new JsonObject(); + Identifier registryKey = registry.getKey(enchantment).orElseThrow().getValue(); + + enchantmentDesc.addProperty("id", registry.getRawId(enchantment)); + enchantmentDesc.addProperty("name", registryKey.getPath()); + enchantmentDesc.addProperty("displayName", enchantment.description().getString()); + + enchantmentDesc.addProperty("maxLevel", enchantment.getMaxLevel()); + enchantmentDesc.add("minCost", generateEnchantmentMinPowerCoefficients(enchantment)); + enchantmentDesc.add("maxCost", generateEnchantmentMaxPowerCoefficients(enchantment)); + + enchantmentDesc.addProperty("treasureOnly", isEnchantmentInTag(enchantment, "treasure")); + + enchantmentDesc.addProperty("curse", isEnchantmentInTag(enchantment, "curse")); + + List incompatibleEnchantments = registry.stream() + .filter(other -> { + RegistryEntry enchantmentEntry = registry.getEntry(enchantment); + RegistryEntry otherEntry = registry.getEntry(other); + return !Enchantment.canBeCombined(enchantmentEntry, otherEntry); + }) + .filter(other -> other != enchantment) + .toList(); + + JsonArray excludes = new JsonArray(); + for (Enchantment excludedEnchantment : incompatibleEnchantments) { + Identifier otherKey = registry.getKey(excludedEnchantment).orElseThrow().getValue(); + excludes.add(otherKey.getPath()); + } + enchantmentDesc.add("exclude", excludes); + enchantmentDesc.addProperty("category", getEnchantmentTargetName(enchantment.getApplicableItems())); + enchantmentDesc.addProperty("weight", enchantment.getWeight()); + enchantmentDesc.addProperty("tradeable", isEnchantmentInTag(enchantment, "tradeable")); + enchantmentDesc.addProperty("discoverable", isEnchantmentInTag(enchantment, "on_random_loot")); + + return enchantmentDesc; + } + + @Override + public String getDataName() { + return "enchantments"; + } + + @Override + public JsonArray generateDataJson() { + JsonArray resultsArray = new JsonArray(); + Registry enchantmentRegistry = DGU.getWorld().getRegistryManager().get(RegistryKeys.ENCHANTMENT); + enchantmentRegistry.stream() + .forEach(enchantment -> resultsArray.add(generateEnchantment(enchantmentRegistry, enchantment))); + return resultsArray; + } +} \ No newline at end of file diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/EntitiesDataGenerator.java b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/EntitiesDataGenerator.java new file mode 100644 index 00000000..70a88040 --- /dev/null +++ b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/EntitiesDataGenerator.java @@ -0,0 +1,119 @@ +package dev.u9g.minecraftdatagenerator.generators; + +import com.google.gson.JsonArray; +import com.google.gson.JsonObject; +import dev.u9g.minecraftdatagenerator.util.DGU; +import net.minecraft.entity.Entity; +import net.minecraft.entity.EntityType; +import net.minecraft.entity.LivingEntity; +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.passive.PassiveEntity; +import net.minecraft.entity.projectile.ProjectileEntity; +import net.minecraft.registry.Registry; +import net.minecraft.registry.RegistryKeys; +import net.minecraft.server.MinecraftServer; +import net.minecraft.util.Identifier; + +public class EntitiesDataGenerator implements IDataGenerator { + public static JsonObject generateEntity(Registry> entityRegistry, EntityType entityType) { + JsonObject entityDesc = new JsonObject(); + Identifier registryKey = entityRegistry.getKey(entityType).orElseThrow().getValue(); + int entityRawId = entityRegistry.getRawId(entityType); + + entityDesc.addProperty("id", entityRawId); + entityDesc.addProperty("internalId", entityRawId); + entityDesc.addProperty("name", registryKey.getPath()); + + entityDesc.addProperty("displayName", DGU.translateText(entityType.getTranslationKey())); + entityDesc.addProperty("width", entityType.getDimensions().width()); + entityDesc.addProperty("height", entityType.getDimensions().height()); + + String entityTypeString = "UNKNOWN"; + MinecraftServer minecraftServer = DGU.getCurrentlyRunningServer(); + + if (minecraftServer != null) { + Entity entityObject = entityType.create(minecraftServer.getOverworld()); + entityTypeString = entityObject != null ? getEntityTypeForClass(entityObject.getClass()) : "unknown"; + } + if (entityType == EntityType.PLAYER) { + entityTypeString = "player"; + } + + entityDesc.addProperty("type", entityTypeString); + entityDesc.addProperty("category", getCategoryFrom(entityType)); + + return entityDesc; + } + + private static String getCategoryFrom(EntityType entityType) { + if (entityType == EntityType.PLAYER) return "UNKNOWN"; + Entity entity = entityType.create(DGU.getWorld()); + if (entity == null) + throw new Error("Entity was null after trying to create a: " + DGU.translateText(entityType.getTranslationKey())); + entity.discard(); + return switch (entity.getClass().getPackageName()) { + 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.projectile.thrown" -> "Projectiles"; + case "net.minecraft.entity.passive" -> "Passive mobs"; + case "net.minecraft.entity.vehicle" -> "Vehicles"; + case "net.minecraft.entity" -> "UNKNOWN"; + default -> throw new Error("Unexpected entity type: " + entity.getClass().getPackageName()); + }; + } + + //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 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 (PassiveEntity.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 (ProjectileEntity.class.isAssignableFrom(entityClass)) { + return "projectile"; + } + return "other"; + } + + @Override + public String getDataName() { + return "entities"; + } + + @Override + public JsonArray generateDataJson() { + JsonArray resultArray = new JsonArray(); + Registry> entityTypeRegistry = DGU.getWorld().getRegistryManager().get(RegistryKeys.ENTITY_TYPE); + entityTypeRegistry.forEach(entity -> resultArray.add(generateEntity(entityTypeRegistry, entity))); + return resultArray; + } +} diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/FoodsDataGenerator.java b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/FoodsDataGenerator.java new file mode 100644 index 00000000..ddb61fe9 --- /dev/null +++ b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/FoodsDataGenerator.java @@ -0,0 +1,52 @@ +package dev.u9g.minecraftdatagenerator.generators; + +import com.google.gson.JsonArray; +import com.google.gson.JsonObject; +import dev.u9g.minecraftdatagenerator.util.DGU; +import net.minecraft.component.DataComponentTypes; +import net.minecraft.component.type.FoodComponent; +import net.minecraft.item.Item; +import net.minecraft.registry.Registry; +import net.minecraft.registry.RegistryKeys; +import net.minecraft.util.Identifier; + +import java.util.Objects; + +public class FoodsDataGenerator implements IDataGenerator { + public static JsonObject generateFoodDescriptor(Registry registry, Item foodItem) { + JsonObject foodDesc = new JsonObject(); + Identifier registryKey = registry.getKey(foodItem).orElseThrow().getValue(); + + foodDesc.addProperty("id", registry.getRawId(foodItem)); + foodDesc.addProperty("name", registryKey.getPath()); + + foodDesc.addProperty("stackSize", foodItem.getMaxCount()); + foodDesc.addProperty("displayName", DGU.translateText(foodItem.getTranslationKey())); + + FoodComponent foodComponent = Objects.requireNonNull(foodItem.getComponents().get(DataComponentTypes.FOOD)); + float foodPoints = foodComponent.nutrition(); + float saturationRatio = foodComponent.saturation() * 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(); + Registry itemRegistry = DGU.getWorld().getRegistryManager().get(RegistryKeys.ITEM); + itemRegistry.stream() + .filter(i -> i.getComponents().contains(DataComponentTypes.FOOD)) + .forEach(food -> resultsArray.add(generateFoodDescriptor(itemRegistry, food))); + return resultsArray; + } +} diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/InstrumentsDataGenerator.java b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/InstrumentsDataGenerator.java new file mode 100644 index 00000000..f422620d --- /dev/null +++ b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/InstrumentsDataGenerator.java @@ -0,0 +1,25 @@ +package dev.u9g.minecraftdatagenerator.generators; + +import com.google.gson.JsonArray; +import com.google.gson.JsonElement; +import com.google.gson.JsonObject; +import net.minecraft.block.enums.NoteBlockInstrument; + +public class InstrumentsDataGenerator implements IDataGenerator { + @Override + public String getDataName() { + return "instruments"; + } + + @Override + public JsonElement generateDataJson() { + JsonArray array = new JsonArray(); + for (NoteBlockInstrument instrument : NoteBlockInstrument.values()) { + JsonObject object = new JsonObject(); + object.addProperty("id", instrument.ordinal()); + object.addProperty("name", instrument.asString()); + array.add(object); + } + return array; + } +} diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/ItemsDataGenerator.java b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/ItemsDataGenerator.java new file mode 100644 index 00000000..ddc4da05 --- /dev/null +++ b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/ItemsDataGenerator.java @@ -0,0 +1,83 @@ +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 net.minecraft.component.DataComponentTypes; +import net.minecraft.enchantment.Enchantment; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.registry.Registry; +import net.minecraft.registry.RegistryKeys; +import net.minecraft.registry.entry.RegistryEntry; +import net.minecraft.util.Identifier; + +import java.util.List; +import java.util.Objects; +import java.util.stream.Collectors; + +public class ItemsDataGenerator implements IDataGenerator { + + private static List calculateItemsToRepairWith(Registry itemRegistry, Item sourceItem) { + ItemStack sourceItemStack = sourceItem.getDefaultStack(); + return itemRegistry.stream() + .filter(otherItem -> sourceItem.canRepair(sourceItemStack, otherItem.getDefaultStack())) + .collect(Collectors.toList()); + } + + + + public static JsonObject generateItem(Registry itemRegistry, Item item) { + JsonObject itemDesc = new JsonObject(); + Identifier registryKey = itemRegistry.getKey(item).orElseThrow().getValue(); + + itemDesc.addProperty("id", itemRegistry.getRawId(item)); + itemDesc.addProperty("name", registryKey.getPath()); + + itemDesc.addProperty("displayName", DGU.translateText(item.getTranslationKey())); + itemDesc.addProperty("stackSize", item.getMaxCount()); + + JsonArray enchantCategoriesArray = new JsonArray(); + DGU.getWorld().getRegistryManager().get(RegistryKeys.ENCHANTMENT).stream() + .map(Enchantment::getApplicableItems) + .filter(applicableItems -> applicableItems.contains(itemRegistry.getEntry(item))) + .map(EnchantmentsDataGenerator::getEnchantmentTargetName) + .distinct() + .forEach(enchantCategoriesArray::add); + + if (enchantCategoriesArray.size() > 0) { + itemDesc.add("enchantCategories", enchantCategoriesArray); + } + + if (item.getComponents().contains(DataComponentTypes.DAMAGE)) { + List repairWithItems = calculateItemsToRepairWith(itemRegistry, item); + + JsonArray fixedWithArray = new JsonArray(); + for (Item repairWithItem : repairWithItems) { + Identifier repairWithName = itemRegistry.getKey(repairWithItem).orElseThrow().getValue(); + fixedWithArray.add(repairWithName.getPath()); + } + if (fixedWithArray.size() > 0) { + itemDesc.add("repairWith", fixedWithArray); + } + + int maxDurability = Objects.requireNonNull(item.getComponents().get(DataComponentTypes.MAX_DAMAGE)); + itemDesc.addProperty("maxDurability", maxDurability); + } + return itemDesc; + } + + @Override + public String getDataName() { + return "items"; + } + + @Override + public JsonArray generateDataJson() { + JsonArray resultArray = new JsonArray(); + Registry itemRegistry = DGU.getWorld().getRegistryManager().get(RegistryKeys.ITEM); + itemRegistry.stream().forEach(item -> resultArray.add(generateItem(itemRegistry, item))); + return resultArray; + } +} \ No newline at end of file diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/LanguageDataGenerator.java b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/LanguageDataGenerator.java new file mode 100644 index 00000000..7a3c6ced --- /dev/null +++ b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/LanguageDataGenerator.java @@ -0,0 +1,27 @@ +package dev.u9g.minecraftdatagenerator.generators; + +import com.google.gson.Gson; +import com.google.gson.JsonElement; +import com.google.gson.JsonObject; + +import java.io.InputStream; +import java.io.InputStreamReader; +import java.nio.charset.StandardCharsets; +import java.util.Objects; + +public class LanguageDataGenerator implements IDataGenerator { + @Override + public String getDataName() { + return "language"; + } + + @Override + public JsonElement generateDataJson() { + try { + InputStream inputStream = Objects.requireNonNull(this.getClass().getResourceAsStream("/assets/minecraft/lang/en_us.json")); + return new Gson().fromJson(new InputStreamReader(inputStream, StandardCharsets.UTF_8), JsonObject.class); + } catch (Exception ignored) { + } + throw new RuntimeException("Failed to generate language file"); + } +} diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/MaterialsDataGenerator.java b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/MaterialsDataGenerator.java new file mode 100644 index 00000000..46e42b47 --- /dev/null +++ b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/MaterialsDataGenerator.java @@ -0,0 +1,211 @@ +package dev.u9g.minecraftdatagenerator.generators; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; +import com.google.gson.JsonElement; +import com.google.gson.JsonObject; +import dev.u9g.minecraftdatagenerator.util.DGU; +import net.minecraft.block.Block; +import net.minecraft.block.BlockState; +import net.minecraft.block.Blocks; +import net.minecraft.component.DataComponentTypes; +import net.minecraft.item.Item; +import net.minecraft.item.Items; +import net.minecraft.item.MiningToolItem; +import net.minecraft.item.SwordItem; +import net.minecraft.registry.Registry; +import net.minecraft.registry.RegistryKeys; +import net.minecraft.registry.tag.BlockTags; +import net.minecraft.registry.tag.TagKey; + +import java.util.*; +import java.util.function.Predicate; +import java.util.stream.Collectors; + +//TODO entire idea of linking materials to tool speeds is obsolete and just wrong now, +//TODO but we kinda have to support it to let old code work for computing digging times, +//TODO so for now we will handle materials as "virtual" ones based on which tools can break blocks +public class MaterialsDataGenerator implements IDataGenerator { + + private static final List> COMPOSITE_MATERIALS = ImmutableList.>builder() + .add(ImmutableList.of("plant", makeMaterialNameForTag(BlockTags.AXE_MINEABLE))) + .add(ImmutableList.of("gourd", makeMaterialNameForTag(BlockTags.AXE_MINEABLE))) + .add(ImmutableList.of(makeMaterialNameForTag(BlockTags.LEAVES), makeMaterialNameForTag(BlockTags.HOE_MINEABLE))) + .add(ImmutableList.of(makeMaterialNameForTag(BlockTags.LEAVES), makeMaterialNameForTag(BlockTags.AXE_MINEABLE), makeMaterialNameForTag(BlockTags.HOE_MINEABLE))) + .add(ImmutableList.of("vine_or_glow_lichen", "plant", makeMaterialNameForTag(BlockTags.AXE_MINEABLE) + )).build(); + + private static String makeMaterialNameForTag(TagKey tag) { + return tag.id().getPath(); + } + + private static void createCompositeMaterialInfo(List allMaterials, List combinedMaterials) { + String compositeMaterialName = String.join(";", combinedMaterials); + + List mappedMaterials = combinedMaterials.stream() + .map(otherName -> allMaterials.stream() + .filter(other -> other.getMaterialName().equals(otherName)) + .findFirst().orElseThrow(() -> new RuntimeException("Material not found with name " + otherName))) + .collect(Collectors.toList()); + + Predicate compositePredicate = blockState -> + mappedMaterials.stream().allMatch(it -> it.getPredicate().test(blockState)); + + MaterialInfo materialInfo = new MaterialInfo(compositeMaterialName, compositePredicate).includes(mappedMaterials); + allMaterials.addFirst(materialInfo); + } + + private static void createCompositeMaterial(Map> allMaterials, List combinedMaterials) { + String compositeMaterialName = String.join(";", combinedMaterials); + + Map resultingToolSpeeds = new LinkedHashMap<>(); + combinedMaterials.stream() + .map(allMaterials::get) + .forEach(resultingToolSpeeds::putAll); + allMaterials.put(compositeMaterialName, resultingToolSpeeds); + } + + public static List getGlobalMaterialInfo() { + ArrayList resultList = new ArrayList<>(); + + resultList.add(new MaterialInfo("vine_or_glow_lichen", blockState -> blockState.isOf(Blocks.VINE) || blockState.isOf(Blocks.GLOW_LICHEN))); + resultList.add(new MaterialInfo("coweb", blockState -> blockState.isOf(Blocks.COBWEB))); + + resultList.add(new MaterialInfo("leaves", blockState -> blockState.isIn(BlockTags.LEAVES))); + resultList.add(new MaterialInfo("wool", blockState -> blockState.isIn(BlockTags.WOOL))); + + // Block Materials were removed in 1.20 in favor of block tags + resultList.add(new MaterialInfo("gourd", blockState -> blockState.isOf(Blocks.MELON) || blockState.isOf(Blocks.PUMPKIN) || blockState.isOf(Blocks.JACK_O_LANTERN))); + // 'sword_efficient' tag is for all plants, and includes everything from the old PLANT and REPLACEABLE_PLANT materials (see https://minecraft.fandom.com/wiki/Tag#Blocks) + resultList.add(new MaterialInfo("plant", blockState -> blockState.isIn(BlockTags.SWORD_EFFICIENT))); + + HashSet uniqueMaterialNames = new HashSet<>(); + + Registry itemRegistry = DGU.getWorld().getRegistryManager().get(RegistryKeys.ITEM); + itemRegistry.forEach(item -> { + if (item instanceof MiningToolItem toolItem) { + item.getComponents().get(DataComponentTypes.TOOL).rules() + .stream().map(rule -> rule.blocks()) + .forEach(blocks -> { + Optional> tagKey = blocks.getTagKey(); + if (tagKey.isPresent()) { + String materialName = makeMaterialNameForTag((tagKey.get())); + + if (!uniqueMaterialNames.contains(materialName)) { + uniqueMaterialNames.add(materialName); + resultList.add(new MaterialInfo(materialName, blockState -> blockState.isIn(blocks))); + } + } + }); + } + }); + + COMPOSITE_MATERIALS.forEach(values -> createCompositeMaterialInfo(resultList, values)); + return resultList; + } + + @Override + public String getDataName() { + return "materials"; + } + + @Override + public JsonElement generateDataJson() { + Registry itemRegistry = DGU.getWorld().getRegistryManager().get(RegistryKeys.ITEM); + + Map> materialMiningSpeeds = new LinkedHashMap<>(); + materialMiningSpeeds.put("default", ImmutableMap.of()); + + //Special materials used for shears and swords special mining speed logic + Map leavesMaterialSpeeds = new LinkedHashMap<>(); + Map cowebMaterialSpeeds = new LinkedHashMap<>(); + Map plantMaterialSpeeds = new LinkedHashMap<>(); + Map gourdMaterialSpeeds = new LinkedHashMap<>(); + + materialMiningSpeeds.put(makeMaterialNameForTag(BlockTags.LEAVES), leavesMaterialSpeeds); + materialMiningSpeeds.put("coweb", cowebMaterialSpeeds); + materialMiningSpeeds.put("plant", plantMaterialSpeeds); + materialMiningSpeeds.put("gourd", gourdMaterialSpeeds); + + //Shears need special handling because they do not follow normal rules like tools + leavesMaterialSpeeds.put(Items.SHEARS, 15.0f); + cowebMaterialSpeeds.put(Items.SHEARS, 15.0f); + materialMiningSpeeds.put("vine_or_glow_lichen", ImmutableMap.of(Items.SHEARS, 2.0f)); + materialMiningSpeeds.put("wool", ImmutableMap.of(Items.SHEARS, 5.0f)); + + itemRegistry.forEach(item -> { + //Tools are handled rather easily and do not require anything else + if (item instanceof MiningToolItem toolItem) { + item.getComponents().get(DataComponentTypes.TOOL).rules() + .stream().map(rule -> rule.blocks()) + .forEach(blocks -> { + Optional> tagKey = blocks.getTagKey(); + if (tagKey.isPresent()) { + String materialName = makeMaterialNameForTag(tagKey.get()); + + Map materialSpeeds = materialMiningSpeeds.computeIfAbsent(materialName, k -> new LinkedHashMap<>()); + float miningSpeed = item.getComponents().get(DataComponentTypes.TOOL).defaultMiningSpeed(); + materialSpeeds.put(item, miningSpeed); + } + } + ); + + //Swords require special treatment + if (item instanceof SwordItem) { + cowebMaterialSpeeds.put(item, 15.0f); + plantMaterialSpeeds.put(item, 1.5f); + leavesMaterialSpeeds.put(item, 1.5f); + gourdMaterialSpeeds.put(item, 1.5f); + } + }}); + + COMPOSITE_MATERIALS.forEach(values -> createCompositeMaterial(materialMiningSpeeds, values)); + + JsonObject resultObject = new JsonObject(); + + for (var entry : materialMiningSpeeds.entrySet()) { + JsonObject toolSpeedsObject = new JsonObject(); + + for (var toolEntry : entry.getValue().entrySet()) { + int rawItemId = itemRegistry.getRawId(toolEntry.getKey()); + toolSpeedsObject.addProperty(Integer.toString(rawItemId), toolEntry.getValue()); + } + resultObject.add(entry.getKey(), toolSpeedsObject); + } + + return resultObject; + } + + public static class MaterialInfo { + private final String materialName; + private final Predicate predicate; + private final List includedMaterials = new ArrayList<>(); + + public MaterialInfo(String materialName, Predicate predicate) { + this.materialName = materialName; + this.predicate = predicate; + } + + protected MaterialInfo includes(List otherMaterials) { + this.includedMaterials.addAll(otherMaterials); + return this; + } + + public String getMaterialName() { + return materialName; + } + + public Predicate getPredicate() { + return predicate; + } + + public boolean includesMaterial(MaterialInfo materialInfo) { + return includedMaterials.contains(materialInfo); + } + + @Override + public String toString() { + return materialName; + } + } +} diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/ParticlesDataGenerator.java b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/ParticlesDataGenerator.java new file mode 100644 index 00000000..bc5a9acc --- /dev/null +++ b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/ParticlesDataGenerator.java @@ -0,0 +1,33 @@ +package dev.u9g.minecraftdatagenerator.generators; + +import com.google.gson.JsonArray; +import com.google.gson.JsonObject; +import dev.u9g.minecraftdatagenerator.util.DGU; +import net.minecraft.particle.ParticleType; +import net.minecraft.registry.Registry; +import net.minecraft.registry.RegistryKeys; +import net.minecraft.util.Identifier; + +public class ParticlesDataGenerator implements IDataGenerator { + public static JsonObject generateParticleType(Registry> registry, ParticleType particleType) { + JsonObject effectDesc = new JsonObject(); + Identifier registryKey = registry.getKey(particleType).orElseThrow().getValue(); + + effectDesc.addProperty("id", registry.getRawId(particleType)); + effectDesc.addProperty("name", registryKey.getPath()); + return effectDesc; + } + + @Override + public String getDataName() { + return "particles"; + } + + @Override + public JsonArray generateDataJson() { + JsonArray resultsArray = new JsonArray(); + Registry> particleTypeRegistry = DGU.getWorld().getRegistryManager().get(RegistryKeys.PARTICLE_TYPE); + particleTypeRegistry.forEach(particleType -> resultsArray.add(generateParticleType(particleTypeRegistry, particleType))); + return resultsArray; + } +} diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/RecipeDataGenerator.java b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/RecipeDataGenerator.java new file mode 100644 index 00000000..ea489d11 --- /dev/null +++ b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/RecipeDataGenerator.java @@ -0,0 +1,128 @@ +package dev.u9g.minecraftdatagenerator.generators; + +import com.google.common.collect.ArrayListMultimap; +import com.google.common.collect.Multimap; +import com.google.gson.JsonArray; +import com.google.gson.JsonElement; +import com.google.gson.JsonObject; +import dev.u9g.minecraftdatagenerator.util.DGU; +import net.minecraft.item.Item; +import net.minecraft.recipe.*; +import net.minecraft.registry.DynamicRegistryManager; +import net.minecraft.registry.RegistryKeys; + +import java.util.ArrayList; +import java.util.List; +import java.util.Objects; + +public class RecipeDataGenerator implements IDataGenerator { + + private static int getRawIdFor(Item item) { + return DGU.getWorld().getRegistryManager().get(RegistryKeys.ITEM).getRawId(item); + } + + @Override + public String getDataName() { + return "recipes"; + } + + @Override + public JsonElement generateDataJson() { + DynamicRegistryManager registryManager = DGU.getWorld().getRegistryManager(); + JsonObject finalObj = new JsonObject(); + Multimap recipes = ArrayListMultimap.create(); + for (RecipeEntry recipeE : Objects.requireNonNull(DGU.getWorld()).getRecipeManager().values()) { + Recipe recipe = recipeE.value(); + if (recipe instanceof ShapedRecipe sr) { + var ingredients = sr.getIngredients(); + List 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 < sr.getHeight(); y++) { + var jsonRow = new JsonArray(); + for (int z = 0; z < sr.getWidth(); z++) { + jsonRow.add(iter.next()); + } + inShape.add(jsonRow); + } + + JsonObject finalRecipe = new JsonObject(); + finalRecipe.add("inShape", inShape); + + var resultObject = new JsonObject(); + resultObject.addProperty("id", getRawIdFor(sr.getResult(registryManager).getItem())); + resultObject.addProperty("count", sr.getResult(registryManager).getCount()); + finalRecipe.add("result", resultObject); + + String id = ((Integer) getRawIdFor(sr.getResult(registryManager).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.getResult(registryManager).getItem())); + resultObject.addProperty("count", sl.getResult(registryManager).getCount()); + rootRecipeObject.add("result", resultObject); + recipes.put(getRawIdFor(sl.getResult(registryManager).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; + } +} diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/TintsDataGenerator.java b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/TintsDataGenerator.java new file mode 100644 index 00000000..3773db5c --- /dev/null +++ b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/TintsDataGenerator.java @@ -0,0 +1,158 @@ +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.EmptyRenderBlockView; +import net.minecraft.block.Block; +import net.minecraft.block.Blocks; +import net.minecraft.block.RedstoneWireBlock; +import net.minecraft.client.color.block.BlockColors; +import net.minecraft.world.biome.FoliageColors; +import net.minecraft.registry.DynamicRegistryManager; +import net.minecraft.registry.Registry; +import net.minecraft.registry.RegistryKeys; +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(Registry biomeRegistry) { + BiomeTintColors colors = new BiomeTintColors(); + + biomeRegistry.forEach(biome -> { + int biomeGrassColor = biome.getGrassColorAt(0.0, 0.0); + int biomeFoliageColor = biome.getFoliageColor(); + int biomeWaterColor = biome.getWaterColor(); + + 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 generateRedstoneTintColors() { + Map resultColors = new LinkedHashMap<>(); + + for (int redstoneLevel : RedstoneWireBlock.POWER.getValues()) { + int color = RedstoneWireBlock.getWireColor(redstoneLevel); + resultColors.put(redstoneLevel, color); + } + return resultColors; + } + + private static int getBlockColor(Block block) { + return BlockColors.create().getColor(block.getDefaultState(), EmptyRenderBlockView.INSTANCE, BlockPos.ORIGIN, 0xFFFFFF); + } + + public static Map generateConstantTintColors() { + Map resultColors = new LinkedHashMap<>(); + + resultColors.put(Blocks.BIRCH_LEAVES, FoliageColors.getBirchColor()); + resultColors.put(Blocks.SPRUCE_LEAVES, FoliageColors.getSpruceColor()); + + resultColors.put(Blocks.LILY_PAD, getBlockColor(Blocks.LILY_PAD)); + resultColors.put(Blocks.ATTACHED_MELON_STEM, getBlockColor(Blocks.ATTACHED_MELON_STEM)); + resultColors.put(Blocks.ATTACHED_PUMPKIN_STEM, getBlockColor(Blocks.ATTACHED_PUMPKIN_STEM)); + + //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(Registry biomeRegistry, Map> colorsMap) { + JsonArray resultColorsArray = new JsonArray(); + for (var entry : colorsMap.entrySet()) { + JsonObject entryObject = new JsonObject(); + + JsonArray keysArray = new JsonArray(); + for (Biome biome : entry.getValue()) { + Identifier registryKey = biomeRegistry.getKey(biome).orElseThrow().getValue(); + keysArray.add(registryKey.getPath()); + } + + 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 colorsMap) { + JsonArray resultColorsArray = new JsonArray(); + for (var entry : colorsMap.entrySet()) { + JsonObject entryObject = new JsonObject(); + + JsonArray keysArray = new JsonArray(); + keysArray.add(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(Registry blockRegistry, Map colorsMap) { + JsonArray resultColorsArray = new JsonArray(); + for (var entry : colorsMap.entrySet()) { + JsonObject entryObject = new JsonObject(); + + JsonArray keysArray = new JsonArray(); + Identifier registryKey = blockRegistry.getKey(entry.getKey()).orElseThrow().getValue(); + keysArray.add(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() { + DynamicRegistryManager registryManager = DGU.getWorld().getRegistryManager(); + Registry biomeRegistry = registryManager.get(RegistryKeys.BIOME); + Registry blockRegistry = registryManager.get(RegistryKeys.BLOCK); + + BiomeTintColors biomeTintColors = generateBiomeTintColors(biomeRegistry); + Map redstoneColors = generateRedstoneTintColors(); + Map constantTintColors = generateConstantTintColors(); + + JsonObject resultObject = new JsonObject(); + + resultObject.add("grass", encodeBiomeColorMap(biomeRegistry, biomeTintColors.grassColoursMap)); + resultObject.add("foliage", encodeBiomeColorMap(biomeRegistry, biomeTintColors.foliageColoursMap)); + resultObject.add("water", encodeBiomeColorMap(biomeRegistry, biomeTintColors.waterColourMap)); + + resultObject.add("redstone", encodeRedstoneColorMap(redstoneColors)); + resultObject.add("constant", encodeBlocksColorMap(blockRegistry, constantTintColors)); + + return resultObject; + } + + public static class BiomeTintColors { + final Map> grassColoursMap = new LinkedHashMap<>(); + final Map> foliageColoursMap = new LinkedHashMap<>(); + final Map> waterColourMap = new LinkedHashMap<>(); + } +} diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/mixin/EULAMixin.java b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/mixin/EULAMixin.java new file mode 100644 index 00000000..0d297e7a --- /dev/null +++ b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/mixin/EULAMixin.java @@ -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 cir) { + cir.setReturnValue(true); + } +} diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/mixin/ReadyMixin.java b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/mixin/ReadyMixin.java new file mode 100644 index 00000000..498a06f6 --- /dev/null +++ b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/mixin/ReadyMixin.java @@ -0,0 +1,22 @@ +package dev.u9g.minecraftdatagenerator.mixin; + +import dev.u9g.minecraftdatagenerator.MinecraftDataGenerator; +import dev.u9g.minecraftdatagenerator.util.DGU; +import net.minecraft.MinecraftVersion; +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; + +@Mixin(MinecraftDedicatedServer.class) +public class ReadyMixin { + + @Inject(method = "setupServer()Z", at = @At("TAIL")) + private void init(CallbackInfoReturnable cir) { + MinecraftDataGenerator.start( + MinecraftVersion.CURRENT.getName(), + DGU.getCurrentlyRunningServer().getRunDirectory() + ); + } +} diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/util/DGU.java b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/util/DGU.java new file mode 100644 index 00000000..3946c1fe --- /dev/null +++ b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/util/DGU.java @@ -0,0 +1,21 @@ +package dev.u9g.minecraftdatagenerator.util; + +import net.fabricmc.loader.api.FabricLoader; +import net.minecraft.server.MinecraftServer; +import net.minecraft.util.Language; +import net.minecraft.world.World; + +public class DGU { + @SuppressWarnings("deprecation") + public static MinecraftServer getCurrentlyRunningServer() { + return (MinecraftServer) FabricLoader.getInstance().getGameInstance(); + } + + public static String translateText(String translationKey) { + return Language.getInstance().get(translationKey); + } + + public static World getWorld() { + return getCurrentlyRunningServer().getOverworld(); + } +} diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/util/EmptyRenderBlockView.java b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/util/EmptyRenderBlockView.java new file mode 100644 index 00000000..611aa5a4 --- /dev/null +++ b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/util/EmptyRenderBlockView.java @@ -0,0 +1,72 @@ +package dev.u9g.minecraftdatagenerator.util; + +import net.minecraft.block.BlockState; +import net.minecraft.block.Blocks; +import net.minecraft.block.entity.BlockEntity; +import net.minecraft.fluid.FluidState; +import net.minecraft.fluid.Fluids; +import net.minecraft.registry.Registry; +import net.minecraft.registry.RegistryKeys; +import net.minecraft.util.math.BlockPos; +import net.minecraft.util.math.Direction; +import net.minecraft.world.BlockRenderView; +import net.minecraft.world.LightType; +import net.minecraft.world.biome.Biome; +import net.minecraft.world.biome.BiomeKeys; +import net.minecraft.world.biome.ColorResolver; +import net.minecraft.world.chunk.light.LightingProvider; +import org.jetbrains.annotations.Nullable; + +public enum EmptyRenderBlockView implements BlockRenderView { + INSTANCE; + + @Nullable + public BlockEntity getBlockEntity(BlockPos pos) { + return null; + } + + public BlockState getBlockState(BlockPos pos) { + return Blocks.AIR.getDefaultState(); + } + + public FluidState getFluidState(BlockPos pos) { + return Fluids.EMPTY.getDefaultState(); + } + + public int getBottomY() { + return 0; + } + + public int getHeight() { + return 0; + } + + + @Override + public float getBrightness(Direction direction, boolean shaded) { + return 0.0f; + } + + @Override + public LightingProvider getLightingProvider() { + return null; + } + + @Override + public int getColor(BlockPos pos, ColorResolver colorResolver) { + Registry biomeRegistry = DGU.getWorld().getRegistryManager().getOptional(RegistryKeys.BIOME).get(); + Biome plainsBiome = biomeRegistry.get(BiomeKeys.PLAINS); + + return colorResolver.getColor(plainsBiome, pos.getX(), pos.getY()); + } + + @Override + public int getLightLevel(LightType type, BlockPos pos) { + return type == LightType.SKY ? getMaxLightLevel() : 0; + } + + @Override + public int getBaseLightLevel(BlockPos pos, int ambientDarkness) { + return ambientDarkness; + } +} diff --git a/1.21.3/src/main/resources/fabric.mod.json b/1.21.3/src/main/resources/fabric.mod.json new file mode 100644 index 00000000..ffac96b0 --- /dev/null +++ b/1.21.3/src/main/resources/fabric.mod.json @@ -0,0 +1,20 @@ +{ + "schemaVersion": 1, + "id": "minecraft-data-generator", + "version": "${version}", + "name": "Minecraft Data Generator", + "description": "", + "authors": [ + "Archengius", + "U9G" + ], + "contact": {}, + "license": "MIT", + "mixins": [ + "minecraft-data-generator.mixins.json" + ], + "depends": { + "fabricloader": "*", + "minecraft": "*" + } +} diff --git a/1.21.3/src/main/resources/minecraft-data-generator.mixins.json b/1.21.3/src/main/resources/minecraft-data-generator.mixins.json new file mode 100644 index 00000000..82185961 --- /dev/null +++ b/1.21.3/src/main/resources/minecraft-data-generator.mixins.json @@ -0,0 +1,15 @@ +{ + "required": true, + "minVersion": "0.8", + "package": "dev.u9g.minecraftdatagenerator.mixin", + "compatibilityLevel": "JAVA_17", + "mixins": [ + "EULAMixin", + "ReadyMixin" + ], + "client": [ + ], + "injectors": { + "defaultRequire": 1 + } +} diff --git a/settings.gradle b/settings.gradle index 62448b64..f5e1d22b 100644 --- a/settings.gradle +++ b/settings.gradle @@ -31,4 +31,6 @@ include "common" "1.20", "1.20.4", "1.20.5", + "1.21", + "1.21.3" ].forEach { include it } From f39a02f8225406e2ab16918f2f2de4a41fd3e69e Mon Sep 17 00:00:00 2001 From: SuperGamerTron Date: Sat, 26 Oct 2024 19:30:39 -0600 Subject: [PATCH 02/12] Update registry manager get() calls to getOrThrow() --- .../generators/BiomesDataGenerator.java | 2 +- .../generators/BlockCollisionShapesDataGenerator.java | 2 +- .../generators/BlocksDataGenerator.java | 2 +- .../generators/EffectsDataGenerator.java | 2 +- .../generators/EnchantmentsDataGenerator.java | 4 ++-- .../generators/EntitiesDataGenerator.java | 2 +- .../minecraftdatagenerator/generators/FoodsDataGenerator.java | 2 +- .../minecraftdatagenerator/generators/ItemsDataGenerator.java | 4 ++-- .../generators/MaterialsDataGenerator.java | 4 ++-- .../generators/ParticlesDataGenerator.java | 2 +- .../generators/RecipeDataGenerator.java | 2 +- .../minecraftdatagenerator/generators/TintsDataGenerator.java | 4 ++-- .../u9g/minecraftdatagenerator/util/EmptyRenderBlockView.java | 2 +- 13 files changed, 17 insertions(+), 17 deletions(-) diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/BiomesDataGenerator.java b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/BiomesDataGenerator.java index a35d00fd..2806a85b 100644 --- a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/BiomesDataGenerator.java +++ b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/BiomesDataGenerator.java @@ -105,7 +105,7 @@ public String getDataName() { public JsonArray generateDataJson() { JsonArray biomesArray = new JsonArray(); DynamicRegistryManager registryManager = DGU.getWorld().getRegistryManager(); - Registry biomeRegistry = registryManager.get(RegistryKeys.BIOME); + Registry biomeRegistry = registryManager.getOrThrow(RegistryKeys.BIOME); biomeRegistry.stream() .map(biome -> generateBiomeInfo(biomeRegistry, biome)) diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/BlockCollisionShapesDataGenerator.java b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/BlockCollisionShapesDataGenerator.java index 68a169cd..2c6c021f 100644 --- a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/BlockCollisionShapesDataGenerator.java +++ b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/BlockCollisionShapesDataGenerator.java @@ -25,7 +25,7 @@ public String getDataName() { @Override public JsonObject generateDataJson() { - Registry blockRegistry = DGU.getWorld().getRegistryManager().get(RegistryKeys.BLOCK); + Registry blockRegistry = DGU.getWorld().getRegistryManager().getOrThrow(RegistryKeys.BLOCK); BlockShapesCache blockShapesCache = new BlockShapesCache(); blockRegistry.forEach(blockShapesCache::processBlock); diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/BlocksDataGenerator.java b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/BlocksDataGenerator.java index 324b4d90..cd138603 100644 --- a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/BlocksDataGenerator.java +++ b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/BlocksDataGenerator.java @@ -38,7 +38,7 @@ public class BlocksDataGenerator implements IDataGenerator { private static final Logger logger = LoggerFactory.getLogger(BlocksDataGenerator.class); private static List getItemsEffectiveForBlock(BlockState blockState) { - return DGU.getWorld().getRegistryManager().get(RegistryKeys.ITEM).stream() + return DGU.getWorld().getRegistryManager().getOrThrow(RegistryKeys.ITEM).stream() .filter(item -> item.getDefaultStack().isSuitableFor(blockState)) .collect(Collectors.toList()); } diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/EffectsDataGenerator.java b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/EffectsDataGenerator.java index dd6dc019..8340c748 100644 --- a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/EffectsDataGenerator.java +++ b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/EffectsDataGenerator.java @@ -39,7 +39,7 @@ public String getDataName() { @Override public JsonArray generateDataJson() { JsonArray resultsArray = new JsonArray(); - Registry statusEffectRegistry = DGU.getWorld().getRegistryManager().get(RegistryKeys.STATUS_EFFECT); + Registry statusEffectRegistry = DGU.getWorld().getRegistryManager().getOrThrow(RegistryKeys.STATUS_EFFECT); statusEffectRegistry.forEach(effect -> resultsArray.add(generateEffect(statusEffectRegistry, effect))); return resultsArray; } diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/EnchantmentsDataGenerator.java b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/EnchantmentsDataGenerator.java index bf77d6fa..a3014224 100644 --- a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/EnchantmentsDataGenerator.java +++ b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/EnchantmentsDataGenerator.java @@ -25,7 +25,7 @@ public static String getEnchantmentTargetName(RegistryEntryList target) { private static boolean isEnchantmentInTag(Enchantment enchantment, String tag) { return DGU.getWorld() .getRegistryManager() - .get(RegistryKeys.ENCHANTMENT) + .getOrThrow(RegistryKeys.ENCHANTMENT) .streamTagsAndEntries() .filter(tagKeyNamedPair -> tagKeyNamedPair.getFirst().id().equals(Identifier.of(tag))) .flatMap(tagKeyNamedPair -> tagKeyNamedPair.getSecond().stream()) @@ -100,7 +100,7 @@ public String getDataName() { @Override public JsonArray generateDataJson() { JsonArray resultsArray = new JsonArray(); - Registry enchantmentRegistry = DGU.getWorld().getRegistryManager().get(RegistryKeys.ENCHANTMENT); + Registry enchantmentRegistry = DGU.getWorld().getRegistryManager().getOrThrow(RegistryKeys.ENCHANTMENT); enchantmentRegistry.stream() .forEach(enchantment -> resultsArray.add(generateEnchantment(enchantmentRegistry, enchantment))); return resultsArray; diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/EntitiesDataGenerator.java b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/EntitiesDataGenerator.java index 70a88040..cc006878 100644 --- a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/EntitiesDataGenerator.java +++ b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/EntitiesDataGenerator.java @@ -112,7 +112,7 @@ public String getDataName() { @Override public JsonArray generateDataJson() { JsonArray resultArray = new JsonArray(); - Registry> entityTypeRegistry = DGU.getWorld().getRegistryManager().get(RegistryKeys.ENTITY_TYPE); + Registry> entityTypeRegistry = DGU.getWorld().getRegistryManager().getOrThrow(RegistryKeys.ENTITY_TYPE); entityTypeRegistry.forEach(entity -> resultArray.add(generateEntity(entityTypeRegistry, entity))); return resultArray; } diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/FoodsDataGenerator.java b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/FoodsDataGenerator.java index ddb61fe9..9d2080f7 100644 --- a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/FoodsDataGenerator.java +++ b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/FoodsDataGenerator.java @@ -43,7 +43,7 @@ public String getDataName() { public JsonArray generateDataJson() { JsonArray resultsArray = new JsonArray(); - Registry itemRegistry = DGU.getWorld().getRegistryManager().get(RegistryKeys.ITEM); + Registry itemRegistry = DGU.getWorld().getRegistryManager().getOrThrow(RegistryKeys.ITEM); itemRegistry.stream() .filter(i -> i.getComponents().contains(DataComponentTypes.FOOD)) .forEach(food -> resultsArray.add(generateFoodDescriptor(itemRegistry, food))); diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/ItemsDataGenerator.java b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/ItemsDataGenerator.java index ddc4da05..ffaefeec 100644 --- a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/ItemsDataGenerator.java +++ b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/ItemsDataGenerator.java @@ -39,7 +39,7 @@ public static JsonObject generateItem(Registry itemRegistry, Item item) { itemDesc.addProperty("stackSize", item.getMaxCount()); JsonArray enchantCategoriesArray = new JsonArray(); - DGU.getWorld().getRegistryManager().get(RegistryKeys.ENCHANTMENT).stream() + DGU.getWorld().getRegistryManager().getOrThrow(RegistryKeys.ENCHANTMENT).stream() .map(Enchantment::getApplicableItems) .filter(applicableItems -> applicableItems.contains(itemRegistry.getEntry(item))) .map(EnchantmentsDataGenerator::getEnchantmentTargetName) @@ -76,7 +76,7 @@ public String getDataName() { @Override public JsonArray generateDataJson() { JsonArray resultArray = new JsonArray(); - Registry itemRegistry = DGU.getWorld().getRegistryManager().get(RegistryKeys.ITEM); + Registry itemRegistry = DGU.getWorld().getRegistryManager().getOrThrow(RegistryKeys.ITEM); itemRegistry.stream().forEach(item -> resultArray.add(generateItem(itemRegistry, item))); return resultArray; } diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/MaterialsDataGenerator.java b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/MaterialsDataGenerator.java index 46e42b47..5ad7dc48 100644 --- a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/MaterialsDataGenerator.java +++ b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/MaterialsDataGenerator.java @@ -81,7 +81,7 @@ public static List getGlobalMaterialInfo() { HashSet uniqueMaterialNames = new HashSet<>(); - Registry itemRegistry = DGU.getWorld().getRegistryManager().get(RegistryKeys.ITEM); + Registry itemRegistry = DGU.getWorld().getRegistryManager().getOrThrow(RegistryKeys.ITEM); itemRegistry.forEach(item -> { if (item instanceof MiningToolItem toolItem) { item.getComponents().get(DataComponentTypes.TOOL).rules() @@ -111,7 +111,7 @@ public String getDataName() { @Override public JsonElement generateDataJson() { - Registry itemRegistry = DGU.getWorld().getRegistryManager().get(RegistryKeys.ITEM); + Registry itemRegistry = DGU.getWorld().getRegistryManager().getOrThrow(RegistryKeys.ITEM); Map> materialMiningSpeeds = new LinkedHashMap<>(); materialMiningSpeeds.put("default", ImmutableMap.of()); diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/ParticlesDataGenerator.java b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/ParticlesDataGenerator.java index bc5a9acc..72177d3a 100644 --- a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/ParticlesDataGenerator.java +++ b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/ParticlesDataGenerator.java @@ -26,7 +26,7 @@ public String getDataName() { @Override public JsonArray generateDataJson() { JsonArray resultsArray = new JsonArray(); - Registry> particleTypeRegistry = DGU.getWorld().getRegistryManager().get(RegistryKeys.PARTICLE_TYPE); + Registry> particleTypeRegistry = DGU.getWorld().getRegistryManager().getOrThrow(RegistryKeys.PARTICLE_TYPE); particleTypeRegistry.forEach(particleType -> resultsArray.add(generateParticleType(particleTypeRegistry, particleType))); return resultsArray; } diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/RecipeDataGenerator.java b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/RecipeDataGenerator.java index ea489d11..0415fdcb 100644 --- a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/RecipeDataGenerator.java +++ b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/RecipeDataGenerator.java @@ -18,7 +18,7 @@ public class RecipeDataGenerator implements IDataGenerator { private static int getRawIdFor(Item item) { - return DGU.getWorld().getRegistryManager().get(RegistryKeys.ITEM).getRawId(item); + return DGU.getWorld().getRegistryManager().getOrThrow(RegistryKeys.ITEM).getRawId(item); } @Override diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/TintsDataGenerator.java b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/TintsDataGenerator.java index 3773db5c..62eadf10 100644 --- a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/TintsDataGenerator.java +++ b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/TintsDataGenerator.java @@ -131,8 +131,8 @@ public String getDataName() { @Override public JsonObject generateDataJson() { DynamicRegistryManager registryManager = DGU.getWorld().getRegistryManager(); - Registry biomeRegistry = registryManager.get(RegistryKeys.BIOME); - Registry blockRegistry = registryManager.get(RegistryKeys.BLOCK); + Registry biomeRegistry = registryManager.getOrThrow(RegistryKeys.BIOME); + Registry blockRegistry = registryManager.getOrThrow(RegistryKeys.BLOCK); BiomeTintColors biomeTintColors = generateBiomeTintColors(biomeRegistry); Map redstoneColors = generateRedstoneTintColors(); diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/util/EmptyRenderBlockView.java b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/util/EmptyRenderBlockView.java index 611aa5a4..72435a84 100644 --- a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/util/EmptyRenderBlockView.java +++ b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/util/EmptyRenderBlockView.java @@ -54,7 +54,7 @@ public LightingProvider getLightingProvider() { @Override public int getColor(BlockPos pos, ColorResolver colorResolver) { - Registry biomeRegistry = DGU.getWorld().getRegistryManager().getOptional(RegistryKeys.BIOME).get(); + Registry biomeRegistry = DGU.getWorld().getRegistryManager().getOrThrow(RegistryKeys.BIOME); Biome plainsBiome = biomeRegistry.get(BiomeKeys.PLAINS); return colorResolver.getColor(plainsBiome, pos.getX(), pos.getY()); From c3b24170ad0bda9793f4fcb57d56712843024cc6 Mon Sep 17 00:00:00 2001 From: SuperGamerTron Date: Sat, 26 Oct 2024 19:36:35 -0600 Subject: [PATCH 03/12] Update BlocksDataGenerator --- .../generators/BlocksDataGenerator.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/BlocksDataGenerator.java b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/BlocksDataGenerator.java index cd138603..5e260d0e 100644 --- a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/BlocksDataGenerator.java +++ b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/BlocksDataGenerator.java @@ -10,8 +10,8 @@ import net.minecraft.item.Item; import net.minecraft.item.ItemStack; import net.minecraft.item.Items; -import net.minecraft.loot.context.LootContextParameterSet; import net.minecraft.loot.context.LootContextParameters; +import net.minecraft.loot.context.LootWorldContext; import net.minecraft.registry.Registries; import net.minecraft.registry.RegistryKeys; import net.minecraft.server.MinecraftServer; @@ -48,7 +48,7 @@ private static void populateDropsIfPossible(BlockState blockState, Item firstToo if (minecraftServer != null) { //If we have local world context, we can actually evaluate loot tables and determine actual data ServerWorld serverWorld = minecraftServer.getOverworld(); - LootContextParameterSet.Builder lootContextParameterSet = new LootContextParameterSet.Builder(serverWorld) + LootWorldContext.Builder lootContextParameterSet = new LootWorldContext.Builder(serverWorld) .add(LootContextParameters.BLOCK_STATE, blockState) .add(LootContextParameters.ORIGIN, Vec3d.ZERO) .add(LootContextParameters.TOOL, firstToolItem.getDefaultStack()); @@ -145,7 +145,7 @@ public static JsonObject generateBlock(List blockDesc.addProperty("transparent", !defaultState.isOpaque()); blockDesc.addProperty("emitLight", defaultState.getLuminance()); - blockDesc.addProperty("filterLight", defaultState.getOpacity(EmptyBlockView.INSTANCE, BlockPos.ORIGIN)); + blockDesc.addProperty("filterLight", defaultState.getOpacity()); blockDesc.addProperty("defaultState", Block.getRawIdFromState(defaultState)); blockDesc.addProperty("minStateId", Block.getRawIdFromState(blockStates.getFirst())); From 57cc4af3d8184b8b5c9936e1c377d1e7bd814c8b Mon Sep 17 00:00:00 2001 From: SuperGamerTron Date: Sat, 26 Oct 2024 19:49:49 -0600 Subject: [PATCH 04/12] Update EnchantmentsDataGenerator --- .../generators/EnchantmentsDataGenerator.java | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/EnchantmentsDataGenerator.java b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/EnchantmentsDataGenerator.java index a3014224..44f2f5e3 100644 --- a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/EnchantmentsDataGenerator.java +++ b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/EnchantmentsDataGenerator.java @@ -14,7 +14,6 @@ import java.util.List; -import java.util.Set; public class EnchantmentsDataGenerator implements IDataGenerator { public static String getEnchantmentTargetName(RegistryEntryList target) { @@ -26,9 +25,8 @@ private static boolean isEnchantmentInTag(Enchantment enchantment, String tag) { return DGU.getWorld() .getRegistryManager() .getOrThrow(RegistryKeys.ENCHANTMENT) - .streamTagsAndEntries() - .filter(tagKeyNamedPair -> tagKeyNamedPair.getFirst().id().equals(Identifier.of(tag))) - .flatMap(tagKeyNamedPair -> tagKeyNamedPair.getSecond().stream()) + .getOrThrow(TagKey.of(RegistryKeys.ENCHANTMENT, Identifier.of(tag))) + .stream() .anyMatch(enchantmentRegistryEntry -> enchantmentRegistryEntry.value() == enchantment); } From e8c9e6359afe07c73b2661e34cbe8a7c346c53ca Mon Sep 17 00:00:00 2001 From: SuperGamerTron Date: Sat, 26 Oct 2024 19:54:22 -0600 Subject: [PATCH 05/12] Update EntitiesDataGenerator --- .../generators/EntitiesDataGenerator.java | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/EntitiesDataGenerator.java b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/EntitiesDataGenerator.java index cc006878..d2feea82 100644 --- a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/EntitiesDataGenerator.java +++ b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/EntitiesDataGenerator.java @@ -6,6 +6,7 @@ import net.minecraft.entity.Entity; import net.minecraft.entity.EntityType; import net.minecraft.entity.LivingEntity; +import net.minecraft.entity.SpawnReason; import net.minecraft.entity.mob.AmbientEntity; import net.minecraft.entity.mob.HostileEntity; import net.minecraft.entity.mob.MobEntity; @@ -36,7 +37,7 @@ public static JsonObject generateEntity(Registry> entityRegistry, MinecraftServer minecraftServer = DGU.getCurrentlyRunningServer(); if (minecraftServer != null) { - Entity entityObject = entityType.create(minecraftServer.getOverworld()); + Entity entityObject = entityType.create(minecraftServer.getOverworld(), SpawnReason.NATURAL); entityTypeString = entityObject != null ? getEntityTypeForClass(entityObject.getClass()) : "unknown"; } if (entityType == EntityType.PLAYER) { @@ -51,7 +52,7 @@ public static JsonObject generateEntity(Registry> entityRegistry, private static String getCategoryFrom(EntityType entityType) { if (entityType == EntityType.PLAYER) return "UNKNOWN"; - Entity entity = entityType.create(DGU.getWorld()); + Entity entity = entityType.create(DGU.getWorld(), SpawnReason.NATURAL); if (entity == null) throw new Error("Entity was null after trying to create a: " + DGU.translateText(entityType.getTranslationKey())); entity.discard(); From 1b9815692526824713ead3ba7e70d7eac70a5685 Mon Sep 17 00:00:00 2001 From: SuperGamerTron Date: Sat, 26 Oct 2024 19:58:54 -0600 Subject: [PATCH 06/12] Update ItemsDataGenerator --- .../minecraftdatagenerator/generators/ItemsDataGenerator.java | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/ItemsDataGenerator.java b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/ItemsDataGenerator.java index ffaefeec..15c2194a 100644 --- a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/ItemsDataGenerator.java +++ b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/ItemsDataGenerator.java @@ -22,12 +22,10 @@ public class ItemsDataGenerator implements IDataGenerator { private static List calculateItemsToRepairWith(Registry itemRegistry, Item sourceItem) { ItemStack sourceItemStack = sourceItem.getDefaultStack(); return itemRegistry.stream() - .filter(otherItem -> sourceItem.canRepair(sourceItemStack, otherItem.getDefaultStack())) + .filter(otherItem -> sourceItemStack.canRepairWith(otherItem.getDefaultStack())) .collect(Collectors.toList()); } - - public static JsonObject generateItem(Registry itemRegistry, Item item) { JsonObject itemDesc = new JsonObject(); Identifier registryKey = itemRegistry.getKey(item).orElseThrow().getValue(); From 45882298a43e28316c349d1f7aa2007907db0f12 Mon Sep 17 00:00:00 2001 From: SuperGamerTron Date: Sat, 26 Oct 2024 20:16:31 -0600 Subject: [PATCH 07/12] Update RecipeDataGenerator --- .../generators/RecipeDataGenerator.java | 33 ++++++++++--------- 1 file changed, 17 insertions(+), 16 deletions(-) diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/RecipeDataGenerator.java b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/RecipeDataGenerator.java index 0415fdcb..22cf3bd5 100644 --- a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/RecipeDataGenerator.java +++ b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/RecipeDataGenerator.java @@ -8,6 +8,7 @@ import dev.u9g.minecraftdatagenerator.util.DGU; import net.minecraft.item.Item; import net.minecraft.recipe.*; +import net.minecraft.recipe.input.CraftingRecipeInput; import net.minecraft.registry.DynamicRegistryManager; import net.minecraft.registry.RegistryKeys; @@ -31,22 +32,22 @@ public JsonElement generateDataJson() { DynamicRegistryManager registryManager = DGU.getWorld().getRegistryManager(); JsonObject finalObj = new JsonObject(); Multimap recipes = ArrayListMultimap.create(); - for (RecipeEntry recipeE : Objects.requireNonNull(DGU.getWorld()).getRecipeManager().values()) { + for (RecipeEntry recipeE : Objects.requireNonNull(DGU.getWorld().getServer()).getRecipeManager().values()) { Recipe recipe = recipeE.value(); if (recipe instanceof ShapedRecipe sr) { var ingredients = sr.getIngredients(); List ingr = new ArrayList<>(); for (int i = 0; i < 9; i++) { if (i >= ingredients.size()) { - ingr.add(-1); + ingr.add(null); continue; } - var stacks = ingredients.get(i); - var matching = stacks.getMatchingStacks(); - if (matching.length == 0) { - ingr.add(-1); + var stacks = ingredients.get(i).get(); + var matching = stacks.getMatchingItems(); + if (matching.isEmpty()) { + ingr.add(null); } else { - ingr.add(getRawIdFor(matching[0].getItem())); + ingr.add(getRawIdFor(matching.getFirst().value())); } } //Lists.reverse(ingr); @@ -67,11 +68,11 @@ public JsonElement generateDataJson() { finalRecipe.add("inShape", inShape); var resultObject = new JsonObject(); - resultObject.addProperty("id", getRawIdFor(sr.getResult(registryManager).getItem())); - resultObject.addProperty("count", sr.getResult(registryManager).getCount()); + resultObject.addProperty("id", getRawIdFor(sr.craft(CraftingRecipeInput.EMPTY, registryManager).getItem())); + resultObject.addProperty("count", sr.craft(CraftingRecipeInput.EMPTY, registryManager).getCount()); finalRecipe.add("result", resultObject); - String id = ((Integer) getRawIdFor(sr.getResult(registryManager).getItem())).toString(); + String id = ((Integer) getRawIdFor(sr.craft(CraftingRecipeInput.EMPTY, registryManager).getItem())).toString(); if (!finalObj.has(id)) { finalObj.add(id, new JsonArray()); @@ -104,17 +105,17 @@ public JsonElement generateDataJson() { // 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())); + for (Ingredient ingredient : sl.getIngredientPlacement().getIngredients()) { + if (ingredient.getMatchingItems().isEmpty()) continue; + ingredients.add(getRawIdFor(ingredient.getMatchingItems().getFirst().value())); } var rootRecipeObject = new JsonObject(); rootRecipeObject.add("ingredients", ingredients); var resultObject = new JsonObject(); - resultObject.addProperty("id", getRawIdFor(sl.getResult(registryManager).getItem())); - resultObject.addProperty("count", sl.getResult(registryManager).getCount()); + resultObject.addProperty("id", getRawIdFor(sl.craft(CraftingRecipeInput.EMPTY, registryManager).getItem())); + resultObject.addProperty("count", sl.craft(CraftingRecipeInput.EMPTY, registryManager).getCount()); rootRecipeObject.add("result", resultObject); - recipes.put(getRawIdFor(sl.getResult(registryManager).getItem()), rootRecipeObject); + recipes.put(getRawIdFor(sl.craft(CraftingRecipeInput.EMPTY, registryManager).getItem()), rootRecipeObject); } } recipes.forEach((a, b) -> { From a186db6f410dbf943fe5e98838ae1bdc73313902 Mon Sep 17 00:00:00 2001 From: SuperGamerTron Date: Sat, 26 Oct 2024 20:20:29 -0600 Subject: [PATCH 08/12] Update EmptyRenderBlockView --- .../u9g/minecraftdatagenerator/util/EmptyRenderBlockView.java | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/util/EmptyRenderBlockView.java b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/util/EmptyRenderBlockView.java index 72435a84..b67c8b9f 100644 --- a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/util/EmptyRenderBlockView.java +++ b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/util/EmptyRenderBlockView.java @@ -41,7 +41,6 @@ public int getHeight() { return 0; } - @Override public float getBrightness(Direction direction, boolean shaded) { return 0.0f; @@ -62,7 +61,7 @@ public int getColor(BlockPos pos, ColorResolver colorResolver) { @Override public int getLightLevel(LightType type, BlockPos pos) { - return type == LightType.SKY ? getMaxLightLevel() : 0; + return type == LightType.SKY ? 15 : 0; } @Override From 97475b715a3c1774b52cdc57913fcad6312a0280 Mon Sep 17 00:00:00 2001 From: GroobleDierne Date: Sun, 27 Oct 2024 17:05:17 +0100 Subject: [PATCH 09/12] Fix Recipe Generator & add Sound Generator --- .../generators/RecipeDataGenerator.java | 130 ++++++++---------- .../generators/SoundsDataGenerator.java | 29 ++++ 2 files changed, 90 insertions(+), 69 deletions(-) create mode 100644 1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/SoundsDataGenerator.java diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/RecipeDataGenerator.java b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/RecipeDataGenerator.java index 22cf3bd5..a1b14ada 100644 --- a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/RecipeDataGenerator.java +++ b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/RecipeDataGenerator.java @@ -8,8 +8,11 @@ import dev.u9g.minecraftdatagenerator.util.DGU; import net.minecraft.item.Item; import net.minecraft.recipe.*; +import net.minecraft.recipe.book.RecipeCategory; import net.minecraft.recipe.input.CraftingRecipeInput; import net.minecraft.registry.DynamicRegistryManager; +import net.minecraft.registry.Registries; +import net.minecraft.registry.Registry; import net.minecraft.registry.RegistryKeys; import java.util.ArrayList; @@ -32,77 +35,10 @@ public JsonElement generateDataJson() { DynamicRegistryManager registryManager = DGU.getWorld().getRegistryManager(); JsonObject finalObj = new JsonObject(); Multimap recipes = ArrayListMultimap.create(); - for (RecipeEntry recipeE : Objects.requireNonNull(DGU.getWorld().getServer()).getRecipeManager().values()) { + for (RecipeEntry recipeE : Objects.requireNonNull(DGU.getWorld()).getServer().getRecipeManager().values()) { Recipe recipe = recipeE.value(); if (recipe instanceof ShapedRecipe sr) { - var ingredients = sr.getIngredients(); - List ingr = new ArrayList<>(); - for (int i = 0; i < 9; i++) { - if (i >= ingredients.size()) { - ingr.add(null); - continue; - } - var stacks = ingredients.get(i).get(); - var matching = stacks.getMatchingItems(); - if (matching.isEmpty()) { - ingr.add(null); - } else { - ingr.add(getRawIdFor(matching.getFirst().value())); - } - } - //Lists.reverse(ingr); - - JsonArray inShape = new JsonArray(); - - - var iter = ingr.iterator(); - for (int y = 0; y < sr.getHeight(); y++) { - var jsonRow = new JsonArray(); - for (int z = 0; z < sr.getWidth(); z++) { - jsonRow.add(iter.next()); - } - inShape.add(jsonRow); - } - - JsonObject finalRecipe = new JsonObject(); - finalRecipe.add("inShape", inShape); - - var resultObject = new JsonObject(); - resultObject.addProperty("id", getRawIdFor(sr.craft(CraftingRecipeInput.EMPTY, registryManager).getItem())); - resultObject.addProperty("count", sr.craft(CraftingRecipeInput.EMPTY, registryManager).getCount()); - finalRecipe.add("result", resultObject); - - String id = ((Integer) getRawIdFor(sr.craft(CraftingRecipeInput.EMPTY, registryManager).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); + generateShapedRecipe(registryManager, finalObj, sr, 0); } else if (recipe instanceof ShapelessRecipe sl) { var ingredients = new JsonArray(); for (Ingredient ingredient : sl.getIngredientPlacement().getIngredients()) { @@ -126,4 +62,60 @@ public JsonElement generateDataJson() { }); return finalObj; } + + private void generateShapedRecipe(DynamicRegistryManager registryManager, JsonObject finalObj, ShapedRecipe sr, int n) { + boolean hasIncremented = false; + var ingredients = sr.getIngredients(); + List ingr = new ArrayList<>(); + for (int i = 0; i < 9; i++) { + if (i >= ingredients.size()) { + ingr.add(null); + continue; + } + var stacks = ingredients.get(i); + if (stacks.isEmpty()) { + ingr.add(null); + continue; + } + var matching = stacks.get().getMatchingItems(); // FIXME: fix when there are more than one matching stack + if (matching.isEmpty()) { + ingr.add(null); + continue; + } else if (matching.size() > n){ + ingr.add(getRawIdFor(matching.get(n).value())); + } else { + ingr.add(getRawIdFor(matching.getFirst().value())); + } + if (matching.size()-1 > n && !hasIncremented) { + generateShapedRecipe(registryManager, finalObj, sr, n+1); + hasIncremented = true; + } + } + + JsonArray inShape = new JsonArray(); + + var iter = ingr.iterator(); + for (int y = 0; y < sr.getHeight(); y++) { + var jsonRow = new JsonArray(); + for (int z = 0; z < sr.getWidth(); z++) { + jsonRow.add(iter.next()); + } + inShape.add(jsonRow); + } + + JsonObject finalRecipe = new JsonObject(); + finalRecipe.add("inShape", inShape); + + var resultObject = new JsonObject(); + resultObject.addProperty("id", getRawIdFor(sr.craft(CraftingRecipeInput.EMPTY, registryManager).getItem())); + resultObject.addProperty("count", sr.craft(CraftingRecipeInput.EMPTY, registryManager).getCount()); + finalRecipe.add("result", resultObject); + + String id = ((Integer) getRawIdFor(sr.craft(CraftingRecipeInput.EMPTY, registryManager).getItem())).toString(); + + if (!finalObj.has(id)) { + finalObj.add(id, new JsonArray()); + } + finalObj.get(id).getAsJsonArray().add(finalRecipe); + } } diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/SoundsDataGenerator.java b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/SoundsDataGenerator.java new file mode 100644 index 00000000..eb069674 --- /dev/null +++ b/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/SoundsDataGenerator.java @@ -0,0 +1,29 @@ +package dev.u9g.minecraftdatagenerator.generators; + +import com.google.gson.JsonArray; +import com.google.gson.JsonObject; +import net.minecraft.registry.Registries; +import net.minecraft.sound.SoundEvent; + +public class SoundsDataGenerator implements IDataGenerator { + public static JsonObject generateSound(SoundEvent soundEvent) { + JsonObject soundDesc = new JsonObject(); + + soundDesc.addProperty("id", Registries.SOUND_EVENT.getRawId(soundEvent) + 1); // the plus 1 is required for 1.19.2+ due to Mojang using 0 in the packet to say that you should read a string id instead. + soundDesc.addProperty("name", soundEvent.id().getPath()); + + return soundDesc; + } + + @Override + public String getDataName() { + return "sounds"; + } + + @Override + public JsonArray generateDataJson() { + JsonArray resultsArray = new JsonArray(); + Registries.SOUND_EVENT.forEach(sound -> resultsArray.add(generateSound(sound))); + return resultsArray; + } +} From afb87486dca33dd637824a459e40db32ebc7ab18 Mon Sep 17 00:00:00 2001 From: AlexProgrammerDE <40795980+AlexProgrammerDE@users.noreply.github.com> Date: Sun, 27 Oct 2024 19:49:59 +0100 Subject: [PATCH 10/12] Move to proper directory --- {1.21.3 => mc/1.21.3}/build.gradle | 0 .../minecraftdatagenerator/generators/BiomesDataGenerator.java | 0 .../generators/BlockCollisionShapesDataGenerator.java | 0 .../minecraftdatagenerator/generators/BlocksDataGenerator.java | 0 .../minecraftdatagenerator/generators/EffectsDataGenerator.java | 0 .../generators/EnchantmentsDataGenerator.java | 0 .../minecraftdatagenerator/generators/EntitiesDataGenerator.java | 0 .../u9g/minecraftdatagenerator/generators/FoodsDataGenerator.java | 0 .../generators/InstrumentsDataGenerator.java | 0 .../u9g/minecraftdatagenerator/generators/ItemsDataGenerator.java | 0 .../minecraftdatagenerator/generators/LanguageDataGenerator.java | 0 .../minecraftdatagenerator/generators/MaterialsDataGenerator.java | 0 .../minecraftdatagenerator/generators/ParticlesDataGenerator.java | 0 .../minecraftdatagenerator/generators/RecipeDataGenerator.java | 0 .../minecraftdatagenerator/generators/SoundsDataGenerator.java | 0 .../u9g/minecraftdatagenerator/generators/TintsDataGenerator.java | 0 .../main/java/dev/u9g/minecraftdatagenerator/mixin/EULAMixin.java | 0 .../java/dev/u9g/minecraftdatagenerator/mixin/ReadyMixin.java | 0 .../src/main/java/dev/u9g/minecraftdatagenerator/util/DGU.java | 0 .../dev/u9g/minecraftdatagenerator/util/EmptyRenderBlockView.java | 0 {1.21.3 => mc/1.21.3}/src/main/resources/fabric.mod.json | 0 .../src/main/resources/minecraft-data-generator.mixins.json | 0 22 files changed, 0 insertions(+), 0 deletions(-) rename {1.21.3 => mc/1.21.3}/build.gradle (100%) rename {1.21.3 => mc/1.21.3}/src/main/java/dev/u9g/minecraftdatagenerator/generators/BiomesDataGenerator.java (100%) rename {1.21.3 => mc/1.21.3}/src/main/java/dev/u9g/minecraftdatagenerator/generators/BlockCollisionShapesDataGenerator.java (100%) rename {1.21.3 => mc/1.21.3}/src/main/java/dev/u9g/minecraftdatagenerator/generators/BlocksDataGenerator.java (100%) rename {1.21.3 => mc/1.21.3}/src/main/java/dev/u9g/minecraftdatagenerator/generators/EffectsDataGenerator.java (100%) rename {1.21.3 => mc/1.21.3}/src/main/java/dev/u9g/minecraftdatagenerator/generators/EnchantmentsDataGenerator.java (100%) rename {1.21.3 => mc/1.21.3}/src/main/java/dev/u9g/minecraftdatagenerator/generators/EntitiesDataGenerator.java (100%) rename {1.21.3 => mc/1.21.3}/src/main/java/dev/u9g/minecraftdatagenerator/generators/FoodsDataGenerator.java (100%) rename {1.21.3 => mc/1.21.3}/src/main/java/dev/u9g/minecraftdatagenerator/generators/InstrumentsDataGenerator.java (100%) rename {1.21.3 => mc/1.21.3}/src/main/java/dev/u9g/minecraftdatagenerator/generators/ItemsDataGenerator.java (100%) rename {1.21.3 => mc/1.21.3}/src/main/java/dev/u9g/minecraftdatagenerator/generators/LanguageDataGenerator.java (100%) rename {1.21.3 => mc/1.21.3}/src/main/java/dev/u9g/minecraftdatagenerator/generators/MaterialsDataGenerator.java (100%) rename {1.21.3 => mc/1.21.3}/src/main/java/dev/u9g/minecraftdatagenerator/generators/ParticlesDataGenerator.java (100%) rename {1.21.3 => mc/1.21.3}/src/main/java/dev/u9g/minecraftdatagenerator/generators/RecipeDataGenerator.java (100%) rename {1.21.3 => mc/1.21.3}/src/main/java/dev/u9g/minecraftdatagenerator/generators/SoundsDataGenerator.java (100%) rename {1.21.3 => mc/1.21.3}/src/main/java/dev/u9g/minecraftdatagenerator/generators/TintsDataGenerator.java (100%) rename {1.21.3 => mc/1.21.3}/src/main/java/dev/u9g/minecraftdatagenerator/mixin/EULAMixin.java (100%) rename {1.21.3 => mc/1.21.3}/src/main/java/dev/u9g/minecraftdatagenerator/mixin/ReadyMixin.java (100%) rename {1.21.3 => mc/1.21.3}/src/main/java/dev/u9g/minecraftdatagenerator/util/DGU.java (100%) rename {1.21.3 => mc/1.21.3}/src/main/java/dev/u9g/minecraftdatagenerator/util/EmptyRenderBlockView.java (100%) rename {1.21.3 => mc/1.21.3}/src/main/resources/fabric.mod.json (100%) rename {1.21.3 => mc/1.21.3}/src/main/resources/minecraft-data-generator.mixins.json (100%) diff --git a/1.21.3/build.gradle b/mc/1.21.3/build.gradle similarity index 100% rename from 1.21.3/build.gradle rename to mc/1.21.3/build.gradle diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/BiomesDataGenerator.java b/mc/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/BiomesDataGenerator.java similarity index 100% rename from 1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/BiomesDataGenerator.java rename to mc/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/BiomesDataGenerator.java diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/BlockCollisionShapesDataGenerator.java b/mc/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/BlockCollisionShapesDataGenerator.java similarity index 100% rename from 1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/BlockCollisionShapesDataGenerator.java rename to mc/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/BlockCollisionShapesDataGenerator.java diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/BlocksDataGenerator.java b/mc/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/BlocksDataGenerator.java similarity index 100% rename from 1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/BlocksDataGenerator.java rename to mc/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/BlocksDataGenerator.java diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/EffectsDataGenerator.java b/mc/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/EffectsDataGenerator.java similarity index 100% rename from 1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/EffectsDataGenerator.java rename to mc/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/EffectsDataGenerator.java diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/EnchantmentsDataGenerator.java b/mc/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/EnchantmentsDataGenerator.java similarity index 100% rename from 1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/EnchantmentsDataGenerator.java rename to mc/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/EnchantmentsDataGenerator.java diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/EntitiesDataGenerator.java b/mc/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/EntitiesDataGenerator.java similarity index 100% rename from 1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/EntitiesDataGenerator.java rename to mc/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/EntitiesDataGenerator.java diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/FoodsDataGenerator.java b/mc/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/FoodsDataGenerator.java similarity index 100% rename from 1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/FoodsDataGenerator.java rename to mc/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/FoodsDataGenerator.java diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/InstrumentsDataGenerator.java b/mc/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/InstrumentsDataGenerator.java similarity index 100% rename from 1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/InstrumentsDataGenerator.java rename to mc/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/InstrumentsDataGenerator.java diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/ItemsDataGenerator.java b/mc/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/ItemsDataGenerator.java similarity index 100% rename from 1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/ItemsDataGenerator.java rename to mc/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/ItemsDataGenerator.java diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/LanguageDataGenerator.java b/mc/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/LanguageDataGenerator.java similarity index 100% rename from 1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/LanguageDataGenerator.java rename to mc/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/LanguageDataGenerator.java diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/MaterialsDataGenerator.java b/mc/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/MaterialsDataGenerator.java similarity index 100% rename from 1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/MaterialsDataGenerator.java rename to mc/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/MaterialsDataGenerator.java diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/ParticlesDataGenerator.java b/mc/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/ParticlesDataGenerator.java similarity index 100% rename from 1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/ParticlesDataGenerator.java rename to mc/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/ParticlesDataGenerator.java diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/RecipeDataGenerator.java b/mc/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/RecipeDataGenerator.java similarity index 100% rename from 1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/RecipeDataGenerator.java rename to mc/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/RecipeDataGenerator.java diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/SoundsDataGenerator.java b/mc/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/SoundsDataGenerator.java similarity index 100% rename from 1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/SoundsDataGenerator.java rename to mc/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/SoundsDataGenerator.java diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/TintsDataGenerator.java b/mc/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/TintsDataGenerator.java similarity index 100% rename from 1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/TintsDataGenerator.java rename to mc/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/generators/TintsDataGenerator.java diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/mixin/EULAMixin.java b/mc/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/mixin/EULAMixin.java similarity index 100% rename from 1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/mixin/EULAMixin.java rename to mc/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/mixin/EULAMixin.java diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/mixin/ReadyMixin.java b/mc/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/mixin/ReadyMixin.java similarity index 100% rename from 1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/mixin/ReadyMixin.java rename to mc/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/mixin/ReadyMixin.java diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/util/DGU.java b/mc/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/util/DGU.java similarity index 100% rename from 1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/util/DGU.java rename to mc/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/util/DGU.java diff --git a/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/util/EmptyRenderBlockView.java b/mc/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/util/EmptyRenderBlockView.java similarity index 100% rename from 1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/util/EmptyRenderBlockView.java rename to mc/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/util/EmptyRenderBlockView.java diff --git a/1.21.3/src/main/resources/fabric.mod.json b/mc/1.21.3/src/main/resources/fabric.mod.json similarity index 100% rename from 1.21.3/src/main/resources/fabric.mod.json rename to mc/1.21.3/src/main/resources/fabric.mod.json diff --git a/1.21.3/src/main/resources/minecraft-data-generator.mixins.json b/mc/1.21.3/src/main/resources/minecraft-data-generator.mixins.json similarity index 100% rename from 1.21.3/src/main/resources/minecraft-data-generator.mixins.json rename to mc/1.21.3/src/main/resources/minecraft-data-generator.mixins.json From 3d203d6651ff4857fa1869149100eabc9bade477 Mon Sep 17 00:00:00 2001 From: AlexProgrammerDE <40795980+AlexProgrammerDE@users.noreply.github.com> Date: Sun, 27 Oct 2024 19:51:50 +0100 Subject: [PATCH 11/12] Remove extra spaces --- .github/workflows/build.yml | 1 - settings.gradle | 2 -- 2 files changed, 3 deletions(-) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 1ca76d60..a277bd79 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -36,7 +36,6 @@ jobs: matrix: version: ${{ fromJSON(needs.define-versions.outputs.versions) }} - name: Build ${{ matrix.version }} timeout-minutes: 10 diff --git a/settings.gradle b/settings.gradle index f5fbfc99..db560d6e 100644 --- a/settings.gradle +++ b/settings.gradle @@ -12,6 +12,4 @@ dependencyResolutionManagement { include "common" - new File(rootProject.projectDir, "mc").list().toList().forEach { include ":mc:$it" } - From 5e8ec69236aec3b94a8a33cbddf9531637d99682 Mon Sep 17 00:00:00 2001 From: AlexProgrammerDE <40795980+AlexProgrammerDE@users.noreply.github.com> Date: Sun, 27 Oct 2024 19:54:35 +0100 Subject: [PATCH 12/12] Enable all features --- .../mixin/DataPackSettingsMixin.java | 36 +++++++++++++++++++ .../minecraft-data-generator.mixins.json | 1 + .../mixin/DataPackSettingsMixin.java | 36 +++++++++++++++++++ .../minecraft-data-generator.mixins.json | 1 + 4 files changed, 74 insertions(+) create mode 100644 mc/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/mixin/DataPackSettingsMixin.java create mode 100644 mc/1.21/src/main/java/dev/u9g/minecraftdatagenerator/mixin/DataPackSettingsMixin.java diff --git a/mc/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/mixin/DataPackSettingsMixin.java b/mc/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/mixin/DataPackSettingsMixin.java new file mode 100644 index 00000000..39fd760d --- /dev/null +++ b/mc/1.21.3/src/main/java/dev/u9g/minecraftdatagenerator/mixin/DataPackSettingsMixin.java @@ -0,0 +1,36 @@ +/* + * SoulFire + * Copyright (C) 2024 AlexProgrammerDE + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +package dev.u9g.minecraftdatagenerator.mixin; + +import net.minecraft.resource.DataPackSettings; +import net.minecraft.resource.featuretoggle.FeatureFlags; +import net.minecraft.util.Identifier; +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.util.List; + +@Mixin(DataPackSettings.class) +public class DataPackSettingsMixin { + @Inject(method = "getEnabled", at = @At("HEAD"), cancellable = true) + public void getEnabled(CallbackInfoReturnable> cir) { + cir.setReturnValue(FeatureFlags.FEATURE_MANAGER.toId(FeatureFlags.FEATURE_MANAGER.getFeatureSet()).stream().map(Identifier::getPath).toList()); + } +} diff --git a/mc/1.21.3/src/main/resources/minecraft-data-generator.mixins.json b/mc/1.21.3/src/main/resources/minecraft-data-generator.mixins.json index 82185961..ed926d16 100644 --- a/mc/1.21.3/src/main/resources/minecraft-data-generator.mixins.json +++ b/mc/1.21.3/src/main/resources/minecraft-data-generator.mixins.json @@ -4,6 +4,7 @@ "package": "dev.u9g.minecraftdatagenerator.mixin", "compatibilityLevel": "JAVA_17", "mixins": [ + "DataPackSettingsMixin", "EULAMixin", "ReadyMixin" ], diff --git a/mc/1.21/src/main/java/dev/u9g/minecraftdatagenerator/mixin/DataPackSettingsMixin.java b/mc/1.21/src/main/java/dev/u9g/minecraftdatagenerator/mixin/DataPackSettingsMixin.java new file mode 100644 index 00000000..39fd760d --- /dev/null +++ b/mc/1.21/src/main/java/dev/u9g/minecraftdatagenerator/mixin/DataPackSettingsMixin.java @@ -0,0 +1,36 @@ +/* + * SoulFire + * Copyright (C) 2024 AlexProgrammerDE + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +package dev.u9g.minecraftdatagenerator.mixin; + +import net.minecraft.resource.DataPackSettings; +import net.minecraft.resource.featuretoggle.FeatureFlags; +import net.minecraft.util.Identifier; +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.util.List; + +@Mixin(DataPackSettings.class) +public class DataPackSettingsMixin { + @Inject(method = "getEnabled", at = @At("HEAD"), cancellable = true) + public void getEnabled(CallbackInfoReturnable> cir) { + cir.setReturnValue(FeatureFlags.FEATURE_MANAGER.toId(FeatureFlags.FEATURE_MANAGER.getFeatureSet()).stream().map(Identifier::getPath).toList()); + } +} diff --git a/mc/1.21/src/main/resources/minecraft-data-generator.mixins.json b/mc/1.21/src/main/resources/minecraft-data-generator.mixins.json index 82185961..ed926d16 100644 --- a/mc/1.21/src/main/resources/minecraft-data-generator.mixins.json +++ b/mc/1.21/src/main/resources/minecraft-data-generator.mixins.json @@ -4,6 +4,7 @@ "package": "dev.u9g.minecraftdatagenerator.mixin", "compatibilityLevel": "JAVA_17", "mixins": [ + "DataPackSettingsMixin", "EULAMixin", "ReadyMixin" ],