X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;ds=sidebyside;f=src%2Fmain%2Fjava%2Fcom%2Firtimaled%2Fbbor%2Fcommon%2FCommonProxy.java;h=9606d02f0efc6017cea3fd3c132d2f7fc5b99fdf;hb=151a75b01318b334d1bcfe5b82bdf4100eb5e45c;hp=7a787456c6a1261ca048ad53d0f4e1320a43bc61;hpb=0c26e135cef356d773c8e198ab80e148dc42c5fc;p=BoundingBoxOutlineReloaded.git diff --git a/src/main/java/com/irtimaled/bbor/common/CommonProxy.java b/src/main/java/com/irtimaled/bbor/common/CommonProxy.java index 7a78745..9606d02 100644 --- a/src/main/java/com/irtimaled/bbor/common/CommonProxy.java +++ b/src/main/java/com/irtimaled/bbor/common/CommonProxy.java @@ -1,183 +1,169 @@ package com.irtimaled.bbor.common; import com.irtimaled.bbor.Logger; -import com.irtimaled.bbor.common.chunkProcessors.ChunkProcessor; -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.*; -import net.minecraft.world.World; -import net.minecraft.world.WorldServer; -import net.minecraft.world.chunk.Chunk; -import net.minecraft.world.dimension.DimensionType; +import com.irtimaled.bbor.common.models.AbstractBoundingBox; +import com.irtimaled.bbor.common.models.ServerPlayer; import java.util.HashMap; import java.util.HashSet; import java.util.Map; import java.util.Set; import java.util.concurrent.ConcurrentHashMap; -import java.util.function.Consumer; public class CommonProxy { - private Set players = new HashSet<>(); - private Map> playerBoundingBoxesCache = new HashMap<>(); - private Map villageProcessors = new HashMap<>(); - private Map chunkProcessors = new HashMap<>(); - private WorldData worldData = null; - private final Map dimensionCache = new ConcurrentHashMap<>(); + private final Map players = new ConcurrentHashMap<>(); + private final Map> playerBoundingBoxesCache = new HashMap<>(); + private final Map villageProcessors = new HashMap<>(); + private final Map chunkProcessors = new HashMap<>(); + private final Map dimensionCache = new ConcurrentHashMap<>(); + private Long seed = null; + private Integer spawnX = null; + private Integer spawnZ = null; public void init() { - EventBus.subscribe(WorldLoaded.class, e -> worldLoaded(e.getWorld())); - EventBus.subscribe(ChunkLoaded.class, e -> chunkLoaded(e.getChunk())); - EventBus.subscribe(MobSpawnerBroken.class, e -> mobSpawnerBroken(e.getDimensionType(), e.getPos())); - EventBus.subscribe(PlayerLoggedIn.class, e -> playerLoggedIn(e.getPlayer())); - EventBus.subscribe(PlayerLoggedOut.class, e -> playerLoggedOut(e.getPlayer())); - EventBus.subscribe(PlayerSubscribed.class, e -> sendBoundingBoxes(e.getPlayer())); - EventBus.subscribe(ServerWorldTick.class, e -> serverWorldTick(e.getWorld())); + EventBus.subscribe(WorldLoaded.class, this::worldLoaded); + EventBus.subscribe(ChunkLoaded.class, this::chunkLoaded); + 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, e -> sendRemoveBoundingBox(e.getDimensionType(), e.getVillage())); + EventBus.subscribe(VillageRemoved.class, this::onVillageRemoved); } - protected void setWorldData(long seed, int spawnX, int spawnZ) { - worldData = new WorldData(seed, spawnX, spawnZ); + protected void setSeed(long seed) { + this.seed = seed; } - private void worldLoaded(World world) { - if (world instanceof WorldServer) { - DimensionType dimensionType = world.dimension.getType(); - BoundingBoxCache boundingBoxCache = getOrCreateCache(dimensionType); - ChunkProcessor chunkProcessor = null; - if (dimensionType == DimensionType.OVERWORLD) { - setWorldData(world.getSeed(), world.getWorldInfo().getSpawnX(), world.getWorldInfo().getSpawnZ()); - chunkProcessor = new OverworldChunkProcessor(boundingBoxCache); - } - if (dimensionType == DimensionType.NETHER) { - chunkProcessor = new NetherChunkProcessor(boundingBoxCache); - } - if (dimensionType == DimensionType.THE_END) { - chunkProcessor = new EndChunkProcessor(boundingBoxCache); - } - Logger.info("create world dimension: %s, %s (seed: %d)", dimensionType, world.getClass().toString(), world.getSeed()); - chunkProcessors.put(dimensionType, chunkProcessor); - villageProcessors.put(dimensionType, new VillageProcessor(dimensionType, boundingBoxCache)); + protected void setWorldSpawn(int spawnX, int spawnZ) { + this.spawnX = spawnX; + this.spawnZ = spawnZ; + } + + private void worldLoaded(WorldLoaded event) { + int dimensionId = event.getDimensionId(); + long seed = event.getSeed(); + if (dimensionId == Dimensions.OVERWORLD) { + setSeed(seed); + setWorldSpawn(event.getSpawnX(), event.getSpawnZ()); } + Logger.info("create world dimension: %s (seed: %d)", dimensionId, seed); + BoundingBoxCache boundingBoxCache = getOrCreateCache(dimensionId); + chunkProcessors.put(dimensionId, new ChunkProcessor(boundingBoxCache)); + villageProcessors.put(dimensionId, new VillageProcessor(dimensionId, boundingBoxCache)); } - private void chunkLoaded(Chunk chunk) { - DimensionType dimensionType = chunk.getWorld().dimension.getType(); - ChunkProcessor chunkProcessor = chunkProcessors.get(dimensionType); - if (chunkProcessor != null) { - chunkProcessor.process(chunk); + private void chunkLoaded(ChunkLoaded event) { + ChunkProcessor chunkProcessor = chunkProcessors.get(event.getDimensionId()); + if (chunkProcessor == null) return; + + chunkProcessor.process(event.getChunk()); + } + + private void playerLoggedIn(PlayerLoggedIn event) { + if (seed == null || spawnX == null || spawnZ == null) { + return; } + ServerPlayer player = event.getPlayer(); + player.sendPacket(InitializeClient.getPayload(seed, spawnX, spawnZ)); } - private void playerLoggedIn(ServerPlayer player) { - player.sendPacket(InitializeClient.getPayload(worldData)); + private void playerLoggedOut(PlayerLoggedOut event) { + int playerId = event.getPlayerId(); + players.remove(playerId); + playerBoundingBoxesCache.remove(playerId); } - private void playerLoggedOut(ServerPlayer player) { - players.remove(player); - playerBoundingBoxesCache.remove(player); + private void onVillageRemoved(VillageRemoved event) { + sendRemoveBoundingBox(event.getDimensionId(), event.getVillage()); } - private void sendRemoveBoundingBox(DimensionType dimensionType, BoundingBox boundingBox) { - PayloadBuilder payload = RemoveBoundingBox.getPayload(dimensionType, boundingBox); + private void sendRemoveBoundingBox(int dimensionId, AbstractBoundingBox boundingBox) { + PayloadBuilder payload = RemoveBoundingBox.getPayload(dimensionId, boundingBox); if (payload == null) return; - for (ServerPlayer player : players) { - if (player.getDimensionType() == dimensionType) { + for (Map.Entry playerEntry : players.entrySet()) { + int playerId = playerEntry.getKey(); + ServerPlayer player = playerEntry.getValue(); + if (player.getDimensionId() == dimensionId) { player.sendPacket(payload); - if (playerBoundingBoxesCache.containsKey(player)) { - playerBoundingBoxesCache.get(player).remove(boundingBox); + if (playerBoundingBoxesCache.containsKey(playerId)) { + playerBoundingBoxesCache.get(playerId).remove(boundingBox); } } } } - private void sendBoundingBoxes(ServerPlayer player) { - DimensionType dimensionType = player.getDimensionType(); - players.add(player); - sendToPlayer(player, getCache(dimensionType)); + private void onPlayerSubscribed(PlayerSubscribed event) { + int playerId = event.getPlayerId(); + ServerPlayer player = event.getPlayer(); + players.put(playerId, player); + sendToPlayer(playerId, player); } - private void sendToPlayer(ServerPlayer player, BoundingBoxCache boundingBoxCache) { - if (boundingBoxCache == null) return; + private void sendToPlayer(int playerId, ServerPlayer player) { + for (Map.Entry entry : dimensionCache.entrySet()) { + int dimensionId = entry.getKey(); + BoundingBoxCache boundingBoxCache = entry.getValue(); + if (boundingBoxCache == null) return; - Map> cacheSubset = getBoundingBoxMap(player, boundingBoxCache.getBoundingBoxes()); + Set playerBoundingBoxes = playerBoundingBoxesCache.computeIfAbsent(playerId, k -> new HashSet<>()); - DimensionType dimensionType = player.getDimensionType(); - - for (BoundingBox key : cacheSubset.keySet()) { - Set boundingBoxes = cacheSubset.get(key); - PayloadBuilder payload = AddBoundingBox.getPayload(dimensionType, key, boundingBoxes); - if (payload != null) - player.sendPacket(payload); + Map> boundingBoxMap = boundingBoxCache.getBoundingBoxes(); + for (AbstractBoundingBox key : boundingBoxMap.keySet()) { + if (playerBoundingBoxes.contains(key)) { + continue; + } - if (!playerBoundingBoxesCache.containsKey(player)) { - playerBoundingBoxesCache.put(player, new HashSet<>()); - } - playerBoundingBoxesCache.get(player).add(key); - } - } + Set boundingBoxes = boundingBoxMap.get(key); + PayloadBuilder payload = AddBoundingBox.getPayload(dimensionId, key, boundingBoxes); + if (payload != null) + player.sendPacket(payload); - private Map> getBoundingBoxMap(ServerPlayer player, Map> boundingBoxMap) { - Map> cacheSubset = new HashMap<>(); - for (BoundingBox key : boundingBoxMap.keySet()) { - if (!playerBoundingBoxesCache.containsKey(player) || !playerBoundingBoxesCache.get(player).contains(key)) { - cacheSubset.put(key, boundingBoxMap.get(key)); + playerBoundingBoxes.add(key); } } - return cacheSubset; } - protected void removeBoundingBox(DimensionType dimensionType, BoundingBox key) { - BoundingBoxCache cache = getCache(dimensionType); + protected void removeBoundingBox(int dimensionId, AbstractBoundingBox key) { + BoundingBoxCache cache = getCache(dimensionId); if (cache == null) return; cache.removeBoundingBox(key); } - private void mobSpawnerBroken(DimensionType dimensionType, Coords pos) { - BoundingBox boundingBox = BoundingBoxMobSpawner.from(pos); - removeBoundingBox(dimensionType, boundingBox); - sendRemoveBoundingBox(dimensionType, boundingBox); - } - private void serverTick() { - for (ServerPlayer player : players) { - DimensionType dimensionType = player.getDimensionType(); - sendToPlayer(player, getCache(dimensionType)); + for (Map.Entry playerEntry : players.entrySet()) { + int playerId = playerEntry.getKey(); + ServerPlayer player = playerEntry.getValue(); + + sendToPlayer(playerId, player); } } - private void serverWorldTick(WorldServer world) { - DimensionType dimensionType = world.dimension.getType(); - VillageProcessor villageProcessor = villageProcessors.get(dimensionType); - if(villageProcessor == null) return; - - villageProcessor.process(world.getVillageCollection()); - } + private void serverWorldTick(ServerWorldTick event) { + VillageProcessor villageProcessor = villageProcessors.get(event.getDimensionId()); + if (villageProcessor == null) return; - protected BoundingBoxCache getCache(DimensionType dimensionType) { - return dimensionCache.get(dimensionType); + villageProcessor.process(event.getWorld()); } - protected BoundingBoxCache getOrCreateCache(DimensionType dimensionType) { - return dimensionCache.computeIfAbsent(dimensionType, dt -> new BoundingBoxCache()); + protected BoundingBoxCache getCache(int dimensionId) { + return dimensionCache.get(dimensionId); } - protected void runOnCache(DimensionType dimensionType, Consumer action) { - action.accept(getOrCreateCache(dimensionType)); + protected BoundingBoxCache getOrCreateCache(int dimensionId) { + return dimensionCache.computeIfAbsent(dimensionId, dt -> new BoundingBoxCache()); } protected void clearCaches() { - for(VillageProcessor villageProcessor : villageProcessors.values()) { + for (VillageProcessor villageProcessor : villageProcessors.values()) { villageProcessor.clear(); } villageProcessors.clear();