java/com/irtimaled/bbor/DimensionProcessor.java

   1 package com.irtimaled.bbor;
   2
   3 import net.minecraft.util.BlockPos;
   4 import net.minecraft.village.Village;
   5 import net.minecraft.world.ChunkCoordIntPair;
   6 import net.minecraft.world.World;
   7 import net.minecraft.world.chunk.IChunkProvider;
   8 import net.minecraft.world.gen.ChunkProviderGenerate;
   9 import net.minecraft.world.gen.ChunkProviderHell;
  10 import net.minecraft.world.gen.structure.ComponentScatteredFeaturePieces;
  11 import net.minecraft.world.gen.structure.MapGenStructure;
  12 import net.minecraft.world.gen.structure.StructureComponent;
  13 import net.minecraft.world.gen.structure.StructureStart;
  14
  15 import java.awt.*;
  16 import java.util.*;
  17 import java.util.List;
  18
  19 public class DimensionProcessor extends BoundingBoxCache {
  20
  21     private ConfigManager configManager;
  22     private World world;
  23     private IEventHandler eventHandler;
  24
  25     public DimensionProcessor(IEventHandler eventHandler, ConfigManager configManager, World world, int dimensionId, IChunkProvider chunkProvider) {
  26         this.eventHandler = eventHandler;
  27         this.configManager = configManager;
  28         this.world = world;
  29         this.dimensionId = dimensionId;
  30         this.chunkProvider = chunkProvider;
  31         villageCache = new HashSet<BoundingBox>();
  32         slimeChunkCache = new HashSet<BoundingBox>();
  33         worldSpawnCache = new HashSet<BoundingBox>();
  34     }
  35
  36     private int dimensionId;
  37     private IChunkProvider chunkProvider;
  38     private Set<BoundingBox> villageCache;
  39     private Set<BoundingBox> slimeChunkCache;
  40     private Set<BoundingBox> worldSpawnCache;
  41
  42     private boolean closed = false;
  43
  44     @Override
  45     public void close() {
  46         closed = true;
  47         chunkProvider = null;
  48         villageCache.clear();
  49         slimeChunkCache.clear();
  50         worldSpawnCache.clear();
  51         super.close();
  52     }
  53
  54     private static <T extends IChunkProvider> Collection<StructureStart> getStructures(T chunkProvider, int method) {
  55         Class<T> chunkProviderClass = (Class<T>) chunkProvider.getClass();
  56         MapGenStructure structureGenerator = ReflectionHelper.getPrivateValue(chunkProviderClass, chunkProvider, method, MapGenStructure.class);
  57         if (structureGenerator != null) {
  58             Map<ChunkCoordIntPair, StructureStart> structureMap = ReflectionHelper.getPrivateValue(MapGenStructure.class, structureGenerator, 1);
  59             return structureMap.values();
  60         }
  61         return Collections.emptyList();
  62     }
  63
  64     private Map<StructureType, Collection<StructureStart>> getStructures() {
  65
  66         Map<StructureType, Collection<StructureStart>> structureMap = new HashMap<StructureType, Collection<StructureStart>>();
  67         if (chunkProvider instanceof ChunkProviderGenerate) {
  68             if (configManager.drawDesertTemples.getBoolean()) {
  69                 structureMap.put(StructureType.DesertTemple, getStructuresWithComponent(getStructures(chunkProvider, 20), ComponentScatteredFeaturePieces.DesertPyramid.class));
  70             }
  71
  72             if (configManager.drawJungleTemples.getBoolean()) {
  73                 structureMap.put(StructureType.JungleTemple, getStructuresWithComponent(getStructures(chunkProvider, 20), ComponentScatteredFeaturePieces.JunglePyramid.class));
  74             }
  75
  76             if (configManager.drawWitchHuts.getBoolean()) {
  77                 structureMap.put(StructureType.WitchHut, getStructuresWithComponent(getStructures(chunkProvider, 20), ComponentScatteredFeaturePieces.SwampHut.class));
  78             }
  79
  80             if (configManager.drawOceanMonuments.getBoolean()) {
  81                 structureMap.put(StructureType.OceanMonument, getStructures(chunkProvider, 22));
  82             }
  83
  84             if (configManager.drawStrongholds.getBoolean()) {
  85                 structureMap.put(StructureType.Stronghold, getStructures(chunkProvider, 17));
  86             }
  87
  88             if (configManager.drawMineShafts.getBoolean()) {
  89                 structureMap.put(StructureType.MineShaft, getStructures(chunkProvider, 19));
  90             }
  91         } else if (chunkProvider instanceof ChunkProviderHell) {
  92
  93             if (configManager.drawNetherFortresses.getBoolean()) {
  94                 structureMap.put(StructureType.NetherFortress, getStructures(chunkProvider, 22));
  95             }
  96         }
  97
  98         return structureMap;
  99     }
 100
 101     private Collection<StructureStart> getStructuresWithComponent(Collection<StructureStart> structures, Class structureComponent) {
 102         Collection<StructureStart> validStructures = new HashSet<StructureStart>();
 103         for (StructureStart structure : structures) {
 104             if (structure.getComponents().getFirst().getClass().equals(structureComponent)) {
 105                 validStructures.add(structure);
 106             }
 107         }
 108         return validStructures;
 109     }
 110
 111     @Override
 112     public synchronized void refresh() {
 113         if (closed) return;
 114
 115         Map<StructureType, Collection<StructureStart>> structureMap = getStructures();
 116         for (StructureType structureType : structureMap.keySet()) {
 117             Color color = structureType.getColor();
 118             for (StructureStart structureStart : structureMap.get(structureType)) {
 119                 BoundingBox boundingBox = BoundingBoxStructure.from(structureStart.getBoundingBox(), color);
 120                 if (!isCached(boundingBox)) {
 121                     Set<BoundingBox> structureBoundingBoxes = new HashSet<BoundingBox>();
 122                     Iterator structureComponents = structureStart.getComponents().iterator();
 123                     while (structureComponents.hasNext()) {
 124                         StructureComponent structureComponent = (StructureComponent) structureComponents.next();
 125                         structureBoundingBoxes.add(BoundingBoxStructure.from(structureComponent.getBoundingBox(), color));
 126                     }
 127                     addBoundingBoxes(boundingBox, structureBoundingBoxes);
 128                     Logger.info("[%d] new boundingBoxCacheMap entries: %d", dimensionId, structureBoundingBoxes.size());
 129                 }
 130             }
 131         }
 132
 133         if (configManager.drawVillages.getBoolean() &&
 134                 (world.getVillageCollection() != null)) {
 135
 136             Set<BoundingBox> villageBoundingBoxes = new HashSet<BoundingBox>();
 137             List<Village> villages = world.getVillageCollection().getVillageList();
 138             int c = 0;
 139             for (Village village : villages) {
 140                 BlockPos center = village.getCenter();
 141                 Integer radius = village.getVillageRadius();
 142                 int numVillagers = village.getNumVillagers();
 143                 int numVillageDoors = village.getNumVillageDoors();
 144                 villageBoundingBoxes.add(BoundingBoxVillage.from(center, radius, numVillagers, numVillageDoors));
 145             }
 146             processDelta(villageCache, villageBoundingBoxes);
 147
 148             villageCache = villageBoundingBoxes;
 149         }
 150     }
 151
 152     private void processDelta(Set<BoundingBox> oldBoundingBoxes, Set<BoundingBox> newBoundingBoxes) {
 153         for (BoundingBox bb : oldBoundingBoxes) {
 154             if (!newBoundingBoxes.contains(bb)) {
 155                 removeBoundingBox(bb);
 156                 eventHandler.boundingBoxRemoved(bb);
 157             } else {
 158                 if (!isCached(bb)) {
 159                     addBoundingBox(bb);
 160                 }
 161             }
 162         }
 163     }
 164 }