d

nms/v1_21_R7/src/main/java/art/arcane/iris/core/nms/v1_21_R7/CustomBiomeSource.java

@@ -25,6 +25,7 @@ import org.bukkit.craftbukkit.v1_21_R7.CraftWorld;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.util.ArrayList;
+import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Optional;
 import java.util.stream.Stream;
@@ -38,6 +39,7 @@ public class CustomBiomeSource extends BiomeSource {
     private final AtomicCache<RegistryAccess> registryAccess = new AtomicCache<>();
     private final RNG rng;
     private final KMap<String, Holder<Biome>> customBiomes;
+    private final Holder<Biome> fallbackBiome;
 
     public CustomBiomeSource(long seed, Engine engine, World world) {
         this.engine = engine;
@@ -45,24 +47,37 @@ public class CustomBiomeSource extends BiomeSource {
         this.biomeCustomRegistry = registry().lookup(Registries.BIOME).orElse(null);
         this.biomeRegistry = ((RegistryAccess) getFor(RegistryAccess.Frozen.class, ((CraftServer) Bukkit.getServer()).getHandle().getServer())).lookup(Registries.BIOME).orElse(null);
         this.rng = new RNG(engine.getSeedManager().getBiome());
-        this.customBiomes = fillCustomBiomes(biomeCustomRegistry, engine);
+        this.fallbackBiome = resolveFallbackBiome(this.biomeRegistry, this.biomeCustomRegistry);
+        this.customBiomes = fillCustomBiomes(this.biomeCustomRegistry, engine, this.fallbackBiome);
     }
 
-    private static List<Holder<Biome>> getAllBiomes(Registry<Biome> customRegistry, Registry<Biome> registry, Engine engine) {
-        List<Holder<Biome>> b = new ArrayList<>();
+    private static List<Holder<Biome>> getAllBiomes(Registry<Biome> customRegistry, Registry<Biome> registry, Engine engine, Holder<Biome> fallback) {
+        LinkedHashSet<Holder<Biome>> biomes = new LinkedHashSet<>();
+        if (fallback != null) {
+            biomes.add(fallback);
+        }
 
         for (IrisBiome i : engine.getAllBiomes()) {
             if (i.isCustom()) {
                 for (IrisBiomeCustom j : i.getCustomDerivitives()) {
-                    b.add(customRegistry.get(customRegistry.getResourceKey(customRegistry
-                            .getValue(Identifier.fromNamespaceAndPath(engine.getDimension().getLoadKey().toLowerCase(java.util.Locale.ROOT), j.getId().toLowerCase(java.util.Locale.ROOT)))).get()).get());
+                    Holder<Biome> customHolder = resolveCustomBiomeHolder(customRegistry, engine, j.getId());
+                    if (customHolder != null) {
+                        biomes.add(customHolder);
+                    } else if (fallback != null) {
+                        biomes.add(fallback);
+                    }
                 }
             } else {
-                b.add(NMSBinding.biomeToBiomeBase(registry, i.getVanillaDerivative()));
+                Holder<Biome> vanillaHolder = NMSBinding.biomeToBiomeBase(registry, i.getVanillaDerivative());
+                if (vanillaHolder != null) {
+                    biomes.add(vanillaHolder);
+                } else if (fallback != null) {
+                    biomes.add(fallback);
+                }
             }
         }
 
-        return b;
+        return new ArrayList<>(biomes);
     }
 
     private static Object getFor(Class<?> type, Object source) {
@@ -117,28 +132,28 @@ public class CustomBiomeSource extends BiomeSource {
                 ((RegistryAccess) getFor(RegistryAccess.Frozen.class, ((CraftServer) Bukkit.getServer()).getHandle().getServer()))
                         .lookup(Registries.BIOME).orElse(null),
                 ((CraftWorld) engine.getWorld().realWorld()).getHandle().registryAccess().lookup(Registries.BIOME).orElse(null),
-                engine).stream();
+                engine,
+                fallbackBiome).stream();
     }
-    private KMap<String, Holder<Biome>> fillCustomBiomes(Registry<Biome> customRegistry, Engine engine) {
+
+    private KMap<String, Holder<Biome>> fillCustomBiomes(Registry<Biome> customRegistry, Engine engine, Holder<Biome> fallback) {
         KMap<String, Holder<Biome>> m = new KMap<>();
+        if (customRegistry == null) {
+            return m;
+        }
 
         for (IrisBiome i : engine.getAllBiomes()) {
             if (i.isCustom()) {
                 for (IrisBiomeCustom j : i.getCustomDerivitives()) {
-                    Identifier resourceLocation = Identifier.fromNamespaceAndPath(engine.getDimension().getLoadKey().toLowerCase(java.util.Locale.ROOT), j.getId().toLowerCase(java.util.Locale.ROOT));
-                    Biome biome = customRegistry.getValue(resourceLocation);
-                    Optional<ResourceKey<Biome>> optionalBiomeKey = customRegistry.getResourceKey(biome);
-                    if (optionalBiomeKey.isEmpty()) {
+                    Holder<Biome> holder = resolveCustomBiomeHolder(customRegistry, engine, j.getId());
+                    if (holder == null) {
+                        if (fallback != null) {
+                            m.put(j.getId(), fallback);
+                        }
                         Iris.error("Cannot find biome for IrisBiomeCustom " + j.getId() + " from engine " + engine.getName());
                         continue;
                     }
-                    ResourceKey<Biome> biomeKey = optionalBiomeKey.get();
-                    Optional<Holder.Reference<Biome>> optionalReferenceHolder = customRegistry.get(biomeKey);
-                    if (optionalReferenceHolder.isEmpty()) {
-                        Iris.error("Cannot find reference to biome " + biomeKey + " for engine " + engine.getName());
-                        continue;
-                    }
-                    m.put(j.getId(), optionalReferenceHolder.get());
+                    m.put(j.getId(), holder);
                 }
             }
         }
@@ -159,11 +174,89 @@ public class CustomBiomeSource extends BiomeSource {
     public Holder<Biome> getNoiseBiome(int x, int y, int z, Climate.Sampler sampler) {
         int m = (y - engine.getMinHeight()) << 2;
         IrisBiome ib = engine.getComplex().getTrueBiomeStream().get(x << 2, z << 2);
-        if (ib.isCustom()) {
-            return customBiomes.get(ib.getCustomBiome(rng, x << 2, m, z << 2).getId());
-        } else {
-            org.bukkit.block.Biome v = ib.getSkyBiome(rng, x << 2, m, z << 2);
-            return NMSBinding.biomeToBiomeBase(biomeRegistry, v);
+        if (ib == null) {
+            return resolveFallbackBiome(biomeRegistry, biomeCustomRegistry);
         }
+
+        if (ib.isCustom()) {
+            IrisBiomeCustom custom = ib.getCustomBiome(rng, x << 2, m, z << 2);
+            if (custom != null) {
+                Holder<Biome> holder = customBiomes.get(custom.getId());
+                if (holder != null) {
+                    return holder;
+                }
+            }
+
+            return resolveFallbackBiome(biomeRegistry, biomeCustomRegistry);
+        }
+
+        org.bukkit.block.Biome v = ib.getSkyBiome(rng, x << 2, m, z << 2);
+        Holder<Biome> holder = NMSBinding.biomeToBiomeBase(biomeRegistry, v);
+        if (holder != null) {
+            return holder;
+        }
+
+        return resolveFallbackBiome(biomeRegistry, biomeCustomRegistry);
     }
-}
+
+    private static Holder<Biome> resolveCustomBiomeHolder(Registry<Biome> customRegistry, Engine engine, String customBiomeId) {
+        if (customRegistry == null || engine == null || customBiomeId == null || customBiomeId.isBlank()) {
+            return null;
+        }
+
+        Identifier resourceLocation = Identifier.fromNamespaceAndPath(
+                engine.getDimension().getLoadKey().toLowerCase(java.util.Locale.ROOT),
+                customBiomeId.toLowerCase(java.util.Locale.ROOT)
+        );
+        Biome biome = customRegistry.getValue(resourceLocation);
+        if (biome == null) {
+            return null;
+        }
+
+        Optional<ResourceKey<Biome>> optionalBiomeKey = customRegistry.getResourceKey(biome);
+        if (optionalBiomeKey.isEmpty()) {
+            return null;
+        }
+
+        Optional<Holder.Reference<Biome>> optionalReferenceHolder = customRegistry.get(optionalBiomeKey.get());
+        if (optionalReferenceHolder.isEmpty()) {
+            return null;
+        }
+
+        return optionalReferenceHolder.get();
+    }
+
+    private static Holder<Biome> resolveFallbackBiome(Registry<Biome> registry, Registry<Biome> customRegistry) {
+        Holder<Biome> plains = NMSBinding.biomeToBiomeBase(registry, org.bukkit.block.Biome.PLAINS);
+        if (plains != null) {
+            return plains;
+        }
+
+        Holder<Biome> vanilla = firstHolder(registry);
+        if (vanilla != null) {
+            return vanilla;
+        }
+
+        return firstHolder(customRegistry);
+    }
+
+    private static Holder<Biome> firstHolder(Registry<Biome> registry) {
+        if (registry == null) {
+            return null;
+        }
+
+        for (Biome biome : registry) {
+            Optional<ResourceKey<Biome>> optionalBiomeKey = registry.getResourceKey(biome);
+            if (optionalBiomeKey.isEmpty()) {
+                continue;
+            }
+
+            Optional<Holder.Reference<Biome>> optionalHolder = registry.get(optionalBiomeKey.get());
+            if (optionalHolder.isPresent()) {
+                return optionalHolder.get();
+            }
+        }
+
+        return null;
+    }
+}

nms/v1_21_R7/src/main/java/art/arcane/iris/core/nms/v1_21_R7/IrisChunkGenerator.java

@@ -402,12 +402,6 @@ public class IrisChunkGenerator extends CustomChunkGenerator {
         delegate.validate();
     }
 
-    @Override
-    @SuppressWarnings("deprecation")
-    public BiomeGenerationSettings getBiomeGenerationSettings(Holder<Biome> holder) {
-        return delegate.getBiomeGenerationSettings(holder);
-    }
-
     static {
         Field biomeSource = null;
         for (Field field : ChunkGenerator.class.getDeclaredFields()) {

nms/v1_21_R7/src/main/java/art/arcane/iris/core/nms/v1_21_R7/NMSBinding.java

@@ -108,7 +108,6 @@ public class NMSBinding implements INMSBinding {
     private final AtomicCache<MCAPalette<BlockState>> globalCache = new AtomicCache<>();
     private final AtomicCache<RegistryAccess> registryAccess = new AtomicCache<>();
     private final AtomicCache<Method> byIdRef = new AtomicCache<>();
-    private Field biomeStorageCache = null;
 
     private static Object getFor(Class<?> type, Object source) {
         Object o = fieldFor(type, source);
@@ -390,7 +389,11 @@ public class NMSBinding implements INMSBinding {
 
     @Override
     public KList<Biome> getBiomes() {
-        return new KList<>(Biome.values()).qadd(Biome.CHERRY_GROVE).qdel(Biome.CUSTOM);
+        KList<Biome> biomes = new KList<>();
+        for (Biome biome : org.bukkit.Registry.BIOME) {
+            biomes.add(biome);
+        }
+        return biomes;
     }
 
     @Override
@@ -407,7 +410,12 @@ public class NMSBinding implements INMSBinding {
             }
         }
 
-        return biome.ordinal();
+        List<Biome> biomes = new ArrayList<>();
+        for (Biome entry : org.bukkit.Registry.BIOME) {
+            biomes.add(entry);
+        }
+        int index = biomes.indexOf(biome);
+        return Math.max(index, 0);
     }
 
     private MCAIdMap<net.minecraft.world.level.biome.Biome> getBiomeMapping() {
@@ -488,38 +496,6 @@ public class NMSBinding implements INMSBinding {
         c.markUnsaved();
     }
 
-    @Override
-    public void forceBiomeInto(int x, int y, int z, Object somethingVeryDirty, ChunkGenerator.BiomeGrid chunk) {
-        try {
-            ChunkAccess s = (ChunkAccess) getFieldForBiomeStorage(chunk).get(chunk);
-            Holder<net.minecraft.world.level.biome.Biome> biome = (Holder<net.minecraft.world.level.biome.Biome>) somethingVeryDirty;
-            s.setBiome(x, y, z, biome);
-        } catch (IllegalAccessException e) {
-            Iris.reportError(e);
-            e.printStackTrace();
-        }
-    }
-
-    private Field getFieldForBiomeStorage(Object storage) {
-        Field f = biomeStorageCache;
-
-        if (f != null) {
-            return f;
-        }
-        try {
-            f = storage.getClass().getDeclaredField("biome");
-            f.setAccessible(true);
-            return f;
-        } catch (Throwable e) {
-            Iris.reportError(e);
-            e.printStackTrace();
-            Iris.error(storage.getClass().getCanonicalName());
-        }
-
-        biomeStorageCache = f;
-        return null;
-    }
-
     @Override
     public MCAPaletteAccess createPalette() {
         MCAIdMapper<BlockState> registry = registryCache.aquireNasty(() -> {
@@ -598,31 +574,41 @@ public class NMSBinding implements INMSBinding {
     }
 
     public Vector3d getBoundingbox(org.bukkit.entity.EntityType entity) {
-        Field[] fields = EntityType.class.getDeclaredFields();
-        for (Field field : fields) {
-            if (Modifier.isStatic(field.getModifiers()) && field.getType().equals(EntityType.class)) {
-                try {
-                    EntityType entityType = (EntityType) field.get(null);
-                    if (entityType.getDescriptionId().equals("entity.minecraft." + entity.name().toLowerCase())) {
-                        Vector<Float> v1 = new Vector<>();
-                        v1.add(entityType.getHeight());
-                        entityType.getDimensions();
-                        Vector3d box = new Vector3d( entityType.getWidth(), entityType.getHeight(),  entityType.getWidth());
-                        //System.out.println("Entity Type: " + entityType.getDescriptionId() + ", " + "Height: " + height + ", Width: " + width);
-                        return box;
-                    }
-                } catch (IllegalAccessException e) {
-                    Iris.error("Unable to get entity dimensions!");
-                    e.printStackTrace();
+        if (entity == null) {
+            return null;
+        }
+
+        try {
+            String descriptionId = "entity.minecraft." + entity.name().toLowerCase(Locale.ROOT);
+            Field[] fields = EntityType.class.getDeclaredFields();
+            for (Field field : fields) {
+                if (!Modifier.isStatic(field.getModifiers()) || !field.getType().equals(EntityType.class)) {
+                    continue;
+                }
+
+                EntityType entityType = (EntityType) field.get(null);
+                if (entityType == null) {
+                    continue;
+                }
+
+                if (descriptionId.equals(entityType.getDescriptionId())) {
+                    return new Vector3d(entityType.getWidth(), entityType.getHeight(), entityType.getWidth());
                 }
             }
+            return null;
+        } catch (Throwable e) {
+            Iris.error("Unable to get entity dimensions for " + entity + "!");
+            Iris.reportError(e);
+            return null;
         }
-        return null;
     }
 
 
     @Override
     public Entity spawnEntity(Location location,  org.bukkit.entity.EntityType type, CreatureSpawnEvent.SpawnReason reason) {
+        if (location == null || location.getWorld() == null || type == null || type.getEntityClass() == null) {
+            return null;
+        }
         return ((CraftWorld) location.getWorld()).spawn(location, type.getEntityClass(), null, reason);
     }
 
@@ -670,7 +656,49 @@ public class NMSBinding implements INMSBinding {
     }
 
     public static Holder<net.minecraft.world.level.biome.Biome> biomeToBiomeBase(Registry<net.minecraft.world.level.biome.Biome> registry, Biome biome) {
-        return registry.getOrThrow(ResourceKey.create(Registries.BIOME, CraftNamespacedKey.toMinecraft(biome.getKey())));
+        if (registry == null || biome == null) {
+            return null;
+        }
+
+        NamespacedKey biomeKey = resolveBiomeKey(biome);
+        if (biomeKey == null) {
+            return null;
+        }
+
+        ResourceKey<net.minecraft.world.level.biome.Biome> key = ResourceKey.create(Registries.BIOME, CraftNamespacedKey.toMinecraft(biomeKey));
+        return registry.get(key).orElse(null);
+    }
+
+    private static NamespacedKey resolveBiomeKey(Biome biome) {
+        Object keyOrNullValue = invokeNoThrow(biome, "getKeyOrNull", new Class<?>[0]);
+        if (keyOrNullValue instanceof NamespacedKey namespacedKey) {
+            return namespacedKey;
+        }
+
+        Object keyOrThrowValue = invokeNoThrow(biome, "getKeyOrThrow", new Class<?>[0]);
+        if (keyOrThrowValue instanceof NamespacedKey namespacedKey) {
+            return namespacedKey;
+        }
+
+        Object keyValue = invokeNoThrow(biome, "getKey", new Class<?>[0]);
+        if (keyValue instanceof NamespacedKey namespacedKey) {
+            return namespacedKey;
+        }
+
+        return null;
+    }
+
+    private static Object invokeNoThrow(Object target, String methodName, Class<?>[] parameterTypes, Object... args) {
+        if (target == null) {
+            return null;
+        }
+
+        try {
+            Method method = target.getClass().getMethod(methodName, parameterTypes);
+            return method.invoke(target, args);
+        } catch (Throwable ignored) {
+            return null;
+        }
     }
 
     @Override