Upgrade to 1.14.2

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

diff --git a/src/main/java/com/irtimaled/bbor/common/CommonProxy.java b/src/main/java/com/irtimaled/bbor/common/CommonProxy.java
index c447f11b95fb10774d2ca6ce32faa5428d3b126f..b39613757230eceebc55cb616c8ef59baf9d9931 100644 (file)
--- a/src/main/java/com/irtimaled/bbor/common/CommonProxy.java
+++ b/src/main/java/com/irtimaled/bbor/common/CommonProxy.java
@@ -1,17 +1,11 @@
 package com.irtimaled.bbor.common;
 
 import com.irtimaled.bbor.Logger;
-import com.irtimaled.bbor.common.chunkProcessors.AbstractChunkProcessor;
-import com.irtimaled.bbor.common.chunkProcessors.EndChunkProcessor;
-import com.irtimaled.bbor.common.chunkProcessors.NetherChunkProcessor;
-import com.irtimaled.bbor.common.chunkProcessors.OverworldChunkProcessor;
 import com.irtimaled.bbor.common.events.*;
 import com.irtimaled.bbor.common.messages.AddBoundingBox;
 import com.irtimaled.bbor.common.messages.InitializeClient;
 import com.irtimaled.bbor.common.messages.PayloadBuilder;
-import com.irtimaled.bbor.common.messages.RemoveBoundingBox;
 import com.irtimaled.bbor.common.models.AbstractBoundingBox;
-import com.irtimaled.bbor.common.models.BoundingBoxMobSpawner;
 import com.irtimaled.bbor.common.models.ServerPlayer;
 
 import java.util.HashMap;
