backport to 1.20-1.20.4 and update to 1.21.6

Author: DerpDerpling

build.gradle

@@ -4,18 +4,13 @@ plugins {
 }
 
 version = project.mod_version
-group = project.maven_group
+group   = project.maven_group
 
 base {
 	archivesName = project.archives_base_name
 }
 
 repositories {
-	// Add repositories to retrieve artifacts from in here.
-	// You should only use this when depending on other mods because
-	// Loom adds the essential maven repositories to download Minecraft and libraries from automatically.
-	// See https://docs.gradle.org/current/userguide/declaring_repositories.html
-	// for more information about repositories.
 	maven {
 		name = "Fabric"
 		url = "https://maven.fabricmc.net/"
@@ -35,81 +30,76 @@ repositories {
 
 loom {
 	splitEnvironmentSourceSets()
-
 	mods {
 		"immersive-hotbar" {
 			sourceSet sourceSets.main
 			sourceSet sourceSets.client
 		}
 	}
-
 }
 
 fabricApi {
-	configureDataGeneration {
-		client = true
-	}
+	configureDataGeneration { client = true }
 }
+
 loom {
 	accessWidenerPath = file("src/main/resources/immersive-hotbar.accesswidener")
 }
+
 dependencies {
 	// To change the versions see the gradle.properties file
 	minecraft "com.mojang:minecraft:${project.minecraft_version}"
 	mappings "net.fabricmc:yarn:${project.yarn_mappings}:v2"
 	modImplementation "net.fabricmc:fabric-loader:${project.loader_version}"
 
-	modImplementation("com.terraformersmc:modmenu:${project.modmenu_version}")
+	modImplementation "com.terraformersmc:modmenu:${project.modmenu_version}"
 	modImplementation "dev.isxander:yet-another-config-lib:${project.yacl_version}"
-
-	// Fabric API. This is technically optional, but you probably want it anyway.
 	modImplementation "net.fabricmc.fabric-api:fabric-api:${project.fabric_version}"
-	
 }
+
 processResources {
 	inputs.property "version", project.version
-
 	filesMatching("fabric.mod.json") {
 		expand "version": inputs.properties.version
 	}
 }
 
-tasks.withType(JavaCompile).configureEach {
-	it.options.release = 21
-}
+// ─── Replace stonecutter.version.current with stonecutter.minecraftVersion ───
+
+def isModernMc = stonecutter.eval(project.minecraft_version, ">=1.20.5")
 
 java {
-	// Loom will automatically attach sourcesJar to a RemapSourcesJar task and to the "build" task
-	// if it is present.
-	// If you remove this line, sources will not be generated.
-	withSourcesJar()
+	// if MC ≥1.20.5 → Java 21; else → Java 17
+	sourceCompatibility = isModernMc ? JavaVersion.VERSION_21 : JavaVersion.VERSION_17
+	targetCompatibility = isModernMc ? JavaVersion.VERSION_21 : JavaVersion.VERSION_17
 
-	sourceCompatibility = JavaVersion.VERSION_21
-	targetCompatibility = JavaVersion.VERSION_21
+	// (Optional) force Gradle to select the correct toolchain
+	toolchain {
+		languageVersion = JavaLanguageVersion.of(isModernMc ? 21 : 17)
+	}
+}
+
+tasks.withType(JavaCompile).configureEach {
+	options.release = isModernMc ? 21 : 17
 }
 
+// ───────────────────────────────────────────────────────────────────────────────
+
 jar {
 	inputs.property "archivesName", project.base.archivesName
-
 	from("LICENSE") {
-		rename { "${it}_${inputs.properties.archivesName}"}
+		rename { "${it}_${inputs.properties.archivesName}" }
 	}
 }
 
-// configure the maven publication
 publishing {
 	publications {
 		create("mavenJava", MavenPublication) {
 			artifactId = project.archives_base_name
 			from components.java
 		}
 	}
-
-	// See https://docs.gradle.org/current/userguide/publishing_maven.html for information on how to set up publishing.
 	repositories {
-		// Add repositories to publish to here.
-		// Notice: This block does NOT have the same function as the block in the top level.
-		// The repositories here will be used for publishing your artifact, not for
-		// retrieving dependencies.
+		// …your publishing repositories…
 	}
-}
+}

settings.gradle

@@ -13,7 +13,7 @@ plugins {
 }
 stonecutter {
 	create(rootProject) {
-		versions "1.21.1", "1.21.2", "1.21.5"
+		versions "1.20.1", "1.21.1", "1.21.2", "1.21.5", "1.21.6"
 		vcsVersion = "1.21.1"
 	}
 }

versions/1.20.1/gradle.properties

@@ -0,0 +1,20 @@
+# Done to increase the memory available to gradle.
+org.gradle.jvmargs=-Xmx1G
+org.gradle.parallel=true
+
+# Fabric Properties
+# check these on https://fabricmc.net/develop
+minecraft_version=1.20.1
+yarn_mappings=1.20.1+build.10
+loader_version=0.16.14
+
+# Mod Properties
+mod_version=1.0.3-1.20-1.20.4
+maven_group=derp.immersive-hotbar
+archives_base_name=immersive-hotbar
+
+# Dependencies
+fabric_version=0.92.5+1.20.1
+yacl_version=3.6.6+1.20.1-fabric
+modmenu_version=7.2.2
+

versions/1.20.1/src/client/java/derp/immersivehotbar/ImmersiveHotbarClient.java

@@ -0,0 +1,119 @@
+package derp.immersivehotbar;
+
+import derp.immersivehotbar.config.ImmersiveHotbarConfigHandler;
+import derp.immersivehotbar.util.TooltipAnimationState;
+import net.fabricmc.api.ClientModInitializer;
+import net.fabricmc.fabric.api.client.event.lifecycle.v1.ClientTickEvents;
+import net.fabricmc.fabric.api.client.networking.v1.ClientPlayConnectionEvents;
+import net.fabricmc.loader.api.FabricLoader;
+import net.minecraft.item.*;
+import net.minecraft.util.hit.BlockHitResult;
+import net.minecraft.util.hit.HitResult;
+import net.minecraft.util.math.BlockPos;
+
+import java.util.Arrays;
+import java.util.concurrent.atomic.AtomicReference;
+
+import static derp.immersivehotbar.config.ImmersiveHotbarConfig.*;
+import static derp.immersivehotbar.util.SlotAnimationState.*;
+
+public class ImmersiveHotbarClient implements ClientModInitializer {
+	private boolean wasUsingItem = false;
+	private ItemStack lastUsedItem = ItemStack.EMPTY;
+	private boolean wasCrossbowChargedMainhand = false;
+	private boolean wasCrossbowChargedOffhand = false;
+	public static final boolean IS_DOUBLEHOTBAR_LOADED = FabricLoader.getInstance().isModLoaded("double_hotbar");
+
+	@Override
+	public void onInitializeClient() {
+		ImmersiveHotbarConfigHandler.load();
+
+		ClientPlayConnectionEvents.DISCONNECT.register((client, world) -> Arrays.fill(lastSlotStacks, ItemStack.EMPTY));
+		ClientPlayConnectionEvents.JOIN.register((handler, sender, client) -> TooltipAnimationState.reset());
+
+		ClientTickEvents.END_CLIENT_TICK.register(client -> {
+			if (client.player == null) return;
+
+			boolean isUsing = client.player.isUsingItem();
+
+			// track bow usage
+			if (isUsing) {
+				lastUsedItem = client.player.getActiveItem();
+			} else if (wasUsingItem && !lastUsedItem.isEmpty()) {
+				Item item = lastUsedItem.getItem();
+
+				if (weaponAnimates && (item instanceof BowItem || item instanceof CrossbowItem)) {
+					int slot = client.player.getMainHandStack() == lastUsedItem ? client.player.getInventory().selectedSlot : 9;
+					triggerShrink(slot);
+				}
+				lastUsedItem = ItemStack.EMPTY;
+			}
+
+			wasUsingItem = isUsing;
+
+			// crossbow mainhand
+			ItemStack mainHandStack = client.player.getMainHandStack();
+			if (mainHandStack.getItem() instanceof CrossbowItem) {
+				boolean isCharged = CrossbowItem.isCharged(mainHandStack);
+				if (wasCrossbowChargedMainhand && !isCharged && weaponAnimates) {
+					int slot = client.player.getInventory().selectedSlot;
+					triggerShrink(slot);
+				}
+				wasCrossbowChargedMainhand = isCharged;
+			} else {
+				wasCrossbowChargedMainhand = false;
+			}
+
+			// crossbow offhand
+			ItemStack offHandStack = client.player.getOffHandStack();
+			if (offHandStack.getItem() instanceof CrossbowItem) {
+				boolean isCharged = CrossbowItem.isCharged(offHandStack);
+				if (wasCrossbowChargedOffhand && !isCharged && weaponAnimates) {
+					triggerShrink(9);
+				}
+				wasCrossbowChargedOffhand = isCharged;
+			} else {
+				wasCrossbowChargedOffhand = false;
+			}
+		});
+		// track block breaking to trigger tool animations
+		AtomicReference<BlockPos> lastBreakingPos = new AtomicReference<>();
+
+		ClientTickEvents.END_CLIENT_TICK.register(client -> {
+			if (client.world == null || client.player == null) return;
+
+
+			HitResult r = client.crosshairTarget;
+			if (r != null && r.getType() == HitResult.Type.BLOCK && client.options.attackKey.isPressed()) {
+				BlockPos targetPos = ((BlockHitResult) r).getBlockPos();
+				lastBreakingPos.set(targetPos);
+			}
+
+
+			BlockPos pending = lastBreakingPos.get();
+			if (pending != null) {
+
+				if (client.world.getBlockState(pending).isAir()) {
+					ItemStack stack = client.player.getMainHandStack();
+					if (stack.getItem() instanceof ToolItem && toolAnimates) {
+						int slot = client.player.getInventory().selectedSlot;
+						triggerShrink(slot);
+					}
+
+					lastBreakingPos.set(null);
+				}
+			}
+		});
+	}
+
+
+		private void triggerShrink(int slot) {
+		if (slot >= 0 && slot < 9) {
+			wasUsed[slot] = true;
+			slotScales[slot] = nonSelectedItemSize - (shouldItemGrowWhenSelected ? 0.03f : 0.2f);
+		} else if (slot == 9) {
+			wasUsed[slot] = true;
+			slotScales[slot] = nonSelectedItemSize - 0.2f;
+		}
+	}
+}

versions/1.20.1/src/client/java/derp/immersivehotbar/ImmersiveHotbarDataGenerator.java

@@ -0,0 +1,11 @@
+package derp.immersivehotbar;
+
+import net.fabricmc.fabric.api.datagen.v1.DataGeneratorEntrypoint;
+import net.fabricmc.fabric.api.datagen.v1.FabricDataGenerator;
+
+public class ImmersiveHotbarDataGenerator implements DataGeneratorEntrypoint {
+	@Override
+	public void onInitializeDataGenerator(FabricDataGenerator fabricDataGenerator) {
+
+	}
+}

versions/1.20.1/src/client/java/derp/immersivehotbar/InGameHudAnimationHandler.java

@@ -0,0 +1,5 @@
+package derp.immersivehotbar;
+
+public interface InGameHudAnimationHandler {
+    void immersive_hotbar$triggerSlotAnimation(int slotIndex);
+}

versions/1.20.1/src/client/java/derp/immersivehotbar/config/ImmersiveHotbarConfig.java

@@ -0,0 +1,93 @@
+package derp.immersivehotbar.config;
+
+import dev.isxander.yacl3.config.v2.api.SerialEntry;
+
+import java.awt.*;
+
+public class ImmersiveHotbarConfig {
+
+    @SerialEntry
+    public static float selectedItemSize = 1.2f;
+
+    @SerialEntry
+    public static float bouncyStiffness = 0.3f;
+
+    @SerialEntry
+    public static float bouncyDamping = 0.2f;
+
+    @SerialEntry
+    public static boolean shouldItemGrowWhenSelected = true;
+
+    @SerialEntry
+    public static boolean durabilityAnimates = true;
+
+    @SerialEntry
+    public static boolean toolAnimates = false;
+
+    @SerialEntry
+    public static boolean weaponAnimates = false;
+
+    @SerialEntry
+    public static boolean bouncyAnimation = false;
+
+    @SerialEntry
+    public static boolean foodAnimates = true;
+
+    @SerialEntry
+    public static boolean toolsIgnoreBounce = false;
+
+    @SerialEntry
+    public static boolean weaponsIgnoreBounce = false;
+
+    @SerialEntry
+    public static boolean textScales = true;
+
+    @SerialEntry
+    public static Color hotbarSelectionColor = new Color(255, 255, 255, 127);
+
+    @SerialEntry
+    public static boolean lowDurabilityGlow = false;
+
+    @SerialEntry
+    public static boolean immersiveToolTip = true;
+
+    @SerialEntry
+    public static int tooltipYOffset = 52;
+
+    @SerialEntry
+    public static boolean scaleTooltipOffset = true;
+
+    @SerialEntry
+    public static float durabilityGlowThreshold = 0.8f;
+
+    @SerialEntry
+    public static shouldShowBackground showBackground = shouldShowBackground.DISABLED;
+
+    @SerialEntry
+    public static float animationIntensity = 0.5f;
+
+    @SerialEntry
+    public static float nonSelectedItemSize = 1.0f;
+
+    @SerialEntry
+    public static float shrinkAnimationSpeed = 2.5f;
+
+    @SerialEntry
+    public static float animationSpeed = 0.1f;
+
+    public enum shouldShowBackground {
+        DISABLED,
+        ENABLED,
+        ONLY_WHEN_SELECTED;
+
+        @Override
+        public String toString() {
+            return switch (this) {
+                case DISABLED -> "Disabled";
+                case ENABLED -> "Always";
+                case ONLY_WHEN_SELECTED -> "Only When Selected";
+            };
+        }
+    }
+
+}