Fixes machines becoming invisible when breaking or replacing multiblock parts

The Root Cause was MachineRenderState relying on identity-based lookups (IdentityHashMap in model rendering, IdMapper in network sync).

However, StateHolder.setValue() only returns interned instances when called on an already-interned state. When non-interned  states entered the system via deserialization or network sync, identity lookups failed, causing blocks to render nothing.

The Fix:
- MachineRenderState - Added intern() method that looks up the canonical state instance from StateDefinition.getPossibleStates(), and wired it into the CODEC via xmap() so deserialized states are always interned
  - MetaMachineBlockEntity - setRenderState() now validates the state belongs to the correct definition and interns it; onLoad() also validates since @persisted bypasses the setter.
  - MachineRenderStatePayload - Interns state before registry ID lookup during network write
  - MultiblockControllerMachine - onPartUnload() now immediately invalidates the structure when a part is removed, ensuring all remaining parts have their render state updated to unformed
  - MachineModel - Added fallback rendering that searches by property values when identity lookup fails, preventing invisible blocks if a non-interned state slips through and is mostly a failsafe

Author: Saereth

src/main/java/com/gregtechceu/gtceu/api/blockentity/MetaMachineBlockEntity.java

@@ -25,6 +25,7 @@
 import net.minecraft.world.level.block.entity.BlockEntity;
 import net.minecraft.world.level.block.entity.BlockEntityType;
 import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.Property;
 
 import lombok.Getter;
 import org.jetbrains.annotations.Nullable;
