1.1.0

Gaider10 · Gaider10 · commit 65c95d830dbb · 2023-04-16T12:41:21.000+03:00
diff --git a/build.gradle b/build.gradle
@@ -1,5 +1,5 @@
 plugins {
-	id 'fabric-loom' version '0.11-SNAPSHOT'
+	id 'fabric-loom' version '1.1-SNAPSHOT'
 }
 
 sourceCompatibility = JavaVersion.VERSION_16
@@ -29,7 +29,7 @@ processResources {
 }
 
 tasks.withType(JavaCompile).configureEach {
-	it.options.release = 16
+	it.options.release = 8
 }
 
 java {
diff --git a/gradle.properties b/gradle.properties
@@ -2,12 +2,12 @@
 org.gradle.jvmargs=-Xmx1G
 
 # Fabric Properties
-minecraft_version=1.17.1
-yarn_mappings=1.17.1+build.65
-loader_version=0.13.3
+minecraft_version=1.17
+yarn_mappings=1.17+build.13
+loader_version=0.14.19
 
 # Mod Properties
-mod_version = 1.0.0
+mod_version = 1.1.0
 archives_base_name = PlayerHealthIndicators
 
 # Dependencies
diff --git a/src/main/java/me/andrew/healthindicators/Config.java b/src/main/java/me/andrew/healthindicators/Config.java
@@ -0,0 +1,65 @@
+package me.andrew.healthindicators;
+
+import com.google.gson.Gson;
+import net.fabricmc.loader.api.FabricLoader;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.FileReader;
+import java.io.FileWriter;
+
+public class Config {
+    private static final Gson GSON = new Gson();
+
+    private static Config INSTANCE = new Config();
+
+    private boolean renderingEnabled = true;
+    private boolean heartStackingEnabled = true;
+    private int heartOffset = 0;
+
+    public static boolean getRenderingEnabled() {
+        return INSTANCE.renderingEnabled;
+    }
+
+    public static void setRenderingEnabled(boolean renderingEnabled) {
+        INSTANCE.renderingEnabled = renderingEnabled;
+        save();
+    }
+
+    public static boolean getHeartStackingEnabled() {
+        return INSTANCE.heartStackingEnabled;
+    }
+
+    public static void setHeartStackingEnabled(boolean heartStackingEnabled) {
+        INSTANCE.heartStackingEnabled = heartStackingEnabled;
+        save();
+    }
+
+    public static int getHeartOffset() {
+        return INSTANCE.heartOffset;
+    }
+
+    public static void setHeartOffset(int heartOffset) {
+        INSTANCE.heartOffset = heartOffset;
+        save();
+    }
+
+    public static void load() {
+        try (BufferedReader reader = new BufferedReader(new FileReader(FabricLoader.getInstance().getConfigDir().resolve(HealthIndicatorsMod.CONFIG_FILE).toFile()))) {
+            Config config = GSON.fromJson(reader, Config.class);
+            if (config != null) {
+                INSTANCE = config;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    public static void save() {
+        try (BufferedWriter writer = new BufferedWriter(new FileWriter(FabricLoader.getInstance().getConfigDir().resolve(HealthIndicatorsMod.CONFIG_FILE).toFile()))) {
+            GSON.toJson(INSTANCE, writer);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+}
diff --git a/src/main/java/me/andrew/healthindicators/HealthIndicatorsMod.java b/src/main/java/me/andrew/healthindicators/HealthIndicatorsMod.java
@@ -6,26 +6,64 @@
 import net.minecraft.client.option.KeyBinding;
 import net.minecraft.client.util.InputUtil;
 import net.minecraft.text.LiteralText;
+import net.minecraft.text.Text;
 
 public class HealthIndicatorsMod implements ModInitializer {
     public static final String MOD_ID = "healthindicators";
 
-    public static KeyBinding keyBinding;
-    public static boolean toggled = true;
+    public static final String CONFIG_FILE = "healthindicators.json";
+
+    public static final KeyBinding RENDERING_ENABLED_KEY_BINDING = KeyBindingHelper.registerKeyBinding(new KeyBinding(
+            "key." + MOD_ID + ".renderingEnabled",
+            InputUtil.UNKNOWN_KEY.getCode(),
+            "key.categories." + MOD_ID
+    ));
+    public static final KeyBinding HEART_STACKING_ENABLED_KEY_BINDING = KeyBindingHelper.registerKeyBinding(new KeyBinding(
+            "key." + MOD_ID + ".heartStackingEnabled",
+            InputUtil.UNKNOWN_KEY.getCode(),
+            "key.categories." + MOD_ID
+    ));
+    public static final KeyBinding INCREASE_HEART_OFFSET_KEY_BINDING = KeyBindingHelper.registerKeyBinding(new KeyBinding(
+            "key." + MOD_ID + ".increaseHeartOffset",
+            InputUtil.UNKNOWN_KEY.getCode(),
+            "key.categories." + MOD_ID
+    ));
+    public static final KeyBinding DECREASE_HEART_OFFSET_KEY_BINDING = KeyBindingHelper.registerKeyBinding(new KeyBinding(
+            "key." + MOD_ID + ".decreaseHeartOffset",
+            InputUtil.UNKNOWN_KEY.getCode(),
+            "key.categories." + MOD_ID
+    ));
 
     @Override
     public void onInitialize() {
-        keyBinding = KeyBindingHelper.registerKeyBinding(new KeyBinding(
-                "key." + MOD_ID + ".toggle",
-                InputUtil.UNKNOWN_KEY.getCode(),
-                "key.categories." + MOD_ID
-        ));
+        Config.load();
 
         ClientTickEvents.END_CLIENT_TICK.register(client -> {
-            while (keyBinding.wasPressed()) {
-                toggled = !toggled;
-                if(client.player != null) {
-                    client.player.sendMessage(new LiteralText((toggled ? "Enabled" : "Disabled") + " Health Indicators"), true);
+            while (RENDERING_ENABLED_KEY_BINDING.wasPressed()) {
+                Config.setRenderingEnabled(!Config.getRenderingEnabled());
+                if (client.player != null) {
+                    client.player.sendMessage(new LiteralText((Config.getRenderingEnabled() ? "Enabled" : "Disabled") + " Health Indicators"), true);
+                }
+            }
+
+            while (HEART_STACKING_ENABLED_KEY_BINDING.wasPressed()) {
+                Config.setHeartStackingEnabled(!Config.getHeartStackingEnabled());
+                if (client.player != null) {
+                    client.player.sendMessage(new LiteralText((Config.getHeartStackingEnabled() ? "Enabled" : "Disabled") + " Heart Stacking"), true);
+                }
+            }
+
+            while (INCREASE_HEART_OFFSET_KEY_BINDING.wasPressed()) {
+                Config.setHeartOffset(Config.getHeartOffset() + 1);
+                if (client.player != null) {
+                    client.player.sendMessage(new LiteralText("Set heart offset to " + Config.getHeartOffset()), true);
+                }
+            }
+
+            while (DECREASE_HEART_OFFSET_KEY_BINDING.wasPressed()) {
+                Config.setHeartOffset(Config.getHeartOffset() - 1);
+                if (client.player != null) {
+                    client.player.sendMessage(new LiteralText("Set heart offset to " + Config.getHeartOffset()), true);
                 }
             }
         });
diff --git a/src/main/java/me/andrew/healthindicators/HeartType.java b/src/main/java/me/andrew/healthindicators/HeartType.java
@@ -0,0 +1,17 @@
+package me.andrew.healthindicators;
+
+public enum HeartType {
+    EMPTY(16 + 0 * 9, 0),
+    RED_FULL(16 + 4 * 9, 0),
+    RED_HALF(16 + 5 * 9, 0),
+    YELLOW_FULL(16 + 16 * 9, 0),
+    YELLOW_HALF(16 + 17 * 9, 0);
+
+    public final int u;
+    public final int v;
+
+    HeartType(int u, int v) {
+        this.u = u;
+        this.v = v;
+    }
+}
diff --git a/src/main/java/me/andrew/healthindicators/mixin/PlayerEntityRendererMixin.java b/src/main/java/me/andrew/healthindicators/mixin/PlayerEntityRendererMixin.java
@@ -1,7 +1,9 @@
 package me.andrew.healthindicators.mixin;
 
 import com.mojang.blaze3d.systems.RenderSystem;
-import me.andrew.healthindicators.HealthIndicatorsMod;
+import me.andrew.healthindicators.Config;
+import me.andrew.healthindicators.HeartType;
+import net.minecraft.client.MinecraftClient;
 import net.minecraft.client.gui.DrawableHelper;
 import net.minecraft.client.network.AbstractClientPlayerEntity;
 import net.minecraft.client.render.*;
@@ -10,6 +12,7 @@
 import net.minecraft.client.render.entity.PlayerEntityRenderer;
 import net.minecraft.client.render.entity.model.PlayerEntityModel;
 import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.entity.Entity;
 import net.minecraft.util.math.MathHelper;
 import net.minecraft.util.math.Matrix4f;
 import org.spongepowered.asm.mixin.Mixin;
@@ -28,86 +31,110 @@ public PlayerEntityRendererMixin(EntityRendererFactory.Context ctx, PlayerEntity
             at = @At("RETURN")
     )
     public void renderHealth(AbstractClientPlayerEntity abstractClientPlayerEntity, float f, float g, MatrixStack matrixStack, VertexConsumerProvider vertexConsumerProvider, int light, CallbackInfo ci) {
-        if (HealthIndicatorsMod.toggled && !abstractClientPlayerEntity.isMainPlayer()) {
-            matrixStack.push();
+        if (!Config.getRenderingEnabled()) return;
 
-            double d = this.dispatcher.getSquaredDistanceToCamera(abstractClientPlayerEntity);
+        if (!shouldRenderHeartsForEntity(abstractClientPlayerEntity)) return;
 
-            matrixStack.translate(0, abstractClientPlayerEntity.getHeight() + 0.5f, 0);
-            if (this.hasLabel(abstractClientPlayerEntity) && d <= 4096.0) {
+        matrixStack.push();
+
+        double d = this.dispatcher.getSquaredDistanceToCamera(abstractClientPlayerEntity);
+
+        matrixStack.translate(0, abstractClientPlayerEntity.getHeight() + 0.5f, 0);
+        if (this.hasLabel(abstractClientPlayerEntity) && d <= 4096.0) {
+            matrixStack.translate(0.0D, 9.0F * 1.15F * 0.025F, 0.0D);
+            if (d < 100.0 && abstractClientPlayerEntity.getScoreboard().getObjectiveForSlot(2) != null) {
                 matrixStack.translate(0.0D, 9.0F * 1.15F * 0.025F, 0.0D);
-                if (d < 100.0 && abstractClientPlayerEntity.getScoreboard().getObjectiveForSlot(2) != null) {
-                    matrixStack.translate(0.0D, 9.0F * 1.15F * 0.025F, 0.0D);
-                }
             }
+        }
 
-            matrixStack.multiply(this.dispatcher.getRotation());
+        matrixStack.multiply(this.dispatcher.getRotation());
 //            matrixStack.multiply(Vector3f.POSITIVE_X.getDegreesQuaternion(mc.gameRenderer.getCamera().getPitch()));
 
-            float pixelSize = 0.025F;
-            matrixStack.scale(pixelSize, pixelSize, pixelSize);
-
-            Tessellator tessellator = Tessellator.getInstance();
-            BufferBuilder vertexConsumer = tessellator.getBuffer();
-
-            vertexConsumer.begin(VertexFormat.DrawMode.QUADS, VertexFormats.POSITION_TEXTURE);
-            RenderSystem.setShader(GameRenderer::getPositionTexShader);
-            RenderSystem.setShaderTexture(0, DrawableHelper.GUI_ICONS_TEXTURE);
-            RenderSystem.enableDepthTest();
-
-            Matrix4f model = matrixStack.peek().getModel();
-
-            int healthRed = MathHelper.ceil(abstractClientPlayerEntity.getHealth());
-            int maxHealth = MathHelper.ceil(abstractClientPlayerEntity.getMaxHealth());
-            int healthYellow = MathHelper.ceil(abstractClientPlayerEntity.getAbsorptionAmount());
-
-            int heartsRed = MathHelper.ceil(healthRed / 2.0f);
-            boolean lastRedHalf = (healthRed & 1) == 1;
-            int heartsNormal = MathHelper.ceil(maxHealth / 2.0f);
-            int heartsYellow = MathHelper.ceil(healthYellow / 2.0f);
-            boolean lastYellowHalf = (healthYellow & 1) == 1;
-            int heartsTotal = heartsNormal + heartsYellow;
-
-            int pixelsTotal = heartsTotal * 8 + 1;
-            float maxX = pixelsTotal / 2.0f;
-            for (int heart = 0; heart < heartsTotal; heart++){
-                float x = maxX - heart * 8;
-                drawHeart(model, vertexConsumer, x, 0);
-                // Offset in the gui icons texture in hearts
-                // 0 - empty, 2 - red, 8 - yellow, +1 for half
-                int type;
-                if (heart < heartsRed) {
-                    type = 2 * 2;
-                    if (heart == heartsRed - 1 && lastRedHalf) type += 1;
-                } else if (heart < heartsNormal) {
-                    type = 0;
-                } else {
-                    type = 8 * 2;
-                    if(heart == heartsTotal - 1 && lastYellowHalf) type += 1;
+        float pixelSize = 0.025F;
+        matrixStack.scale(pixelSize, pixelSize, pixelSize);
+        matrixStack.translate(0, Config.getHeartOffset(), 0);
+
+        Tessellator tessellator = Tessellator.getInstance();
+        BufferBuilder vertexConsumer = tessellator.getBuffer();
+
+        vertexConsumer.begin(VertexFormat.DrawMode.QUADS, VertexFormats.POSITION_TEXTURE);
+        RenderSystem.setShader(GameRenderer::getPositionTexShader);
+        RenderSystem.setShaderTexture(0, DrawableHelper.GUI_ICONS_TEXTURE);
+        RenderSystem.enableDepthTest();
+
+        Matrix4f model = matrixStack.peek().getModel();
+
+        int healthRed = MathHelper.ceil(abstractClientPlayerEntity.getHealth());
+        int maxHealth = MathHelper.ceil(abstractClientPlayerEntity.getMaxHealth());
+        int healthYellow = MathHelper.ceil(abstractClientPlayerEntity.getAbsorptionAmount());
+
+        int heartsRed = MathHelper.ceil(healthRed / 2.0f);
+        boolean lastRedHalf = (healthRed & 1) == 1;
+        int heartsNormal = MathHelper.ceil(maxHealth / 2.0f);
+        int heartsYellow = MathHelper.ceil(healthYellow / 2.0f);
+        boolean lastYellowHalf = (healthYellow & 1) == 1;
+        int heartsTotal = heartsNormal + heartsYellow;
+
+        int heartsPerRow = Config.getHeartStackingEnabled() ? 10 : heartsTotal;
+        int rowsTotal = (heartsTotal + heartsPerRow - 1) / heartsPerRow;
+        int rowOffset = Math.max(10 - (rowsTotal - 2), 3);
+
+        int pixelsTotal = Math.min(heartsTotal, heartsPerRow) * 8 + 1;
+        float maxX = pixelsTotal / 2.0f;
+        for (int heart = 0; heart < heartsTotal; heart++){
+            int row = heart / heartsPerRow;
+            int col = heart % heartsPerRow;
+
+            float x = maxX - col * 8;
+            float y = row * rowOffset;
+            float z = row * 0.01F;
+            drawHeart(model, vertexConsumer, x, y, z, HeartType.EMPTY);
+
+            HeartType type;
+            if (heart < heartsRed) {
+                type = HeartType.RED_FULL;
+                if (heart == heartsRed - 1 && lastRedHalf) {
+                    type = HeartType.RED_HALF;
                 }
-                if (type != 0) {
-                    drawHeart(model, vertexConsumer, x, type);
+            } else if (heart < heartsNormal) {
+                type = HeartType.EMPTY;
+            } else {
+                type = HeartType.YELLOW_FULL;
+                if (heart == heartsTotal - 1 && lastYellowHalf) {
+                    type = HeartType.YELLOW_HALF;
                 }
             }
+            if (type != HeartType.EMPTY) {
+                drawHeart(model, vertexConsumer, x, y, z, type);
+            }
+        }
+
+        tessellator.draw();
 
-            tessellator.draw();
+        matrixStack.pop();
+    }
 
-            matrixStack.pop();
+    private static boolean shouldRenderHeartsForEntity(Entity entity) {
+        if (entity instanceof AbstractClientPlayerEntity) {
+            AbstractClientPlayerEntity abstractClientPlayerEntity = (AbstractClientPlayerEntity) entity;
+            return !abstractClientPlayerEntity.isMainPlayer() && !abstractClientPlayerEntity.isInvisibleTo(MinecraftClient.getInstance().player);
         }
+
+        return false;
     }
 
-    private static void drawHeart(Matrix4f model, VertexConsumer vertexConsumer, float x, int type){
-        float minU = 16F / 256F + type * 9F / 256F;
+    private static void drawHeart(Matrix4f model, VertexConsumer vertexConsumer, float x, float y, float z, HeartType type){
+        float minU = type.u / 256F;
         float maxU = minU + 9F / 256F;
-        float minV = 0;
+        float minV = type.v / 256F;
         float maxV = minV + 9F / 256F;
 
         float heartSize = 9F;
 
-        drawVertex(model, vertexConsumer, x, 0F - heartSize, 0F, minU, maxV);
-        drawVertex(model, vertexConsumer, x - heartSize, 0F - heartSize, 0F, maxU, maxV);
-        drawVertex(model, vertexConsumer, x - heartSize, 0F, 0F, maxU, minV);
-        drawVertex(model, vertexConsumer, x, 0F, 0F, minU, minV);
+        drawVertex(model, vertexConsumer, x, y - heartSize, z, minU, maxV);
+        drawVertex(model, vertexConsumer, x - heartSize, y - heartSize, z, maxU, maxV);
+        drawVertex(model, vertexConsumer, x - heartSize, y, z, maxU, minV);
+        drawVertex(model, vertexConsumer, x, y, z, minU, minV);
     }
 
     private static void drawVertex(Matrix4f model, VertexConsumer vertices, float x, float y, float z, float u, float v) {
diff --git a/src/main/resources/assets/healthindicators/lang/en_us.json b/src/main/resources/assets/healthindicators/lang/en_us.json
@@ -1,4 +1,7 @@
 {
   "key.categories.healthindicators": "Player Health Indicators",
-  "key.healthindicators.toggle": "Toggle"
+  "key.healthindicators.renderingEnabled": "Toggle Rendering",
+  "key.healthindicators.heartStackingEnabled": "Toggle Heart Stacking",
+  "key.healthindicators.increaseHeartOffset": "Increase Heart Offset",
+  "key.healthindicators.decreaseHeartOffset": "Decrease Heart Offset"
 }

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`plugins {`
`2`		`- id 'fabric-loom' version '0.11-SNAPSHOT'`
	`2`	`+ id 'fabric-loom' version '1.1-SNAPSHOT'`
`3`	`3`	`}`
`4`	`4`
`5`	`5`	`sourceCompatibility = JavaVersion.VERSION_16`
`@@ -29,7 +29,7 @@ processResources {`
`29`	`29`	`}`
`30`	`30`
`31`	`31`	`tasks.withType(JavaCompile).configureEach {`
`32`		`- it.options.release = 16`
	`32`	`+ it.options.release = 8`
`33`	`33`	`}`
`34`	`34`
`35`	`35`	`java {`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,7 @@`
`1`	`1`	`{`
`2`	`2`	`"key.categories.healthindicators": "Player Health Indicators",`
`3`		`- "key.healthindicators.toggle": "Toggle"`
	`3`	`+ "key.healthindicators.renderingEnabled": "Toggle Rendering",`
	`4`	`+ "key.healthindicators.heartStackingEnabled": "Toggle Heart Stacking",`
	`5`	`+ "key.healthindicators.increaseHeartOffset": "Increase Heart Offset",`
	`6`	`+ "key.healthindicators.decreaseHeartOffset": "Decrease Heart Offset"`
`4`	`7`	`}`