From ceff04adba01f2e5a4243aa09548ab78f9d8c610 Mon Sep 17 00:00:00 2001 From: Jason Mitchell Date: Fri, 5 Jun 2026 16:13:30 -0700 Subject: [PATCH] Fixes a regression with TFC. (#1822) --- .../CeleritasBlockTransformer.java | 1 - .../transformers/CeleritasBlockTransform.java | 64 +++++++++---------- 2 files changed, 30 insertions(+), 35 deletions(-) diff --git a/src/main/java/com/gtnewhorizons/angelica/loading/fml/transformers/CeleritasBlockTransformer.java b/src/main/java/com/gtnewhorizons/angelica/loading/fml/transformers/CeleritasBlockTransformer.java index f439ca761..474c6d04d 100644 --- a/src/main/java/com/gtnewhorizons/angelica/loading/fml/transformers/CeleritasBlockTransformer.java +++ b/src/main/java/com/gtnewhorizons/angelica/loading/fml/transformers/CeleritasBlockTransformer.java @@ -17,7 +17,6 @@ public class CeleritasBlockTransformer implements IClassTransformer { public CeleritasBlockTransformer() { this.inner = new CeleritasBlockTransform(AngelicaClientTweaker.isObfEnv()); this.exclusions = inner.getTransformerExclusions(); - this.inner.setCeleritasSetting(); } /** diff --git a/src/main/java/com/gtnewhorizons/angelica/loading/shared/transformers/CeleritasBlockTransform.java b/src/main/java/com/gtnewhorizons/angelica/loading/shared/transformers/CeleritasBlockTransform.java index 43675ac9c..9694bf7cf 100644 --- a/src/main/java/com/gtnewhorizons/angelica/loading/shared/transformers/CeleritasBlockTransform.java +++ b/src/main/java/com/gtnewhorizons/angelica/loading/shared/transformers/CeleritasBlockTransform.java @@ -31,16 +31,21 @@ public final class CeleritasBlockTransform implements Opcodes { private static final Logger LOGGER = LogManager.getLogger("CeleritasBlockTransformer"); private static final String BlockClass = "net/minecraft/block/Block"; private static final String ThreadedBlockData = "com/gtnewhorizons/angelica/client/rendering/ThreadedBlockData"; + /** All classes under net.minecraft.block.Block* are Block subclasses save for these. */ + private static final String[] VanillaBlockExclusions = { + "net/minecraft/block/IGrowable", + "net/minecraft/block/ITileEntityProvider", + "net/minecraft/block/BlockEventData", + "net/minecraft/block/BlockSourceImpl", + "net/minecraft/block/material/" + }; private final Map fieldNameToRedirect = new HashMap<>(); - private final Set blockSubclasses = Collections.newSetFromMap(new ConcurrentHashMap<>()); + private final Set moddedBlockSubclasses = Collections.newSetFromMap(new ConcurrentHashMap<>()); // Block subclass owners we shouldn't redirect because they shadow some fields we want to redirect private final Set blockSubclassExclusions = Collections.newSetFromMap(new ConcurrentHashMap<>()); private final ClassConstantPoolParser cstPoolParser; - private final MethodHandle celeritasEnabledGetter; - private boolean isCeleritasEnabled; - public CeleritasBlockTransform(boolean isObf) { final List> mappings = ImmutableList.of( Pair.of("minX", "field_149759_B"), @@ -56,37 +61,30 @@ public final class CeleritasBlockTransform implements Opcodes { } this.cstPoolParser = new ClassConstantPoolParser(this.fieldNameToRedirect.keySet().toArray(new String[0])); + } - blockSubclasses.add(BlockClass); - - try { - // Needed because the config is loaded in LaunchClassLoader, but we need to access it in the parent system loader. - final Class angelicaConfig = Class.forName("com.gtnewhorizons.angelica.config.AngelicaConfig", true, Launch.classLoader); - celeritasEnabledGetter = MethodHandles.lookup().findStaticGetter(angelicaConfig, "enableCeleritas", boolean.class); - } catch (ReflectiveOperationException e) { - throw new RuntimeException(e); + private boolean isVanillaBlockSubclass(String className) { + if (!className.startsWith(BlockClass)) { + return false; } - } - - public void setCeleritasSetting() { - isCeleritasEnabled = true; - } - - private boolean isCeleritasEnabled() { - if (isCeleritasEnabled) return true; - try { - return (boolean) celeritasEnabledGetter.invokeExact(); - } catch (Throwable e) { - throw new RuntimeException(e); + for (String exclusion : VanillaBlockExclusions) { + if (className.startsWith(exclusion)) { + return false; + } } + return true; } - // This method needs to be called for every class, including the ones we don't want to transform + private boolean isBlockSubclass(String className) { + return isVanillaBlockSubclass(className) || moddedBlockSubclasses.contains(className); + } + + // This method needs to be called for every class, including the ones we don't want to transform. + // Vanilla blocks are recognized by name; only modded subclasses need tracking, and FML's + // EventSubscriptionTransformer guarantees a modded class's superclass loads first. public void trackBlockSubclasses(String className, String superClassName) { - // It works because the deepest subclasses are always transformed first due to - // ForgeEventTransformer recursive superclass loading - if (blockSubclasses.contains(superClassName)) { - blockSubclasses.add(className); + if (!isVanillaBlockSubclass(className) && isBlockSubclass(superClassName)) { + moddedBlockSubclasses.add(className); if (blockSubclassExclusions.contains(superClassName)) { LOGGER.info("Class {} extends a class with shadowed block bounds fields and will be skipped from redirecting", className); @@ -110,9 +108,6 @@ public final class CeleritasBlockTransform implements Opcodes { /** @return Was the class changed? */ public boolean transformClassNode(String transformedName, ClassNode cn) { - if (!isCeleritasEnabled()) { - return false; - } boolean changed = false; if (BlockClass.equals(cn.name)) { changed = cn.fields.removeIf(field -> fieldNameToRedirect.containsKey(field.name)); @@ -124,7 +119,8 @@ public final class CeleritasBlockTransform implements Opcodes { } private void trackBlockShadowingFields(ClassNode cn) { - if (blockSubclasses.contains(cn.name)) { + // Only modded subclasses can shadow; vanilla declares these fields solely in Block. + if (moddedBlockSubclasses.contains(cn.name)) { for (FieldNode field : cn.fields) { if (fieldNameToRedirect.containsKey(field.name)) { LOGGER.info("Class '{}' shadows one or more block bounds fields, these accesses won't be redirected!", cn.name); @@ -141,7 +137,7 @@ public final class CeleritasBlockTransform implements Opcodes { for (AbstractInsnNode node = mn.instructions.getFirst(); node != null; node = node.getNext()) { if ((node.getOpcode() == GETFIELD || node.getOpcode() == PUTFIELD) && node instanceof FieldInsnNode fNode) { String newFieldName = fieldNameToRedirect.get(fNode.name); - if (newFieldName != null && blockSubclasses.contains(fNode.owner) && !blockSubclassExclusions.contains(fNode.owner)) { + if (newFieldName != null && isBlockSubclass(fNode.owner) && !blockSubclassExclusions.contains(fNode.owner)) { if (LOG_SPAM) { LOGGER.info("Redirecting Block.{} in {} to thread-safe wrapper", fNode.name, transformedName); }