@@ -117,10 +118,50 @@ public void removeComponentsFromTag(CompoundTag tag) {
 
     @Override
     public void setRenderState(MachineRenderState state) {
+        if (state != null) {
+            // Validate that the state belongs to this block entity's definition
+            if (!state.is(getDefinition())) {
+                state = correctRenderStateDefinition(state);
+            }
+            // Ensure we're using the interned (canonical) state instance
+            state = state.intern();
+        }
         this.renderState = state;
         scheduleRenderUpdate();
     }
 
+    /**
+     * Corrects a render state that belongs to the wrong definition by creating a new state
+     * from this block entity's definition while preserving any compatible property values.
+     */
+    private MachineRenderState correctRenderStateDefinition(MachineRenderState wrongState) {
+        MachineRenderState correctedState = getDefinition().defaultRenderState();
+        // Copy any property values that exist in both the wrong state and this definition's state
+        for (Property<?> property : wrongState.getProperties()) {
+            if (correctedState.hasProperty(property)) {
+                correctedState = copyProperty(correctedState, wrongState, property);
+            }
+        }
+        return correctedState; // intern() will be called by setRenderState
+    }
+
+    /**
+     * Helper method to copy a single property value from one state to another.
+     * Uses a type parameter to satisfy the generic constraints of setValue().
+     */
+    @SuppressWarnings("unchecked")
+    private static <T extends Comparable<T>> MachineRenderState copyProperty(
+                                                                             MachineRenderState target,
+                                                                             MachineRenderState source,
+                                                                             Property<T> property) {
+        T value = source.getValue(property);
+        // Verify the value is valid for the target state's property
+        if (property.getPossibleValues().contains(value)) {
+            return target.setValue(property, value);
+        }
+        return target;
+    }
+
     @Override
     public long getOffset() {
         return offset;
@@ -135,6 +176,11 @@ public void setRemoved() {
     @Override
     public void onLoad() {
         super.onLoad();
+        // Validate render state after NBT load - @Persisted writes directly to field via reflection,
+        // bypassing setRenderState(), so we need to validate here as well
+        if (renderState != null && !renderState.is(getDefinition())) {
+            this.renderState = correctRenderStateDefinition(renderState);
+        }
         metaMachine.onLoad();
     }
 

src/main/java/com/gregtechceu/gtceu/api/machine/multiblock/MultiblockControllerMachine.java

@@ -23,7 +23,6 @@
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;
 import net.minecraft.server.level.ServerLevel;
-import net.minecraft.world.level.block.state.BlockState;
 
 import lombok.Getter;
 import lombok.Setter;
@@ -204,16 +203,25 @@ public void onStructureInvalid() {
     }
 
     /**
-     * mark multiblockState as unload error first.
-     * if it's actually cuz by block breaking.
-     * {@link #onStructureInvalid()} will be called from
-     * {@link MultiblockState#onBlockStateChanged(BlockPos, BlockState)}
+     * Called when a part is unloaded (chunk unload or block broken).
+     * If the structure is currently formed, immediately invalidate it to ensure
+     * all remaining parts have their render state updated.
      */
     @Override
     public void onPartUnload() {
-        parts.removeIf(part -> part.self().isInValid());
+        for (var it = parts.iterator(); it.hasNext();) {
+            var part = it.next();
+            if (part.self().isInValid()) {
+                it.remove();
+            }
+        }
         getMultiblockState().setError(MultiblockState.UNLOAD_ERROR);
         if (getLevel() instanceof ServerLevel serverLevel) {
+            // If structure is formed, invalidate it immediately to update all parts' render states
+            if (isFormed) {
+                onStructureInvalid();
+                MultiblockWorldSavedData.getOrCreate(serverLevel).removeMapping(getMultiblockState());
+            }
             MultiblockWorldSavedData.getOrCreate(serverLevel).addAsyncLogic(this);
         }
         updatePartPositions();

src/main/java/com/gregtechceu/gtceu/api/multiblock/MultiblockState.java

@@ -172,11 +172,6 @@ public void onBlockStateChanged(BlockPos pos, BlockState state) {
                 }
             } else {
                 IMultiController controller = getController();
-                if (controller == null && error == UNLOAD_ERROR) {
-                    if (!serverLevel.isLoaded(controllerPos)) {
-                        GTCEu.LOGGER.info("Controller not loaded, pos {}", controllerPos);
-                    }
-                }
                 if (controller != null) {
                     if (controller.isFormed() && state.getBlock() instanceof ActiveBlock) {
                         LongSet activeBlocks = getMatchContext().getOrDefault("vaBlocks", LongSets.emptySet());
@@ -186,7 +181,8 @@ public void onBlockStateChanged(BlockPos pos, BlockState state) {
                             return;
                         }
                     }
-                    if (controller.checkPatternWithLock()) {
+                    boolean patternValid = controller.checkPatternWithLock();
+                    if (patternValid) {
                         // refresh structure
                         controller.self().setFlipped(this.neededFlip);
                         controller.onStructureFormed();

src/main/java/com/gregtechceu/gtceu/client/model/machine/MachineModel.java

@@ -293,6 +293,22 @@ public void renderBaseModel(List<BakedQuad> quads, @NotNull MachineRenderState r
         }
         if (modelsByState.containsKey(renderState)) {
             quads.addAll(modelsByState.get(renderState).getQuads(blockState, side, rand, modelData, renderType));
+        } else {
+            // State not found by identity - try to find matching state by values as fallback
+            MachineRenderState fallbackState = null;
+            for (MachineRenderState expected : modelsByState.keySet()) {
+                if (expected.getValues().equals(renderState.getValues())) {
+                    fallbackState = expected;
+                    break;
+                }
+            }
+            if (fallbackState != null) {
+                quads.addAll(modelsByState.get(fallbackState).getQuads(blockState, side, rand, modelData, renderType));
+            } else if (modelsByState.containsKey(definition.defaultRenderState())) {
+                // Fall back to default state as last resort
+                quads.addAll(modelsByState.get(definition.defaultRenderState())
+                        .getQuads(blockState, side, rand, modelData, renderType));
+            }
         }
     }
 

src/main/java/com/gregtechceu/gtceu/client/model/machine/MachineRenderState.java

@@ -11,10 +11,31 @@
 import com.mojang.serialization.MapCodec;
 import it.unimi.dsi.fastutil.objects.Reference2ObjectArrayMap;
 
+import java.util.function.Function;
+
 public class MachineRenderState extends StateHolder<MachineDefinition, MachineRenderState> {
 
+    /**
+     * CODEC that always returns interned (canonical) state instances.
+     * This is critical because StateHolder uses identity-based lookups internally.
+     */
     public static final Codec<MachineRenderState> CODEC = codec(GTRegistries.MACHINES.byNameCodec(),
-            MachineDefinition::defaultRenderState).stable();
+            MachineDefinition::defaultRenderState)
+            .xmap(MachineRenderState::intern, Function.identity())
+            .stable();
+
+    /**
+     * Returns the interned (canonical) instance of this state from the definition's StateDefinition.
+     * This ensures identity-based lookups work correctly.
+     */
+    public MachineRenderState intern() {
+        for (MachineRenderState interned : getDefinition().getStateDefinition().getPossibleStates()) {
+            if (interned.getValues().equals(this.getValues())) {
+                return interned;
+            }
+        }
+        return this; // Fallback if not found (shouldn't happen)
+    }
 
     public MachineRenderState(MachineDefinition owner, Reference2ObjectArrayMap<Property<?>, Comparable<?>> values,
                               MapCodec<MachineRenderState> propertiesCodec) {

src/main/java/com/gregtechceu/gtceu/data/machine/GTMachines.java

@@ -49,7 +49,6 @@
 import com.google.common.math.IntMath;
 import it.unimi.dsi.fastutil.Pair;
 
-import java.util.Iterator;
 import java.util.List;
 import java.util.function.BiConsumer;
 
@@ -1101,9 +1100,7 @@ public static void init() {
     }
 
     public static void bakeRenderStates(Registry<MachineDefinition> registry) {
-        Iterator<MachineDefinition> iter = registry.iterator();
-        while (iter.hasNext()) {
-            MachineDefinition machine = iter.next();
+        for (MachineDefinition machine : registry) {
             for (MachineRenderState renderState : machine.getStateDefinition().getPossibleStates()) {
                 MachineDefinition.RENDER_STATE_REGISTRY.add(renderState);
             }

src/main/java/com/gregtechceu/gtceu/syncdata/MachineRenderStatePayload.java

@@ -18,6 +18,10 @@ public class MachineRenderStatePayload extends ObjectTypedPayload<MachineRenderS
 
     @Override
     public void writePayload(RegistryFriendlyByteBuf buf) {
+        // Ensure we're using the interned state for registry lookup
+        if (payload != null) {
+            payload = payload.intern();
+        }
         buf.writeById(MachineDefinition.RENDER_STATE_REGISTRY::getId, payload);
     }