package com.irtimaled.bbor.client;
+import com.irtimaled.bbor.client.config.ConfigManager;
import com.irtimaled.bbor.client.events.*;
-import com.irtimaled.bbor.common.BoundingBoxType;
+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;
-import com.irtimaled.bbor.common.models.BoundingBox;
-import com.irtimaled.bbor.common.models.BoundingBoxWorldSpawn;
-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.util.math.BlockPos;
-import net.minecraft.world.dimension.DimensionType;
-
-import java.net.InetSocketAddress;
-import java.net.SocketAddress;
-
-import static com.irtimaled.bbor.client.Constants.CHUNK_SIZE;
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() {
super.init();
- 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 -> setWorldData(e.getSeed(), e.getSpawnX(), e.getSpawnZ()));
- EventBus.subscribe(AddBoundingBoxReceived.class, e -> runOnCache(e.getDimensionType(), cache -> cache.addBoundingBoxes(e.getKey(), e.getBoundingBoxes())));
- EventBus.subscribe(RemoveBoundingBoxReceived.class, e -> removeBoundingBox(e.getDimensionType(), e.getKey()));
+ 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());
- renderer = new ClientRenderer(this::getCache);
- }
-
- private void render(float partialTicks) {
- EntityPlayer entityPlayer = Minecraft.getInstance().player;
- PlayerData.setPlayerPosition(partialTicks, entityPlayer);
-
- if (this.active) {
- renderer.render(DimensionType.getById(entityPlayer.dimension), outerBoxOnly);
- }
- }
+ ClientRenderer.registerProvider(new CacheProvider(this::getCache));
- private void keyPressed() {
- if (ActiveHotKey.isPressed()) {
- active = !active;
- if (active)
- PlayerData.setActiveY();
- } else if (OuterBoxOnlyHotKey.isPressed()) {
- outerBoxOnly = !outerBoxOnly;
- }
+ KeyListener.init();
}
- private void connectedToServer(NetworkManager networkManager) {
- SocketAddress remoteAddress = networkManager.getRemoteAddress();
- if (remoteAddress instanceof InetSocketAddress) {
- InetSocketAddress socketAddress = (InetSocketAddress) remoteAddress;
- NBTFileParser.loadLocalDatFiles(socketAddress.getHostName(), socketAddress.getPort(), this::setWorldData, this::getOrCreateCache);
- }
+ private void disconnectedFromServer() {
+ ClientRenderer.deactivate();
+ if (ConfigManager.keepCacheBetweenSessions.get()) return;
+ clear();
}
- private void disconnectedFromServer() {
- active = false;
- if (ConfigManager.keepCacheBetweenSessions.getBoolean()) return;
+ private void clear() {
+ SlimeChunkProvider.clear();
+ WorldSpawnProvider.clear();
+ SpawningSphereProvider.clear();
+ CustomBeaconProvider.clear();
+ CustomBoxProvider.clear();
+ BiomeBorderProvider.clear();
VillageColorCache.clear();
clearCaches();
}
- @Override
- protected void setWorldData(long seed, int spawnX, int spawnZ) {
- super.setWorldData(seed, spawnX, spawnZ);
- addSpawnChunkBoundingBoxes(spawnX, spawnZ);
+ private void addBoundingBox(AddBoundingBoxReceived event) {
+ BoundingBoxCache cache = getOrCreateCache(event.getDimensionId());
+ if (cache == null) return;
+
+ cache.addBoundingBoxes(event.getKey(), event.getBoundingBoxes());
}
- private void addSpawnChunkBoundingBoxes(int spawnX, int spawnZ) {
- BoundingBox worldSpawnBoundingBox = getWorldSpawnBoundingBox(spawnX, spawnZ);
- BoundingBox spawnChunksBoundingBox = buildSpawnChunksBoundingBox(spawnX, spawnZ, 12, BoundingBoxType.SpawnChunks);
- BoundingBox lazySpawnChunksBoundingBox = buildSpawnChunksBoundingBox(spawnX, spawnZ, 16, BoundingBoxType.LazySpawnChunks);
+ private void onRemoveBoundingBoxReceived(RemoveBoundingBoxReceived event) {
+ super.removeBoundingBox(event.getDimensionId(), event.getKey());
+ }
- runOnCache(DimensionType.OVERWORLD, cache -> {
- cache.addBoundingBox(worldSpawnBoundingBox);
- cache.addBoundingBox(spawnChunksBoundingBox);
- cache.addBoundingBox(lazySpawnChunksBoundingBox);
- });
+ private void onInitializeClientReceived(InitializeClientReceived event) {
+ setWorldSpawn(event.getSpawnX(), event.getSpawnZ());
+ setSeed(event.getSeed());
}
- private BoundingBox getWorldSpawnBoundingBox(int spawnX, int spawnZ) {
- BlockPos minBlockPos = new BlockPos(spawnX - 10, 0, spawnZ - 10);
- BlockPos maxBlockPos = new BlockPos(spawnX + 10, 0, spawnZ + 10);
+ private void onUpdateWorldSpawnReceived(UpdateWorldSpawnReceived event) {
+ setWorldSpawn(event.getSpawnX(), event.getSpawnZ());
+ }
- return BoundingBoxWorldSpawn.from(minBlockPos, maxBlockPos, BoundingBoxType.WorldSpawn);
+ @Override
+ protected void setSeed(long seed) {
+ super.setSeed(seed);
+ SlimeChunkProvider.setSeed(seed);
}
- private BoundingBox buildSpawnChunksBoundingBox(int spawnX, int spawnZ, int size, BoundingBoxType type) {
- double midOffset = CHUNK_SIZE * (size / 2.0);
- double midX = Math.round((float) (spawnX / (double) CHUNK_SIZE)) * (double) CHUNK_SIZE;
- double midZ = Math.round((float) (spawnZ / (double) CHUNK_SIZE)) * (double) CHUNK_SIZE;
- BlockPos minBlockPos = new BlockPos(midX - midOffset, 0, midZ - midOffset);
- if (spawnX / (double) CHUNK_SIZE % 0.5D == 0.0D && spawnZ / (double) CHUNK_SIZE % 0.5D == 0.0D) {
- midX += (double) CHUNK_SIZE;
- midZ += (double) CHUNK_SIZE;
- }
- BlockPos maxBlockPos = new BlockPos(midX + midOffset, 0, midZ + midOffset);
- return BoundingBoxWorldSpawn.from(minBlockPos, maxBlockPos, type);
+ @Override
+ protected void setWorldSpawn(int spawnX, int spawnZ) {
+ super.setWorldSpawn(spawnX, spawnZ);
+ WorldSpawnProvider.setWorldSpawn(spawnX, spawnZ);
}
-}
\ No newline at end of file
+}
projects / BoundingBoxOutlineReloaded.git / blobdiff