Downgrade to 1.12.2

[BoundingBoxOutlineReloaded.git] / src / main / java / com / irtimaled / bbor / common / chunkProcessors / AbstractChunkProcessor.java

diff --git a/src/main/java/com/irtimaled/bbor/common/chunkProcessors/AbstractChunkProcessor.java b/src/main/java/com/irtimaled/bbor/common/chunkProcessors/AbstractChunkProcessor.java
index efb75941bb6c002b787bf0be21749f07e4909f89..8bd43bd5340af2df0daa10acd19f0258f84d1c62 100644 (file)
--- a/src/main/java/com/irtimaled/bbor/common/chunkProcessors/AbstractChunkProcessor.java
+++ b/src/main/java/com/irtimaled/bbor/common/chunkProcessors/AbstractChunkProcessor.java
@@ -9,18 +9,21 @@ import com.irtimaled.bbor.common.models.BoundingBoxStructure;
 import com.irtimaled.bbor.common.models.Coords;
 import net.minecraft.tileentity.TileEntity;
 import net.minecraft.tileentity.TileEntityMobSpawner;
-import net.minecraft.util.math.MutableBoundingBox;
+import net.minecraft.util.math.ChunkPos;
 import net.minecraft.world.chunk.Chunk;
-import net.minecraft.world.gen.feature.structure.StructurePiece;
-import net.minecraft.world.gen.feature.structure.StructureStart;
+import net.minecraft.world.chunk.IChunkProvider;
+import net.minecraft.world.gen.ChunkProviderServer;
+import net.minecraft.world.gen.IChunkGenerator;
+import net.minecraft.world.gen.structure.MapGenStructure;
+import net.minecraft.world.gen.structure.StructureBoundingBox;
+import net.minecraft.world.gen.structure.StructureComponent;
+import net.minecraft.world.gen.structure.StructureStart;
 
-import java.util.Collection;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
+import java.util.*;
+import java.util.function.Function;
 
 public abstract class AbstractChunkProcessor {
-    Set<BoundingBoxType> supportedStructures = new HashSet<>();
+    Map<BoundingBoxType, Function<IChunkGenerator, Collection<StructureStart>>> supportedStructures = new HashMap<>();
 
     AbstractChunkProcessor(BoundingBoxCache boundingBoxCache) {
         this.boundingBoxCache = boundingBoxCache;
@@ -28,31 +31,49 @@ public abstract class AbstractChunkProcessor {
 
     private final BoundingBoxCache boundingBoxCache;
 
-    private void addStructures(BoundingBoxType type, Map<String, StructureStart> structureMap) {
-        StructureStart structureStart = structureMap.get(type.getName());
-        if (structureStart == null) return;
+    static <T extends IChunkGenerator, R extends MapGenStructure> Collection<StructureStart> getStructures(T chunkGenerator, Class<R> generatorClass) {
+        Class<T> chunkGeneratorClass = (Class<T>) chunkGenerator.getClass();
+        R structureGenerator = ReflectionHelper.getPrivateValue(chunkGeneratorClass, chunkGenerator, generatorClass);
+        if (structureGenerator != null) {
+            Map<ChunkPos, StructureStart> structureMap = ReflectionHelper.getPrivateValue(MapGenStructure.class, structureGenerator, Map.class);
+            return structureMap.values();
+        }
+        return Collections.emptyList();
+    }
+
+    Collection<StructureStart> getStructuresWithComponent(Collection<StructureStart> structures, Class structureComponent) {
+        Collection<StructureStart> validStructures = new HashSet<>();
+        for (StructureStart structure : structures) {
+            if (structure.getComponents().get(0).getClass().equals(structureComponent)) {
+                validStructures.add(structure);
+            }
+        }
+        return validStructures;
+    }
 
-        MutableBoundingBox bb = structureStart.getBoundingBox();
+
+    private void addStructures(BoundingBoxType type, StructureStart structureStart) {
+        StructureBoundingBox bb = structureStart.getBoundingBox();
         if (bb == null) return;
 
         AbstractBoundingBox boundingBox = buildStructure(bb, type);
         if (boundingBoxCache.isCached(boundingBox)) return;
 
         Set<AbstractBoundingBox> structureBoundingBoxes = new HashSet<>();
-        for (StructurePiece structureComponent : structureStart.getComponents()) {
+        for (StructureComponent structureComponent : structureStart.getComponents()) {
             structureBoundingBoxes.add(buildStructure(structureComponent.getBoundingBox(), type));
         }
         boundingBoxCache.addBoundingBoxes(boundingBox, structureBoundingBoxes);
     }
 
-    private AbstractBoundingBox buildStructure(MutableBoundingBox bb, BoundingBoxType type) {
+    private AbstractBoundingBox buildStructure(StructureBoundingBox bb, BoundingBoxType type) {
         Coords min = new Coords(bb.minX, bb.minY, bb.minZ);
         Coords max = new Coords(bb.maxX, bb.maxY, bb.maxZ);
         return BoundingBoxStructure.from(min, max, type);
     }
 
     private void addMobSpawners(Chunk chunk) {
-        Collection<TileEntity> tileEntities = chunk.getTileEntityMap().values();
+        Collection<TileEntity> tileEntities = chunk.getWorld().loadedTileEntityList;
         for (TileEntity tileEntity : tileEntities) {
             TileEntityMobSpawner spawner = TypeHelper.as(tileEntity, TileEntityMobSpawner.class);
             if (spawner != null) {
@@ -63,10 +84,14 @@ public abstract class AbstractChunkProcessor {
     }
 
     public void process(Chunk chunk) {
-        Map<String, StructureStart> structureMap = chunk.getStructureStarts();
-        if (structureMap.size() > 0) {
-            supportedStructures.forEach(type -> addStructures(type, structureMap));
-        }
+        IChunkProvider chunkProvider = chunk.getWorld().getChunkProvider();
+        IChunkGenerator chunkGenerator = ReflectionHelper.getPrivateValue(ChunkProviderServer.class, (ChunkProviderServer) chunkProvider, IChunkGenerator.class);
+        supportedStructures.forEach((type, supplier) ->
+                {
+                    Collection<StructureStart> structureStarts = supplier.apply(chunkGenerator);
+                    structureStarts.forEach(structureStart -> addStructures(type, structureStart));
+                }
+        );
         addMobSpawners(chunk);
     }
 }