Make definition of ci and projects dynamic (#33)
* Make definition of ci and projects dynamic * Try defining matrix properly * Working impl * Fix target task * Fix path
This commit is contained in:
Alex
@@ -0,0 +1,53 @@
|
||||
import xyz.wagyourtail.unimined.api.minecraft.task.RemapJarTask
|
||||
import xyz.wagyourtail.unimined.internal.minecraft.MinecraftProvider
|
||||
|
||||
plugins {
|
||||
id 'xyz.wagyourtail.unimined'
|
||||
}
|
||||
|
||||
unimined.minecraft {
|
||||
version "1.15"
|
||||
|
||||
mappings {
|
||||
intermediary()
|
||||
yarn(2)
|
||||
|
||||
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"
|
||||
}
|
||||
|
||||
java {
|
||||
toolchain {
|
||||
languageVersion.set(JavaLanguageVersion.of(21))
|
||||
}
|
||||
}
|
||||
+32
@@ -0,0 +1,32 @@
|
||||
package dev.u9g.minecraftdatagenerator.generators;
|
||||
|
||||
import com.google.gson.JsonArray;
|
||||
import com.google.gson.JsonElement;
|
||||
import com.google.gson.JsonObject;
|
||||
import dev.u9g.minecraftdatagenerator.mixin.LanguageAccessor;
|
||||
import net.minecraft.util.Language;
|
||||
|
||||
import java.util.Map;
|
||||
|
||||
public class AttributesDataGenerator implements IDataGenerator {
|
||||
@Override
|
||||
public String getDataName() {
|
||||
return "attributes";
|
||||
}
|
||||
|
||||
@Override
|
||||
public JsonElement generateDataJson() {
|
||||
Map<String, String> translations = ((LanguageAccessor) new Language()).translations();
|
||||
JsonArray arr = new JsonArray();
|
||||
for (Map.Entry<String, String> translation : translations.entrySet()) {
|
||||
String key = translation.getKey();
|
||||
if (!key.startsWith("attribute.name.")) continue;
|
||||
JsonObject obj = new JsonObject();
|
||||
key = key.replace("attribute.name.", "");
|
||||
obj.addProperty("name", key.split("\\.")[1]);
|
||||
obj.addProperty("resource", key);
|
||||
arr.add(obj);
|
||||
}
|
||||
return arr;
|
||||
}
|
||||
}
|
||||
+56
@@ -0,0 +1,56 @@
|
||||
package dev.u9g.minecraftdatagenerator.generators;
|
||||
|
||||
import com.google.gson.JsonArray;
|
||||
import com.google.gson.JsonObject;
|
||||
import dev.u9g.minecraftdatagenerator.util.DGU;
|
||||
import net.minecraft.util.Identifier;
|
||||
import net.minecraft.util.registry.Registry;
|
||||
import net.minecraft.world.biome.Biome;
|
||||
|
||||
import java.util.Objects;
|
||||
|
||||
public class BiomesDataGenerator implements IDataGenerator {
|
||||
|
||||
private static String guessBiomeDimensionFromCategory(Biome biome) {
|
||||
return switch (biome.getCategory()) {
|
||||
case NETHER -> "nether";
|
||||
case THEEND -> "end";
|
||||
default -> "overworld";
|
||||
};
|
||||
}
|
||||
|
||||
public static JsonObject generateBiomeInfo(Registry<Biome> registry, Biome biome) {
|
||||
JsonObject biomeDesc = new JsonObject();
|
||||
Identifier registryKey = registry.getId(biome);
|
||||
String localizationKey = String.format("biome.%s.%s", Objects.requireNonNull(registryKey).getNamespace(), registryKey.getPath());
|
||||
biomeDesc.addProperty("id", registry.getRawId(biome));
|
||||
biomeDesc.addProperty("name", registryKey.getPath());
|
||||
|
||||
biomeDesc.addProperty("category", biome.getCategory().getName());
|
||||
biomeDesc.addProperty("temperature", biome.getTemperature());
|
||||
biomeDesc.addProperty("precipitation", biome.getPrecipitation().getName());
|
||||
biomeDesc.addProperty("depth", biome.getDepth());
|
||||
biomeDesc.addProperty("dimension", guessBiomeDimensionFromCategory(biome));
|
||||
biomeDesc.addProperty("displayName", DGU.translateText(localizationKey));
|
||||
biomeDesc.addProperty("color", biome.getSkyColor());
|
||||
biomeDesc.addProperty("rainfall", biome.getRainfall());
|
||||
|
||||
return biomeDesc;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getDataName() {
|
||||
return "biomes";
|
||||
}
|
||||
|
||||
@Override
|
||||
public JsonArray generateDataJson() {
|
||||
JsonArray biomesArray = new JsonArray();
|
||||
Registry<Biome> biomeRegistry = Registry.BIOME;
|
||||
|
||||
biomeRegistry.stream()
|
||||
.map(biome -> generateBiomeInfo(biomeRegistry, biome))
|
||||
.forEach(biomesArray::add);
|
||||
return biomesArray;
|
||||
}
|
||||
}
|
||||
+108
@@ -0,0 +1,108 @@
|
||||
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 net.minecraft.block.Block;
|
||||
import net.minecraft.block.BlockState;
|
||||
import net.minecraft.util.Identifier;
|
||||
import net.minecraft.util.math.BlockPos;
|
||||
import net.minecraft.util.registry.Registry;
|
||||
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<Block> blockRegistry = Registry.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<VoxelShape, Integer> uniqueBlockShapes = new LinkedHashMap<>();
|
||||
public final Map<Block, List<Integer>> blockCollisionShapes = new LinkedHashMap<>();
|
||||
private int lastCollisionShapeId = 0;
|
||||
|
||||
public void processBlock(Block block) {
|
||||
List<BlockState> blockStates = block.getStateManager().getStates();
|
||||
List<Integer> 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<Block> blockRegistry) {
|
||||
JsonObject resultObject = new JsonObject();
|
||||
|
||||
for (var entry : blockCollisionShapes.entrySet()) {
|
||||
List<Integer> 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.getId(entry.getKey());
|
||||
resultObject.add(Objects.requireNonNull(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;
|
||||
}
|
||||
}
|
||||
}
|
||||
+146
@@ -0,0 +1,146 @@
|
||||
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.mixin.MiningToolItemAccessor;
|
||||
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.MiningToolItem;
|
||||
import net.minecraft.loot.context.LootContext;
|
||||
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.registry.Registry;
|
||||
import net.minecraft.util.shape.VoxelShape;
|
||||
import net.minecraft.world.EmptyBlockView;
|
||||
|
||||
import java.util.Collection;
|
||||
import java.util.List;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
public class BlocksDataGenerator implements IDataGenerator {
|
||||
private static List<Item> getItemsEffectiveForBlock(Block block) {
|
||||
return Registry.ITEM.stream()
|
||||
.filter(item -> item instanceof MiningToolItem)
|
||||
.filter(item -> ((MiningToolItemAccessor) item).getEffectiveBlocks().contains(block))
|
||||
.collect(Collectors.toList());
|
||||
}
|
||||
|
||||
private static List<ItemStack> populateDropsIfPossible(BlockState blockState, Item firstToolItem) {
|
||||
//If we have local world context, we can actually evaluate loot tables and determine actual data
|
||||
ServerWorld serverWorld = (ServerWorld) DGU.getWorld();
|
||||
LootContext.Builder lootContext = new LootContext.Builder(serverWorld)
|
||||
.setRandom(0L);
|
||||
return blockState.getDroppedStacks(lootContext);
|
||||
}
|
||||
|
||||
private static String getPropertyTypeName(Property<?> property) {
|
||||
//Explicitly handle default minecraft properties
|
||||
if (property instanceof BooleanProperty) {
|
||||
return "bool";
|
||||
}
|
||||
if (property instanceof IntProperty) {
|
||||
return "int";
|
||||
}
|
||||
if (property instanceof EnumProperty) {
|
||||
return "enum";
|
||||
}
|
||||
|
||||
//Use simple class name as fallback, this code will give something like
|
||||
//example_type for ExampleTypeProperty class name
|
||||
String rawPropertyName = property.getClass().getSimpleName().replace("Property", "");
|
||||
return CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_UNDERSCORE, rawPropertyName);
|
||||
}
|
||||
|
||||
private static <T extends Comparable<T>> JsonObject generateStateProperty(Property<T> property) {
|
||||
JsonObject propertyObject = new JsonObject();
|
||||
Collection<T> propertyValues = property.getValues();
|
||||
|
||||
propertyObject.addProperty("name", property.getName());
|
||||
propertyObject.addProperty("type", getPropertyTypeName(property));
|
||||
propertyObject.addProperty("num_values", propertyValues.size());
|
||||
|
||||
//Do not add values for vanilla boolean properties, they are known by default
|
||||
if (!(property instanceof BooleanProperty)) {
|
||||
JsonArray propertyValuesArray = new JsonArray();
|
||||
for (T propertyValue : propertyValues) {
|
||||
propertyValuesArray.add(property.name(propertyValue));
|
||||
}
|
||||
propertyObject.add("values", propertyValuesArray);
|
||||
}
|
||||
return propertyObject;
|
||||
}
|
||||
|
||||
public static JsonObject generateBlock(Block block) {
|
||||
JsonObject blockDesc = new JsonObject();
|
||||
|
||||
List<BlockState> blockStates = block.getStateManager().getStates();
|
||||
BlockState defaultState = block.getDefaultState();
|
||||
Identifier registryKey = Registry.BLOCK.getId(block);
|
||||
String localizationKey = block.getTranslationKey();
|
||||
List<Item> effectiveTools = getItemsEffectiveForBlock(block);
|
||||
|
||||
blockDesc.addProperty("id", Registry.BLOCK.getRawId(block));
|
||||
blockDesc.addProperty("name", registryKey.getPath());
|
||||
blockDesc.addProperty("displayName", DGU.translateText(localizationKey));
|
||||
|
||||
float hardness = block.getDefaultState().getHardness(null, null);
|
||||
|
||||
blockDesc.addProperty("hardness", hardness);
|
||||
blockDesc.addProperty("resistance", block.getBlastResistance());
|
||||
blockDesc.addProperty("stackSize", block.asItem().getMaxCount());
|
||||
blockDesc.addProperty("diggable", hardness != -1.0f && !(block instanceof AirBlock));
|
||||
JsonObject effTools = new JsonObject();
|
||||
effectiveTools.forEach(item -> effTools.addProperty(
|
||||
String.valueOf(Registry.ITEM.getRawId(item)), // key
|
||||
item.getMiningSpeed(DGU.asStack(item), defaultState) // value
|
||||
));
|
||||
blockDesc.add("effectiveTools", effTools);
|
||||
|
||||
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);
|
||||
|
||||
// List<ItemStack> drops = populateDropsIfPossible(defaultState, effectiveTools.stream().findFirst().orElse(Items.AIR));
|
||||
|
||||
JsonArray dropsArray = new JsonArray();
|
||||
// drops.forEach(dropped -> dropsArray.add(Item.getRawId(dropped.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();
|
||||
|
||||
Registry.BLOCK.forEach(block -> resultBlocksArray.add(generateBlock(block)));
|
||||
return resultBlocksArray;
|
||||
}
|
||||
}
|
||||
+47
@@ -0,0 +1,47 @@
|
||||
package dev.u9g.minecraftdatagenerator.generators;
|
||||
|
||||
import com.google.gson.JsonArray;
|
||||
import com.google.gson.JsonObject;
|
||||
import dev.u9g.minecraftdatagenerator.mixin.StatusEffectAccessor;
|
||||
import dev.u9g.minecraftdatagenerator.util.DGU;
|
||||
import net.minecraft.entity.effect.StatusEffect;
|
||||
import net.minecraft.entity.effect.StatusEffectType;
|
||||
import net.minecraft.entity.effect.StatusEffects;
|
||||
import net.minecraft.util.Identifier;
|
||||
import net.minecraft.util.registry.Registry;
|
||||
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<StatusEffect> registry, StatusEffect statusEffect) {
|
||||
JsonObject effectDesc = new JsonObject();
|
||||
Identifier registryKey = registry.getId(statusEffect);
|
||||
|
||||
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", ((StatusEffectAccessor) statusEffect).type() == StatusEffectType.BENEFICIAL ? "good" : "bad");
|
||||
return effectDesc;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getDataName() {
|
||||
return "effects";
|
||||
}
|
||||
|
||||
@Override
|
||||
public JsonArray generateDataJson() {
|
||||
JsonArray resultsArray = new JsonArray();
|
||||
Registry<StatusEffect> statusEffectRegistry = Registry.STATUS_EFFECT;
|
||||
statusEffectRegistry.forEach(effect -> resultsArray.add(generateEffect(statusEffectRegistry, effect)));
|
||||
return resultsArray;
|
||||
}
|
||||
}
|
||||
+94
@@ -0,0 +1,94 @@
|
||||
package dev.u9g.minecraftdatagenerator.generators;
|
||||
|
||||
import com.google.common.collect.ImmutableMap;
|
||||
import com.google.gson.JsonArray;
|
||||
import com.google.gson.JsonObject;
|
||||
import dev.u9g.minecraftdatagenerator.util.DGU;
|
||||
import net.minecraft.enchantment.Enchantment;
|
||||
import net.minecraft.enchantment.EnchantmentTarget;
|
||||
import net.minecraft.util.Identifier;
|
||||
import net.minecraft.util.registry.Registry;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.Locale;
|
||||
import java.util.Objects;
|
||||
|
||||
public class EnchantmentsDataGenerator implements IDataGenerator {
|
||||
|
||||
private static final ImmutableMap<EnchantmentTarget, String> ENCHANTMENT_TARGET_NAMES = ImmutableMap.<EnchantmentTarget, String>builder()
|
||||
.put(EnchantmentTarget.ALL, "vanishable") // according to VanishingCurseEnchantment
|
||||
.build();
|
||||
|
||||
public static String getEnchantmentTargetName(EnchantmentTarget target) {
|
||||
return ENCHANTMENT_TARGET_NAMES.getOrDefault(target, target.name().toLowerCase(Locale.ROOT));
|
||||
}
|
||||
|
||||
// Equation enchantment costs follow is a * level + b, so we can easily retrieve a and b by passing zero level
|
||||
private static JsonObject generateEnchantmentMinPowerCoefficients(Enchantment enchantment) {
|
||||
int b = enchantment.getMinimumPower(0);
|
||||
int a = enchantment.getMinimumPower(1) - b;
|
||||
|
||||
JsonObject resultObject = new JsonObject();
|
||||
resultObject.addProperty("a", a);
|
||||
resultObject.addProperty("b", b);
|
||||
return resultObject;
|
||||
}
|
||||
|
||||
private static JsonObject generateEnchantmentMaxPowerCoefficients(Enchantment enchantment) {
|
||||
int b = enchantment.getMaximumPower(0);
|
||||
int a = enchantment.getMaximumPower(1) - b;
|
||||
|
||||
JsonObject resultObject = new JsonObject();
|
||||
resultObject.addProperty("a", a);
|
||||
resultObject.addProperty("b", b);
|
||||
return resultObject;
|
||||
}
|
||||
|
||||
public static JsonObject generateEnchantment(Registry<Enchantment> registry, Enchantment enchantment) {
|
||||
JsonObject enchantmentDesc = new JsonObject();
|
||||
Identifier registryKey = registry.getId(enchantment);
|
||||
|
||||
enchantmentDesc.addProperty("id", registry.getRawId(enchantment));
|
||||
enchantmentDesc.addProperty("name", Objects.requireNonNull(registryKey).getPath());
|
||||
enchantmentDesc.addProperty("displayName", DGU.translateText(enchantment.getTranslationKey()));
|
||||
|
||||
enchantmentDesc.addProperty("maxLevel", enchantment.getMaximumLevel());
|
||||
enchantmentDesc.add("minCost", generateEnchantmentMinPowerCoefficients(enchantment));
|
||||
enchantmentDesc.add("maxCost", generateEnchantmentMaxPowerCoefficients(enchantment));
|
||||
|
||||
enchantmentDesc.addProperty("treasureOnly", enchantment.isTreasure());
|
||||
enchantmentDesc.addProperty("curse", enchantment.isCursed());
|
||||
|
||||
List<Enchantment> incompatibleEnchantments = registry.stream()
|
||||
.filter(other -> !enchantment.isDifferent(other))
|
||||
.filter(other -> other != enchantment).toList();
|
||||
|
||||
JsonArray excludes = new JsonArray();
|
||||
for (Enchantment excludedEnchantment : incompatibleEnchantments) {
|
||||
Identifier otherKey = registry.getId(excludedEnchantment);
|
||||
excludes.add(Objects.requireNonNull(otherKey).getPath());
|
||||
}
|
||||
enchantmentDesc.add("exclude", excludes);
|
||||
|
||||
enchantmentDesc.addProperty("category", getEnchantmentTargetName(enchantment.type));
|
||||
enchantmentDesc.addProperty("weight", enchantment.getWeight().getWeight());
|
||||
enchantmentDesc.addProperty("tradeable", true); // the first non-tradeable enchant came in 1.16, soul speed
|
||||
enchantmentDesc.addProperty("discoverable", true); // the first non-enchantable enchant came in 1.16, soul speed
|
||||
|
||||
return enchantmentDesc;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getDataName() {
|
||||
return "enchantments";
|
||||
}
|
||||
|
||||
@Override
|
||||
public JsonArray generateDataJson() {
|
||||
JsonArray resultsArray = new JsonArray();
|
||||
Registry<Enchantment> enchantmentRegistry = Registry.ENCHANTMENT;
|
||||
enchantmentRegistry.stream()
|
||||
.forEach(enchantment -> resultsArray.add(generateEnchantment(enchantmentRegistry, enchantment)));
|
||||
return resultsArray;
|
||||
}
|
||||
}
|
||||
+110
@@ -0,0 +1,110 @@
|
||||
package dev.u9g.minecraftdatagenerator.generators;
|
||||
|
||||
import com.google.gson.JsonArray;
|
||||
import com.google.gson.JsonObject;
|
||||
import dev.u9g.minecraftdatagenerator.FieldHelper;
|
||||
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.util.Identifier;
|
||||
import net.minecraft.util.registry.Registry;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
|
||||
import java.lang.reflect.ParameterizedType;
|
||||
import java.util.Objects;
|
||||
|
||||
public class EntitiesDataGenerator implements IDataGenerator {
|
||||
public static JsonObject generateEntity(Registry<EntityType<?>> entityRegistry, EntityType<?> entityType) {
|
||||
JsonObject entityDesc = new JsonObject();
|
||||
Identifier registryKey = entityRegistry.getId(entityType);
|
||||
int entityRawId = entityRegistry.getRawId(entityType);
|
||||
|
||||
entityDesc.addProperty("id", entityRawId);
|
||||
entityDesc.addProperty("internalId", entityRawId);
|
||||
entityDesc.addProperty("name", Objects.requireNonNull(registryKey).getPath());
|
||||
|
||||
entityDesc.addProperty("displayName", DGU.translateText(entityType.getTranslationKey()));
|
||||
entityDesc.addProperty("width", entityType.getDimensions().width);
|
||||
entityDesc.addProperty("height", entityType.getDimensions().height);
|
||||
|
||||
Entity entityObject = entityType.create(DGU.getWorld());
|
||||
String entityTypeString = entityObject != null ? getEntityTypeForClass(entityObject.getClass()) : "player";
|
||||
entityDesc.addProperty("type", entityTypeString);
|
||||
entityDesc.addProperty("category", getCategoryFrom(entityType));
|
||||
|
||||
return entityDesc;
|
||||
}
|
||||
|
||||
private static String getCategoryFrom(@NotNull EntityType<?> entityType) {
|
||||
ParameterizedType entityTypeClass = (ParameterizedType) FieldHelper.findStaticFieldWithValue(EntityType.class, entityType).getGenericType();
|
||||
Class<?> entityClass = (Class<?>) entityTypeClass.getActualTypeArguments()[0];
|
||||
return switch (entityClass.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.thrown" -> "Projectiles";
|
||||
case "net.minecraft.entity.passive" -> "Passive mobs";
|
||||
case "net.minecraft.entity.vehicle" -> "Vehicles";
|
||||
case "net.minecraft.entity.player", "net.minecraft.entity" -> "other";
|
||||
default -> throw new IllegalStateException("Unexpected entity type: " + entityClass.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<? extends Entity> entityClass) {
|
||||
//Top-level classifications
|
||||
if (WaterCreatureEntity.class.isAssignableFrom(entityClass)) {
|
||||
return "water_creature";
|
||||
}
|
||||
if (AnimalEntity.class.isAssignableFrom(entityClass)) {
|
||||
return "animal";
|
||||
}
|
||||
if (HostileEntity.class.isAssignableFrom(entityClass)) {
|
||||
return "hostile";
|
||||
}
|
||||
if (AmbientEntity.class.isAssignableFrom(entityClass)) {
|
||||
return "ambient";
|
||||
}
|
||||
|
||||
//Second level classifications. PathAwareEntity is not included because it
|
||||
//doesn't really make much sense to categorize by it
|
||||
if (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<EntityType<?>> entityTypeRegistry = Registry.ENTITY_TYPE;
|
||||
entityTypeRegistry.forEach(entity -> resultArray.add(generateEntity(entityTypeRegistry, entity)));
|
||||
return resultArray;
|
||||
}
|
||||
}
|
||||
+50
@@ -0,0 +1,50 @@
|
||||
package dev.u9g.minecraftdatagenerator.generators;
|
||||
|
||||
import com.google.gson.JsonArray;
|
||||
import com.google.gson.JsonObject;
|
||||
import dev.u9g.minecraftdatagenerator.util.DGU;
|
||||
import net.minecraft.item.FoodComponent;
|
||||
import net.minecraft.item.Item;
|
||||
import net.minecraft.util.Identifier;
|
||||
import net.minecraft.util.registry.Registry;
|
||||
|
||||
import java.util.Objects;
|
||||
|
||||
public class FoodsDataGenerator implements IDataGenerator {
|
||||
public static JsonObject generateFoodDescriptor(Registry<Item> registry, Item foodItem) {
|
||||
JsonObject foodDesc = new JsonObject();
|
||||
Identifier registryKey = registry.getId(foodItem);
|
||||
|
||||
foodDesc.addProperty("id", registry.getRawId(foodItem));
|
||||
foodDesc.addProperty("name", Objects.requireNonNull(registryKey).getPath());
|
||||
|
||||
foodDesc.addProperty("stackSize", foodItem.getMaxCount());
|
||||
foodDesc.addProperty("displayName", DGU.translateText(foodItem.getTranslationKey()));
|
||||
|
||||
FoodComponent foodComponent = Objects.requireNonNull(foodItem.getFoodComponent());
|
||||
float foodPoints = foodComponent.getHunger();
|
||||
float saturationRatio = foodComponent.getSaturationModifier() * 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<Item> itemRegistry = Registry.ITEM;
|
||||
itemRegistry.stream()
|
||||
.filter(Item::isFood)
|
||||
.forEach(food -> resultsArray.add(generateFoodDescriptor(itemRegistry, food)));
|
||||
return resultsArray;
|
||||
}
|
||||
}
|
||||
+25
@@ -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.Instrument;
|
||||
|
||||
public class InstrumentsDataGenerator implements IDataGenerator {
|
||||
@Override
|
||||
public String getDataName() {
|
||||
return "instruments";
|
||||
}
|
||||
|
||||
@Override
|
||||
public JsonElement generateDataJson() {
|
||||
JsonArray array = new JsonArray();
|
||||
for (Instrument instrument : Instrument.values()) {
|
||||
JsonObject object = new JsonObject();
|
||||
object.addProperty("id", instrument.ordinal());
|
||||
object.addProperty("name", instrument.asString());
|
||||
array.add(object);
|
||||
}
|
||||
return array;
|
||||
}
|
||||
}
|
||||
+78
@@ -0,0 +1,78 @@
|
||||
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.EnchantmentTarget;
|
||||
import net.minecraft.item.Item;
|
||||
import net.minecraft.item.ItemStack;
|
||||
import net.minecraft.util.Identifier;
|
||||
import net.minecraft.util.registry.Registry;
|
||||
|
||||
import java.util.*;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
public class ItemsDataGenerator implements IDataGenerator {
|
||||
|
||||
private static List<Item> calculateItemsToRepairWith(Registry<Item> itemRegistry, Item sourceItem) {
|
||||
ItemStack sourceItemStack = DGU.asStack(sourceItem);
|
||||
return itemRegistry.stream()
|
||||
.filter(otherItem -> sourceItem.canRepair(sourceItemStack, DGU.asStack(otherItem)))
|
||||
.collect(Collectors.toList());
|
||||
}
|
||||
|
||||
private static Set<String> getApplicableEnchantmentTargets(Item sourceItem) {
|
||||
return Arrays.stream(EnchantmentTarget.values())
|
||||
.filter(target -> target.isAcceptableItem(sourceItem))
|
||||
.map(EnchantmentsDataGenerator::getEnchantmentTargetName)
|
||||
.sorted()
|
||||
.collect(Collectors.toCollection(LinkedHashSet::new));
|
||||
}
|
||||
|
||||
public static JsonObject generateItem(Registry<Item> itemRegistry, Item item) {
|
||||
JsonObject itemDesc = new JsonObject();
|
||||
Identifier registryKey = itemRegistry.getId(item);
|
||||
|
||||
itemDesc.addProperty("id", itemRegistry.getRawId(item));
|
||||
itemDesc.addProperty("name", Objects.requireNonNull(registryKey).getPath());
|
||||
|
||||
itemDesc.addProperty("displayName", DGU.translateText(item.getTranslationKey()));
|
||||
itemDesc.addProperty("stackSize", item.getMaxCount());
|
||||
|
||||
JsonArray enchantCategoriesArray = new JsonArray();
|
||||
getApplicableEnchantmentTargets(item).forEach(enchantCategoriesArray::add);
|
||||
if (!enchantCategoriesArray.isEmpty()) {
|
||||
itemDesc.add("enchantCategories", enchantCategoriesArray);
|
||||
}
|
||||
|
||||
if (item.isDamageable()) {
|
||||
List<Item> repairWithItems = calculateItemsToRepairWith(itemRegistry, item);
|
||||
|
||||
JsonArray fixedWithArray = new JsonArray();
|
||||
for (Item repairWithItem : repairWithItems) {
|
||||
Identifier repairWithName = itemRegistry.getId(repairWithItem);
|
||||
fixedWithArray.add(Objects.requireNonNull(repairWithName).getPath());
|
||||
}
|
||||
if (!fixedWithArray.isEmpty()) {
|
||||
itemDesc.add("repairWith", fixedWithArray);
|
||||
}
|
||||
|
||||
int maxDurability = item.getMaxDamage();
|
||||
itemDesc.addProperty("maxDurability", maxDurability);
|
||||
}
|
||||
return itemDesc;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getDataName() {
|
||||
return "items";
|
||||
}
|
||||
|
||||
@Override
|
||||
public JsonArray generateDataJson() {
|
||||
JsonArray resultArray = new JsonArray();
|
||||
Registry<Item> itemRegistry = Registry.ITEM;
|
||||
itemRegistry.stream().forEach(item -> resultArray.add(generateItem(itemRegistry, item)));
|
||||
return resultArray;
|
||||
}
|
||||
}
|
||||
+27
@@ -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 e) {
|
||||
throw new RuntimeException("Failed to generate language file", e);
|
||||
}
|
||||
}
|
||||
}
|
||||
+33
@@ -0,0 +1,33 @@
|
||||
package dev.u9g.minecraftdatagenerator.generators;
|
||||
|
||||
import com.google.gson.JsonArray;
|
||||
import com.google.gson.JsonObject;
|
||||
import net.minecraft.particle.ParticleType;
|
||||
import net.minecraft.util.Identifier;
|
||||
import net.minecraft.util.registry.Registry;
|
||||
|
||||
import java.util.Objects;
|
||||
|
||||
public class ParticlesDataGenerator implements IDataGenerator {
|
||||
public static JsonObject generateParticleType(Registry<ParticleType<?>> registry, ParticleType<?> particleType) {
|
||||
JsonObject effectDesc = new JsonObject();
|
||||
Identifier registryKey = registry.getId(particleType);
|
||||
|
||||
effectDesc.addProperty("id", registry.getRawId(particleType));
|
||||
effectDesc.addProperty("name", Objects.requireNonNull(registryKey).getPath());
|
||||
return effectDesc;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getDataName() {
|
||||
return "particles";
|
||||
}
|
||||
|
||||
@Override
|
||||
public JsonArray generateDataJson() {
|
||||
JsonArray resultsArray = new JsonArray();
|
||||
Registry<ParticleType<?>> particleTypeRegistry = Registry.PARTICLE_TYPE;
|
||||
particleTypeRegistry.forEach(particleType -> resultsArray.add(generateParticleType(particleTypeRegistry, particleType)));
|
||||
return resultsArray;
|
||||
}
|
||||
}
|
||||
+126
@@ -0,0 +1,126 @@
|
||||
package dev.u9g.minecraftdatagenerator.generators;
|
||||
|
||||
import com.google.gson.JsonElement;
|
||||
import com.google.gson.JsonNull;
|
||||
import net.minecraft.item.Item;
|
||||
import net.minecraft.util.registry.Registry;
|
||||
|
||||
public class RecipeDataGenerator implements IDataGenerator {
|
||||
|
||||
private static int getRawIdFor(Item item) {
|
||||
return Registry.ITEM.getRawId(item);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getDataName() {
|
||||
return "recipes";
|
||||
}
|
||||
|
||||
@Override
|
||||
public JsonElement generateDataJson() {
|
||||
// JsonObject finalObj = new JsonObject();
|
||||
// Multimap<Integer, JsonObject> recipes = ArrayListMultimap.create();
|
||||
// for (Recipe<?> recipe : Objects.requireNonNull(DGU.getWorld()).getRecipeManager().values()) {
|
||||
// if (recipe instanceof ShapedRecipe sr) {
|
||||
// var ingredients = sr.getIngredients();
|
||||
// List<Integer> ingr = new ArrayList<>();
|
||||
// for (int i = 0; i < 9; i++) {
|
||||
// if (i >= ingredients.size()) {
|
||||
// ingr.add(-1);
|
||||
// continue;
|
||||
// }
|
||||
// var stacks = ingredients.get(i);
|
||||
//// var matching = stacks.getMatchingStacks();
|
||||
//// if (matching.length == 0) {
|
||||
//// ingr.add(-1);
|
||||
//// } else {
|
||||
//// ingr.add(getRawIdFor(matching[0].getItem()));
|
||||
//// }
|
||||
// }
|
||||
// Lists.reverse(ingr);
|
||||
//
|
||||
// JsonArray inShape = new JsonArray();
|
||||
//
|
||||
// var iter = ingr.iterator();
|
||||
// for (int y = 0; y < 3; y++) {
|
||||
// var jsonRow = new JsonArray();
|
||||
// int one = iter.next();
|
||||
// int two = iter.next();
|
||||
// int three = iter.next();
|
||||
// if (y > 0 && one == -1 && two == -1 && three == -1) continue;
|
||||
// jsonRow.add(one);
|
||||
// jsonRow.add(two);
|
||||
// jsonRow.add(three);
|
||||
// inShape.add(jsonRow);
|
||||
// }
|
||||
//
|
||||
// JsonObject finalRecipe = new JsonObject();
|
||||
// finalRecipe.add("inShape", inShape);
|
||||
//
|
||||
// var resultObject = new JsonObject();
|
||||
// resultObject.addProperty("id", getRawIdFor(sr.getOutput().getItem()));
|
||||
// resultObject.addProperty("count", sr.getOutput().getCount());
|
||||
// finalRecipe.add("result", resultObject);
|
||||
//
|
||||
// String id = ((Integer) getRawIdFor(sr.getOutput().getItem())).toString();
|
||||
//
|
||||
// if (!finalObj.has(id)) {
|
||||
// finalObj.add(id, new JsonArray());
|
||||
// }
|
||||
// finalObj.get(id).getAsJsonArray().add(finalRecipe);
|
||||
//// var input = new JsonArray();
|
||||
//// var ingredients = sr.getIngredients().stream().toList();
|
||||
//// for (int y = 0; y < sr.getHeight(); y++) {
|
||||
//// var arr = new JsonArray();
|
||||
//// for (int x = 0; x < sr.getWidth(); x++) {
|
||||
//// if ((y*3)+x >= ingredients.size()) {
|
||||
//// arr.add(JsonNull.INSTANCE);
|
||||
//// continue;
|
||||
//// }
|
||||
//// var ingredient = ingredients.get((y*3)+x).getMatchingStacks(); // FIXME: fix when there are more than one matching stack
|
||||
//// if (ingredient.length == 0) {
|
||||
//// arr.add(JsonNull.INSTANCE);
|
||||
//// } else {
|
||||
//// arr.add(getRawIdFor(ingredient[0].getItem()));
|
||||
//// }
|
||||
//// }
|
||||
//// input.add(arr);
|
||||
//// }
|
||||
//// var rootRecipeObject = new JsonObject();
|
||||
//// rootRecipeObject.add("inShape", input);
|
||||
//// var resultObject = new JsonObject();
|
||||
//// resultObject.addProperty("id", getRawIdFor(sr.getOutput().getItem()));
|
||||
//// resultObject.addProperty("count", sr.getOutput().getCount());
|
||||
//// rootRecipeObject.add("result", resultObject);
|
||||
//// recipes.put(getRawIdFor(sr.getOutput().getItem()), rootRecipeObject);
|
||||
// } else if (recipe instanceof ShapelessRecipe sl) {
|
||||
|
||||
// var ingredients = new JsonArray();
|
||||
// for (Ingredient ingredient : sl.getIngredients()) {
|
||||
// if (ingredient.isEmpty()) continue;
|
||||
//// ingredients.add(getRawIdFor(ingredient.getMatchingStacks()[0].getItem()));
|
||||
// }
|
||||
// var rootRecipeObject = new JsonObject();
|
||||
// rootRecipeObject.add("ingredients", ingredients);
|
||||
// var resultObject = new JsonObject();
|
||||
// resultObject.addProperty("id", getRawIdFor(sl.getOutput().getItem()));
|
||||
// resultObject.addProperty("count", sl.getOutput().getCount());
|
||||
// rootRecipeObject.add("result", resultObject);
|
||||
// recipes.put(getRawIdFor(sl.getOutput().getItem()), rootRecipeObject);
|
||||
// }
|
||||
// }
|
||||
// recipes.forEach((a, b) -> {
|
||||
// if (!finalObj.has(a.toString())) {
|
||||
// finalObj.add(a.toString(), new JsonArray());
|
||||
// }
|
||||
// finalObj.get(a.toString()).getAsJsonArray().add(b);
|
||||
// });
|
||||
// return finalObj;
|
||||
return JsonNull.INSTANCE;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isEnabled() {
|
||||
return false; // TODO: Implement this
|
||||
}
|
||||
}
|
||||
+29
@@ -0,0 +1,29 @@
|
||||
package dev.u9g.minecraftdatagenerator.generators;
|
||||
|
||||
import com.google.gson.JsonArray;
|
||||
import com.google.gson.JsonObject;
|
||||
import net.minecraft.sound.SoundEvent;
|
||||
import net.minecraft.util.registry.Registry;
|
||||
|
||||
public class SoundsDataGenerator implements IDataGenerator {
|
||||
public static JsonObject generateSound(SoundEvent soundEvent) {
|
||||
JsonObject soundDesc = new JsonObject();
|
||||
|
||||
soundDesc.addProperty("id", Registry.SOUND_EVENT.getRawId(soundEvent));
|
||||
soundDesc.addProperty("name", soundEvent.getId().getPath());
|
||||
|
||||
return soundDesc;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getDataName() {
|
||||
return "sounds";
|
||||
}
|
||||
|
||||
@Override
|
||||
public JsonArray generateDataJson() {
|
||||
JsonArray resultsArray = new JsonArray();
|
||||
Registry.SOUND_EVENT.forEach(sound -> resultsArray.add(generateSound(sound)));
|
||||
return resultsArray;
|
||||
}
|
||||
}
|
||||
+167
@@ -0,0 +1,167 @@
|
||||
package dev.u9g.minecraftdatagenerator.generators;
|
||||
|
||||
import com.google.gson.JsonArray;
|
||||
import com.google.gson.JsonObject;
|
||||
import dev.u9g.minecraftdatagenerator.util.EmptyRenderBlockView;
|
||||
import net.fabricmc.api.EnvType;
|
||||
import net.fabricmc.loader.api.FabricLoader;
|
||||
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.client.color.world.FoliageColors;
|
||||
import net.minecraft.client.color.world.GrassColors;
|
||||
import net.minecraft.util.Identifier;
|
||||
import net.minecraft.util.math.BlockPos;
|
||||
import net.minecraft.util.math.MathHelper;
|
||||
import net.minecraft.util.registry.Registry;
|
||||
import net.minecraft.world.biome.Biome;
|
||||
|
||||
import java.util.*;
|
||||
|
||||
public class TintsDataGenerator implements IDataGenerator {
|
||||
public static BiomeTintColors generateBiomeTintColors(Registry<Biome> biomeRegistry) {
|
||||
BiomeTintColors colors = new BiomeTintColors();
|
||||
|
||||
biomeRegistry.forEach(biome -> {
|
||||
double d = MathHelper.clamp(biome.getTemperature(), 0.0f, 1.0f);
|
||||
double e = MathHelper.clamp(biome.getRainfall(), 0.0f, 1.0f);
|
||||
|
||||
int biomeGrassColor = GrassColors.getColor(d, e);
|
||||
int biomeFoliageColor = FoliageColors.getColor(d, e);
|
||||
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<Integer, Integer> generateRedstoneTintColors() {
|
||||
Map<Integer, Integer> 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<Block, Integer> generateConstantTintColors() {
|
||||
Map<Block, Integer> 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<Biome> biomeRegistry, Map<Integer, List<Biome>> 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.getId(biome);
|
||||
keysArray.add(Objects.requireNonNull(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<Integer, Integer> 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<Block> blockRegistry, Map<Block, Integer> colorsMap) {
|
||||
JsonArray resultColorsArray = new JsonArray();
|
||||
for (var entry : colorsMap.entrySet()) {
|
||||
JsonObject entryObject = new JsonObject();
|
||||
|
||||
JsonArray keysArray = new JsonArray();
|
||||
Identifier registryKey = blockRegistry.getId(entry.getKey());
|
||||
keysArray.add(Objects.requireNonNull(registryKey).getPath());
|
||||
|
||||
entryObject.add("keys", keysArray);
|
||||
entryObject.addProperty("color", entry.getValue());
|
||||
resultColorsArray.add(entryObject);
|
||||
}
|
||||
|
||||
JsonObject resultObject = new JsonObject();
|
||||
resultObject.add("data", resultColorsArray);
|
||||
return resultObject;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getDataName() {
|
||||
return "tints";
|
||||
}
|
||||
|
||||
@Override
|
||||
public JsonObject generateDataJson() {
|
||||
// DynamicRegistryManager registryManager = DynamicRegistryManager.create();
|
||||
Registry<Biome> biomeRegistry = Registry.BIOME;
|
||||
Registry<Block> blockRegistry = Registry.BLOCK;
|
||||
|
||||
BiomeTintColors biomeTintColors = generateBiomeTintColors(biomeRegistry);
|
||||
Map<Integer, Integer> redstoneColors = generateRedstoneTintColors();
|
||||
Map<Block, Integer> constantTintColors = Collections.emptyMap();
|
||||
|
||||
EnvType currentEnvironment = FabricLoader.getInstance().getEnvironmentType();
|
||||
if (currentEnvironment == EnvType.CLIENT) {
|
||||
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<Integer, List<Biome>> grassColoursMap = new LinkedHashMap<>();
|
||||
final Map<Integer, List<Biome>> foliageColoursMap = new LinkedHashMap<>();
|
||||
final Map<Integer, List<Biome>> waterColourMap = new LinkedHashMap<>();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,15 @@
|
||||
package dev.u9g.minecraftdatagenerator.mixin;
|
||||
|
||||
import net.minecraft.server.dedicated.EulaReader;
|
||||
import org.spongepowered.asm.mixin.Mixin;
|
||||
import org.spongepowered.asm.mixin.injection.At;
|
||||
import org.spongepowered.asm.mixin.injection.Inject;
|
||||
import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
|
||||
|
||||
@Mixin(EulaReader.class)
|
||||
public class EULAMixin {
|
||||
@Inject(method = "isEulaAgreedTo()Z", at = @At("TAIL"), cancellable = true)
|
||||
public void init(CallbackInfoReturnable<Boolean> cir) {
|
||||
cir.setReturnValue(true);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,13 @@
|
||||
package dev.u9g.minecraftdatagenerator.mixin;
|
||||
|
||||
import net.minecraft.util.Language;
|
||||
import org.spongepowered.asm.mixin.Mixin;
|
||||
import org.spongepowered.asm.mixin.gen.Accessor;
|
||||
|
||||
import java.util.Map;
|
||||
|
||||
@Mixin(Language.class)
|
||||
public interface LanguageAccessor {
|
||||
@Accessor("translations")
|
||||
Map<String, String> translations();
|
||||
}
|
||||
+18
@@ -0,0 +1,18 @@
|
||||
package dev.u9g.minecraftdatagenerator.mixin;
|
||||
|
||||
import net.minecraft.block.Block;
|
||||
import net.minecraft.item.MiningToolItem;
|
||||
import org.spongepowered.asm.mixin.Mixin;
|
||||
import org.spongepowered.asm.mixin.gen.Accessor;
|
||||
|
||||
import java.util.Set;
|
||||
|
||||
@Mixin(MiningToolItem.class)
|
||||
public interface MiningToolItemAccessor {
|
||||
|
||||
@Accessor
|
||||
Set<Block> getEffectiveBlocks();
|
||||
|
||||
@Accessor
|
||||
float getMiningSpeed();
|
||||
}
|
||||
@@ -0,0 +1,26 @@
|
||||
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("HEAD"))
|
||||
private void constructor(CallbackInfoReturnable<Boolean> cir) {
|
||||
((MinecraftDedicatedServer) (Object) this).setServerPort(0);
|
||||
}
|
||||
|
||||
@Inject(method = "setupServer()Z", at = @At("TAIL"))
|
||||
private void init(CallbackInfoReturnable<Boolean> cir) {
|
||||
MinecraftDataGenerator.start(
|
||||
MinecraftVersion.create().getName(),
|
||||
DGU.getCurrentlyRunningServer().getRunDirectory().toPath()
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,12 @@
|
||||
package dev.u9g.minecraftdatagenerator.mixin;
|
||||
|
||||
import net.minecraft.entity.effect.StatusEffect;
|
||||
import net.minecraft.entity.effect.StatusEffectType;
|
||||
import org.spongepowered.asm.mixin.Mixin;
|
||||
import org.spongepowered.asm.mixin.gen.Accessor;
|
||||
|
||||
@Mixin(StatusEffect.class)
|
||||
public interface StatusEffectAccessor {
|
||||
@Accessor("type")
|
||||
StatusEffectType type();
|
||||
}
|
||||
@@ -0,0 +1,30 @@
|
||||
package dev.u9g.minecraftdatagenerator.util;
|
||||
|
||||
import net.fabricmc.loader.api.FabricLoader;
|
||||
import net.minecraft.item.Item;
|
||||
import net.minecraft.item.ItemStack;
|
||||
import net.minecraft.server.MinecraftServer;
|
||||
import net.minecraft.util.Language;
|
||||
import net.minecraft.world.World;
|
||||
import net.minecraft.world.dimension.DimensionType;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
|
||||
public class DGU {
|
||||
@SuppressWarnings("deprecation")
|
||||
public static MinecraftServer getCurrentlyRunningServer() {
|
||||
return (MinecraftServer) FabricLoader.getInstance().getGameInstance();
|
||||
}
|
||||
|
||||
public static String translateText(String translationKey) {
|
||||
return Language.getInstance().translate(translationKey);
|
||||
}
|
||||
|
||||
@NotNull
|
||||
public static World getWorld() {
|
||||
return getCurrentlyRunningServer().getWorld(DimensionType.OVERWORLD);
|
||||
}
|
||||
|
||||
public static ItemStack asStack(Item item) {
|
||||
return new ItemStack(item);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,59 @@
|
||||
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.util.math.BlockPos;
|
||||
import net.minecraft.world.BlockRenderView;
|
||||
import net.minecraft.world.LightType;
|
||||
import net.minecraft.world.biome.Biomes;
|
||||
import net.minecraft.world.chunk.light.LightingProvider;
|
||||
import net.minecraft.world.level.ColorResolver;
|
||||
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 LightingProvider getLightingProvider() {
|
||||
return null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getColor(BlockPos pos, ColorResolver colorResolver) {
|
||||
return colorResolver.getColor(Biomes.PLAINS, 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;
|
||||
}
|
||||
}
|
||||
@@ -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": "*"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,20 @@
|
||||
{
|
||||
"required": true,
|
||||
"minVersion": "0.8",
|
||||
"package": "dev.u9g.minecraftdatagenerator.mixin",
|
||||
"compatibilityLevel": "JAVA_17",
|
||||
"mixins": [
|
||||
"LanguageAccessor",
|
||||
"MiningToolItemAccessor",
|
||||
"ReadyMixin",
|
||||
"StatusEffectAccessor"
|
||||
],
|
||||
"client": [
|
||||
],
|
||||
"injectors": {
|
||||
"defaultRequire": 1
|
||||
},
|
||||
"server": [
|
||||
"EULAMixin"
|
||||
]
|
||||
}
|
||||
Reference in New Issue
Block a user