@@ -21,25 +15,22 @@ import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 
 public class CommonProxy {
-    private Map<Integer, ServerPlayer> players = new ConcurrentHashMap<>();
-    private Map<Integer, Set<AbstractBoundingBox>> playerBoundingBoxesCache = new HashMap<>();
-    private Map<Integer, VillageProcessor> villageProcessors = new HashMap<>();
-    private Map<Integer, AbstractChunkProcessor> chunkProcessors = new HashMap<>();
+    private final Map<Integer, ServerPlayer> players = new ConcurrentHashMap<>();
+    private final Map<Integer, Set<AbstractBoundingBox>> playerBoundingBoxesCache = new HashMap<>();
+    private final Map<Integer, StructureProcessor> structureProcessors = new HashMap<>();
     private final Map<Integer, BoundingBoxCache> dimensionCache = new ConcurrentHashMap<>();
     private Long seed = null;
     private Integer spawnX = null;
     private Integer spawnZ = null;
 
     public void init() {
+        BoundingBoxType.registerTypes();
         EventBus.subscribe(WorldLoaded.class, this::worldLoaded);
-        EventBus.subscribe(ChunkLoaded.class, this::chunkLoaded);
-        EventBus.subscribe(MobSpawnerBroken.class, this::mobSpawnerBroken);
+        EventBus.subscribe(StructuresLoaded.class, this::structuresLoaded);
         EventBus.subscribe(PlayerLoggedIn.class, this::playerLoggedIn);
         EventBus.subscribe(PlayerLoggedOut.class, this::playerLoggedOut);
         EventBus.subscribe(PlayerSubscribed.class, this::onPlayerSubscribed);
-        EventBus.subscribe(ServerWorldTick.class, this::serverWorldTick);
         EventBus.subscribe(ServerTick.class, e -> serverTick());
-        EventBus.subscribe(VillageRemoved.class, this::onVillageRemoved);
     }
 
     protected void setSeed(long seed) {
@@ -54,31 +45,26 @@ public class CommonProxy {
     private void worldLoaded(WorldLoaded event) {
         int dimensionId = event.getDimensionId();
         long seed = event.getSeed();
-        BoundingBoxCache boundingBoxCache = getOrCreateCache(dimensionId);
-        AbstractChunkProcessor chunkProcessor = null;
-        switch (dimensionId) {
-            case Dimensions.OVERWORLD:
-                setSeed(seed);
-                setWorldSpawn(event.getSpawnX(), event.getSpawnZ());
-                chunkProcessor = new OverworldChunkProcessor(boundingBoxCache);
-                break;
-            case Dimensions.NETHER:
-                chunkProcessor = new NetherChunkProcessor(boundingBoxCache);
-                break;
-            case Dimensions.THE_END:
-                chunkProcessor = new EndChunkProcessor(boundingBoxCache);
-                break;
+        if (dimensionId == Dimensions.OVERWORLD) {
+            setSeed(seed);
+            setWorldSpawn(event.getSpawnX(), event.getSpawnZ());
         }
         Logger.info("create world dimension: %s (seed: %d)", dimensionId, seed);
-        chunkProcessors.put(dimensionId, chunkProcessor);
-        villageProcessors.put(dimensionId, new VillageProcessor(dimensionId, boundingBoxCache));
     }
 
-    private void chunkLoaded(ChunkLoaded event) {
-        AbstractChunkProcessor chunkProcessor = chunkProcessors.get(event.getDimensionId());
-        if (chunkProcessor == null) return;
+    private void structuresLoaded(StructuresLoaded event) {
+        int dimensionId = event.getDimensionId();
+        StructureProcessor structureProcessor = getStructureProcessor(dimensionId);
+        structureProcessor.process(event.getStructures());
+    }
 
-        chunkProcessor.process(event.getChunk());
+    private StructureProcessor getStructureProcessor(int dimensionId) {
+        StructureProcessor structureProcessor = structureProcessors.get(dimensionId);
+        if (structureProcessor == null) {
+            structureProcessor = new StructureProcessor(getOrCreateCache(dimensionId));
+            structureProcessors.put(dimensionId, structureProcessor);
+        }
+        return structureProcessor;
     }
 
     private void playerLoggedIn(PlayerLoggedIn event) {
@@ -95,27 +81,6 @@ public class CommonProxy {
         playerBoundingBoxesCache.remove(playerId);
     }
 
-    private void onVillageRemoved(VillageRemoved event) {
-        sendRemoveBoundingBox(event.getDimensionId(), event.getVillage());
-    }
-
-    private void sendRemoveBoundingBox(int dimensionId, AbstractBoundingBox boundingBox) {
-        PayloadBuilder payload = RemoveBoundingBox.getPayload(dimensionId, boundingBox);
-        if (payload == null) return;
-
-        for (Map.Entry<Integer, ServerPlayer> playerEntry : players.entrySet()) {
-            int playerId = playerEntry.getKey();
-            ServerPlayer player = playerEntry.getValue();
-            if (player.getDimensionId() == dimensionId) {
-                player.sendPacket(payload);
-
-                if (playerBoundingBoxesCache.containsKey(playerId)) {
-                    playerBoundingBoxesCache.get(playerId).remove(boundingBox);
-                }
-            }
-        }
-    }
-
     private void onPlayerSubscribed(PlayerSubscribed event) {
         int playerId = event.getPlayerId();
         ServerPlayer player = event.getPlayer();
@@ -147,20 +112,6 @@ public class CommonProxy {
         }
     }
 
-    protected void removeBoundingBox(int dimensionId, AbstractBoundingBox key) {
-        BoundingBoxCache cache = getCache(dimensionId);
-        if (cache == null) return;
-
-        cache.removeBoundingBox(key);
-    }
-
-    private void mobSpawnerBroken(MobSpawnerBroken event) {
-        int dimensionId = event.getDimensionId();
-        AbstractBoundingBox boundingBox = BoundingBoxMobSpawner.from(event.getPos());
-        removeBoundingBox(dimensionId, boundingBox);
-        sendRemoveBoundingBox(dimensionId, boundingBox);
-    }
-
     private void serverTick() {
         for (Map.Entry<Integer, ServerPlayer> playerEntry : players.entrySet()) {
             int playerId = playerEntry.getKey();
@@ -170,13 +121,6 @@ public class CommonProxy {
         }
     }
 
-    private void serverWorldTick(ServerWorldTick event) {
-        VillageProcessor villageProcessor = villageProcessors.get(event.getDimensionId());
-        if (villageProcessor == null) return;
-
-        villageProcessor.process(event.getWorld());
-    }
-
     protected BoundingBoxCache getCache(int dimensionId) {
         return dimensionCache.get(dimensionId);
     }
@@ -186,10 +130,7 @@ public class CommonProxy {
     }
 
     protected void clearCaches() {
-        for (VillageProcessor villageProcessor : villageProcessors.values()) {
-            villageProcessor.clear();
-        }
-        villageProcessors.clear();
+        structureProcessors.clear();
         for (BoundingBoxCache cache : dimensionCache.values()) {
             cache.clear();
         }