Version/1.1.0

src/main/java/nl/devpieter/utilize/Utilize.java

@@ -5,48 +5,33 @@
 import net.fabricmc.loader.api.FabricLoader;
 import net.fabricmc.loader.api.ModContainer;
 import net.minecraft.SharedConstants;
-import net.minecraft.client.MinecraftClient;
-import net.minecraft.client.network.ClientPlayerEntity;
 import nl.devpieter.utilize.http.AsyncRequest;
-import nl.devpieter.utilize.listeners.packet.OpenScreenPacketListener;
-import nl.devpieter.utilize.managers.PacketManager;
 import nl.devpieter.utilize.setting.SettingManager;
-import nl.devpieter.utilize.task.TaskManager;
-import nl.devpieter.utilize.utils.minecraft.ClientUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.util.ArrayList;
-import java.util.List;
-
 public class Utilize implements ClientModInitializer {
 
     private static Utilize INSTANCE;
 
     private final Logger logger = LoggerFactory.getLogger("Utilize");
     private final ModContainer modContainer = FabricLoader.getInstance().getModContainer("utilize").orElseThrow();
 
-    private final List<Integer> blockScreenIds = new ArrayList<>();
-
     private boolean isInitialized;
 
     @Override
     public void onInitializeClient() {
         INSTANCE = this;
 
-        PacketManager packetManager = PacketManager.getInstance();
-        packetManager.subscribe(new OpenScreenPacketListener());
-
         ClientLifecycleEvents.CLIENT_STOPPING.register((client) -> {
-            this.logger.info("Shutting down Utilize...");
+            logger.info("Shutting down Utilize...");
 
-            TaskManager.shutdown();
             SettingManager.shutdown();
             AsyncRequest.shutdown();
         });
 
-        this.logger.info("Utilize initialized successfully! Version: {}", this.getUtilizeVersion());
-        this.isInitialized = true;
+        logger.info("Utilize initialized successfully! Version: {}", getUtilizeVersion());
+        isInitialized = true;
     }
 
     /**
@@ -78,11 +63,11 @@ public static Utilize getInstance() {
      * @return true if initialized, false otherwise
      */
     public boolean isInitialized() {
-        return this.isInitialized;
+        return isInitialized;
     }
 
     public String getUtilizeVersion() {
-        return this.modContainer.getMetadata().getVersion().getFriendlyString();
+        return modContainer.getMetadata().getVersion().getFriendlyString();
     }
 
     public String getMinecraftVersion() {
@@ -98,8 +83,8 @@ public String getMinecraftVersion() {
     public String getUserAgent() {
         return String.format(
                 "Utilize/%s (Mc/%s; Java/%s)",
-                this.getUtilizeVersion(),
-                this.getMinecraftVersion(),
+                getUtilizeVersion(),
+                getMinecraftVersion(),
                 System.getProperty("java.version")
         );
     }
@@ -117,33 +102,9 @@ public String getUserAgent(String name, String version) {
                 "%s/%s (Utilize/%s; Mc/%s; Java/%s)",
                 name,
                 version,
-                this.getUtilizeVersion(),
-                this.getMinecraftVersion(),
+                getUtilizeVersion(),
+                getMinecraftVersion(),
                 System.getProperty("java.version")
         );
     }
-
-    public boolean shouldBlockScreenId(int screenId) {
-        return blockScreenIds.contains(screenId);
-    }
-
-    public void blockScreenId(int screenId) {
-        if (this.blockScreenIds.contains(screenId)) return;
-        this.blockScreenIds.add(screenId);
-
-        if (!ClientUtils.hasPlayer()) return;
-        MinecraftClient client = MinecraftClient.getInstance();
-        ClientPlayerEntity player = ClientUtils.getPlayer();
-
-        client.execute(() -> {
-            if (player == null || player.currentScreenHandler.syncId != screenId) return;
-
-            player.closeHandledScreen();
-            blockedScreenId(screenId);
-        });
-    }
-
-    public void blockedScreenId(int screenId) {
-        this.blockScreenIds.removeIf(id -> id == screenId);
-    }
 }

src/main/java/nl/devpieter/utilize/enums/KeyActionOverride.java

@@ -0,0 +1,7 @@
+package nl.devpieter.utilize.enums;
+
+public enum KeyActionOverride {
+    NONE,
+    FORCE_PRESS,
+    FORCE_RELEASE
+}

src/main/java/nl/devpieter/utilize/events/interaction/keybinding/KeyBindingPressedCheckEvent.java

@@ -0,0 +1,29 @@
+package nl.devpieter.utilize.events.interaction.keybinding;
+
+import nl.devpieter.sees.event.SReturnableEvent;
+import nl.devpieter.utilize.enums.KeyActionOverride;
+import org.jetbrains.annotations.NotNull;
+
+public class KeyBindingPressedCheckEvent implements SReturnableEvent<KeyActionOverride> {
+
+    private final String keyId;
+    private KeyActionOverride override = KeyActionOverride.NONE;
+
+    public KeyBindingPressedCheckEvent(@NotNull String keyId) {
+        this.keyId = keyId;
+    }
+
+    public @NotNull String getKeyId() {
+        return keyId;
+    }
+
+    @Override
+    public KeyActionOverride getResult() {
+        return override;
+    }
+
+    @Override
+    public void setResult(KeyActionOverride result) {
+        override = result;
+    }
+}

src/main/java/nl/devpieter/utilize/events/interaction/keybinding/KeyBindingPressedEvent.java

@@ -0,0 +1,29 @@
+package nl.devpieter.utilize.events.interaction.keybinding;
+
+import nl.devpieter.sees.event.SReturnableEvent;
+import nl.devpieter.utilize.enums.KeyActionOverride;
+import org.jetbrains.annotations.NotNull;
+
+public class KeyBindingPressedEvent implements SReturnableEvent<KeyActionOverride> {
+
+    private final String keyId;
+    private KeyActionOverride override = KeyActionOverride.NONE;
+
+    public KeyBindingPressedEvent(@NotNull String keyId) {
+        this.keyId = keyId;
+    }
+
+    public @NotNull String getKeyId() {
+        return keyId;
+    }
+
+    @Override
+    public KeyActionOverride getResult() {
+        return override;
+    }
+
+    @Override
+    public void setResult(KeyActionOverride result) {
+        override = result;
+    }
+}

src/main/java/nl/devpieter/utilize/http/AsyncRequest.java

@@ -21,7 +21,7 @@ public AsyncRequest() {
 
     public AsyncRequest(@Nullable ResultConsumer<T> requestCallback) {
         if (requestCallback == null) return;
-        this.callbacks.add(requestCallback);
+        callbacks.add(requestCallback);
     }
 
     public static void shutdown() {
@@ -38,42 +38,42 @@ public static void shutdown() {
 
     public void addCallback(@Nullable ResultConsumer<T> callback) {
         if (callback == null) return;
-        this.callbacks.add(callback);
+        callbacks.add(callback);
     }
 
     public void execute() {
-        if (this.future != null) return;
+        if (future != null) return;
 
-        this.future = CompletableFuture.supplyAsync(() -> {
+        future = CompletableFuture.supplyAsync(() -> {
             try {
                 T result = requestAsync();
-                this.callCallbacks(result, null);
+                callCallbacks(result, null);
                 return result;
             } catch (Exception e) {
-                this.callCallbacks(null, e);
+                callCallbacks(null, e);
                 throw new RuntimeException(e);
             }
         }, EXECUTOR_SERVICE);
     }
 
     public void cancel() {
-        this.future.cancel(true);
+        future.cancel(true);
     }
 
     public boolean isDone() {
-        return this.future.isDone();
+        return future.isDone();
     }
 
     public T get() throws ExecutionException, InterruptedException {
-        return this.future.get();
+        return future.get();
     }
 
     public CompletableFuture<T> getFuture() {
-        return this.future;
+        return future;
     }
 
     private void callCallbacks(@Nullable T result, @Nullable Exception exception) {
-        for (ResultConsumer<T> callback : this.callbacks) {
+        for (ResultConsumer<T> callback : callbacks) {
             if (callback != null) callback.accept(result, exception);
         }
     }

src/main/java/nl/devpieter/utilize/managers/DamageManager.java

@@ -4,38 +4,37 @@
 import nl.devpieter.utilize.events.player.PlayerDamagedEvent;
 import nl.devpieter.utilize.events.player.PlayerHealedEvent;
 
-public class DamageManager {
+public final class DamageManager {
 
-    private static DamageManager INSTANCE;
+    private static final DamageManager INSTANCE = new DamageManager();
 
     private final Sees sees = Sees.getInstance();
 
-    private double currentHealth = -1;
+    private double currentCurrentHealth = -1;
 
     private DamageManager() {
     }
 
     public static DamageManager getInstance() {
-        if (INSTANCE == null) INSTANCE = new DamageManager();
         return INSTANCE;
     }
 
     public void tick(double currentHealth) {
-        if (this.currentHealth == -1) {
-            this.currentHealth = currentHealth;
+        if (currentCurrentHealth == -1) {
+            currentCurrentHealth = currentHealth;
             return;
         }
 
-        double difference = this.currentHealth - currentHealth;
-        this.currentHealth = currentHealth;
+        double difference = currentCurrentHealth - currentHealth;
+        currentCurrentHealth = currentHealth;
 
         if (difference == 0) return;
 
-        if (difference > 0) this.sees.dispatch(new PlayerDamagedEvent(currentHealth, difference));
-        else if (difference < 0) this.sees.dispatch(new PlayerHealedEvent(currentHealth, -difference));
+        if (difference > 0) sees.dispatch(new PlayerDamagedEvent(currentHealth, difference));
+        else if (difference < 0) sees.dispatch(new PlayerHealedEvent(currentHealth, -difference));
     }
 
     public double getCurrentHealth() {
-        return this.currentHealth;
+        return currentCurrentHealth;
     }
 }

src/main/java/nl/devpieter/utilize/managers/DebugManager.java

@@ -1,35 +1,38 @@
 package nl.devpieter.utilize.managers;
 
+import net.minecraft.client.MinecraftClient;
 import net.minecraft.client.render.debug.DebugRenderer;
+import nl.devpieter.utilize.mixins.accessors.DebugRendererAccessor;
 import org.jetbrains.annotations.NotNull;
 
-import java.util.ArrayList;
 import java.util.List;
 
-public class DebugManager {
+public final class DebugManager {
 
-    private static DebugManager INSTANCE;
+    private static final DebugManager INSTANCE = new DebugManager();
 
-    private final List<DebugRenderer.Renderer> renderers = new ArrayList<>();
+    private final MinecraftClient minecraftClient = MinecraftClient.getInstance();
 
     private DebugManager() {
     }
 
     public static DebugManager getInstance() {
-        if (INSTANCE == null) INSTANCE = new DebugManager();
         return INSTANCE;
     }
 
     public void addRenderer(@NotNull DebugRenderer.Renderer renderer) {
-        if (this.renderers.contains(renderer)) return;
-        this.renderers.add(renderer);
+        List<DebugRenderer.Renderer> renderers = getAccessor().utilize$getDebugRenderers();
+        if (renderers.contains(renderer)) return;
+
+        renderers.add(renderer);
     }
 
     public void removeRenderer(@NotNull DebugRenderer.Renderer renderer) {
-        this.renderers.remove(renderer);
+        List<DebugRenderer.Renderer> renderers = getAccessor().utilize$getDebugRenderers();
+        renderers.remove(renderer);
     }
 
-    public List<DebugRenderer.Renderer> getRenderers() {
-        return this.renderers;
+    private DebugRendererAccessor getAccessor() {
+        return (DebugRendererAccessor) minecraftClient.worldRenderer.debugRenderer;
     }
 }