Move config to client module

[BoundingBoxOutlineReloaded.git] / src / main / java / com / irtimaled / bbor / client / ClientProxy.java

diff --git a/src/main/java/com/irtimaled/bbor/client/ClientProxy.java b/src/main/java/com/irtimaled/bbor/client/ClientProxy.java
index a71eed56e3c9aa373b03b76900e1e22e28708bfa..c85cb93447fcfc9ce1070b359a31301b010834ed 100644 (file)
--- a/src/main/java/com/irtimaled/bbor/client/ClientProxy.java
+++ b/src/main/java/com/irtimaled/bbor/client/ClientProxy.java
@@ -1,89 +1,94 @@
 package com.irtimaled.bbor.client;
 
+import com.irtimaled.bbor.client.config.ConfigManager;
 import com.irtimaled.bbor.client.events.*;
-import com.irtimaled.bbor.common.*;
-import com.irtimaled.bbor.common.events.Tick;
-import com.irtimaled.bbor.common.models.BoundingBox;
-import com.irtimaled.bbor.config.ConfigManager;
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.settings.KeyBinding;
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.network.NetworkManager;
-import net.minecraft.world.dimension.DimensionType;
-
-import java.net.InetSocketAddress;
-import java.net.SocketAddress;
-import java.util.Set;
+import com.irtimaled.bbor.client.gui.LoadSavesScreen;
+import com.irtimaled.bbor.client.gui.SettingsScreen;
+import com.irtimaled.bbor.client.keyboard.Key;
+import com.irtimaled.bbor.client.keyboard.KeyListener;
+import com.irtimaled.bbor.client.providers.*;
+import com.irtimaled.bbor.common.BoundingBoxCache;
+import com.irtimaled.bbor.common.CommonProxy;
+import com.irtimaled.bbor.common.EventBus;
+import com.irtimaled.bbor.common.VillageColorCache;
 
 public class ClientProxy extends CommonProxy {
-    public static final String KeyCategory = "Bounding Box Outline Reloaded";
-    public static KeyBinding ActiveHotKey = new KeyBinding("Toggle On/Off", 0x42, KeyCategory);
-    public static KeyBinding OuterBoxOnlyHotKey = new KeyBinding("Toggle Display Outer Box Only", 0x4f, KeyCategory);
+    static {
+        Key mainKey = KeyListener.register("bbor.key.toggleActive", "key.keyboard.b")
+                .onKeyPressHandler(ClientRenderer::toggleActive);
+        mainKey.register("key.keyboard.g")
+                .onKeyPressHandler(SettingsScreen::show);
+        mainKey.register("key.keyboard.o")
+                .onKeyPressHandler(() -> ConfigManager.Toggle(ConfigManager.outerBoxesOnly));
+        mainKey.register("key.keyboard.l")
+                .onKeyPressHandler(LoadSavesScreen::show);
+    }
 
-    private boolean active;
-    private boolean outerBoxOnly;
-    private ClientRenderer renderer;
+    public ClientProxy() {
+        ConfigManager.loadConfig();
+    }
 
     @Override
     public void init() {
-        registerEventHandlers();
-        ClientDimensionCache clientDimensionCache = new ClientDimensionCache();
-        renderer = new ClientRenderer(clientDimensionCache);
-        dimensionCache = clientDimensionCache;
+        super.init();
+        EventBus.subscribe(DisconnectedFromRemoteServer.class, e -> disconnectedFromServer());
+        EventBus.subscribe(InitializeClientReceived.class, this::onInitializeClientReceived);
+        EventBus.subscribe(AddBoundingBoxReceived.class, this::addBoundingBox);
+        EventBus.subscribe(RemoveBoundingBoxReceived.class, this::onRemoveBoundingBoxReceived);
+        EventBus.subscribe(UpdateWorldSpawnReceived.class, this::onUpdateWorldSpawnReceived);
+        EventBus.subscribe(SaveLoaded.class, e -> clear());
+
+        ClientRenderer.registerProvider(new CacheProvider(this::getCache));
+
+        KeyListener.init();
     }
 
-    @Override
-    protected void registerEventHandlers() {
-        super.registerEventHandlers();
-        EventBus.subscribe(Render.class, e -> render(e.getPartialTicks()));
-        EventBus.subscribe(KeyPressed.class, e -> keyPressed());
-        EventBus.subscribe(ConnectedToRemoteServer.class, e -> connectedToServer(e.getNetworkManager()));
-        EventBus.subscribe(DisconnectedFromRemoteServer.class, e -> disconnectedFromServer());
-        EventBus.subscribe(InitializeClientReceived.class, e -> dimensionCache.setWorldData(e.getSeed(), e.getSpawnX(), e.getSpawnZ()));
-        EventBus.subscribe(AddBoundingBoxReceived.class, e -> addBoundingBox(e.getDimensionType(), e.getKey(), e.getBoundingBoxes()));
-        EventBus.subscribe(RemoveBoundingBoxReceived.class, e -> removeBoundingBox(e.getDimensionType(), e.getKey()));
+    private void disconnectedFromServer() {
+        ClientRenderer.deactivate();
+        if (ConfigManager.keepCacheBetweenSessions.get()) return;
+        clear();
     }
 
-    private void render(float partialTicks) {
-        EntityPlayer entityPlayer = Minecraft.getInstance().player;
-        PlayerData.setPlayerPosition(partialTicks, entityPlayer);
+    private void clear() {
+        SlimeChunkProvider.clear();
+        WorldSpawnProvider.clear();
+        SpawningSphereProvider.clear();
+        CustomBeaconProvider.clear();
+        CustomBoxProvider.clear();
+        BiomeBorderProvider.clear();
+        VillageColorCache.clear();
+        clearCaches();
+    }
+
+    private void addBoundingBox(AddBoundingBoxReceived event) {
+        BoundingBoxCache cache = getOrCreateCache(event.getDimensionId());
+        if (cache == null) return;
 
-        if (this.active) {
-            renderer.render(DimensionType.getById(entityPlayer.dimension), outerBoxOnly);
-        }
+        cache.addBoundingBoxes(event.getKey(), event.getBoundingBoxes());
     }
 
-    private void keyPressed() {
-        if (ActiveHotKey.isPressed()) {
-            active = !active;
-            if (active)
-                PlayerData.setActiveY();
-        } else if (OuterBoxOnlyHotKey.isPressed()) {
-            outerBoxOnly = !outerBoxOnly;
-        }
+    private void onRemoveBoundingBoxReceived(RemoveBoundingBoxReceived event) {
+        super.removeBoundingBox(event.getDimensionId(), event.getKey());
     }
 
-    private void connectedToServer(NetworkManager networkManager) {
-        SocketAddress remoteAddress = networkManager.getRemoteAddress();
-        if (remoteAddress instanceof InetSocketAddress) {
-            InetSocketAddress socketAddress = (InetSocketAddress) remoteAddress;
-            NBTFileParser.loadLocalDatFiles(socketAddress.getHostName(), socketAddress.getPort(), dimensionCache);
-        }
+    private void onInitializeClientReceived(InitializeClientReceived event) {
+        setWorldSpawn(event.getSpawnX(), event.getSpawnZ());
+        setSeed(event.getSeed());
     }
 
-    private void disconnectedFromServer() {
-        active = false;
-        if (ConfigManager.keepCacheBetweenSessions.getBoolean()) return;
-        VillageColorCache.clear();
-        clearCaches();
+    private void onUpdateWorldSpawnReceived(UpdateWorldSpawnReceived event) {
+        setWorldSpawn(event.getSpawnX(), event.getSpawnZ());
     }
 
-    private void addBoundingBox(DimensionType dimensionType, BoundingBox key, Set<BoundingBox> boundingBoxes) {
-        BoundingBoxCache cache = dimensionCache.get(dimensionType);
-        if (cache == null) {
-            dimensionCache.put(dimensionType, cache = new BoundingBoxCache());
-        }
+    @Override
+    protected void setSeed(long seed) {
+        super.setSeed(seed);
+        SlimeChunkProvider.setSeed(seed);
+    }
 
-        cache.addBoundingBoxes(key, boundingBoxes);
+    @Override
+    protected void setWorldSpawn(int spawnX, int spawnZ) {
+        super.setWorldSpawn(spawnX, spawnZ);
+        WorldSpawnProvider.setWorldSpawn(spawnX, spawnZ);
     }
-}
\ No newline at end of file
+}