Update gradle.properties

This is helpful if one is using Firework rockets to fly around the landscape.

build.gradle

@@ -11,11 +11,8 @@ version = project.mod_version + "-" + project.minecraft_version + "-fabric"
 group = project.maven_group
 
 repositories {
-    // Add repositories to retrieve artifacts from in here.
+	maven { url "https://maven.shedaniel.me/" }
-    // You should only use this when depending on other mods because
+	maven { url "https://maven.terraformersmc.com/" }
-    // 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.
 }
 
 dependencies {
@@ -24,8 +21,8 @@ dependencies {
 	mappings "net.fabricmc:yarn:${project.yarn_mappings}:v2"
 	modImplementation "net.fabricmc:fabric-loader:${project.loader_version}"
 
-	// Fabric API. This is technically optional, but you probably want it anyway.
+	modApi "me.shedaniel.cloth:cloth-config-fabric:${project.cloth_version}"
-	modImplementation "net.fabricmc.fabric-api:fabric-api:${project.fabric_version}"
+	modImplementation "com.terraformersmc:modmenu:${project.modmenu_version}"
 
 	// PSA: Some older mods, compiled on Loom 0.2.1, might have outdated Maven POMs.
 	// You may need to force-disable transitiveness on them.

gradle.properties

@@ -7,11 +7,10 @@ org.gradle.jvmargs=-Xmx1G
 	yarn_mappings=1.16.4+build.9
 	loader_version=0.11.1
 
+cloth_version=4.11.14
+modmenu_version=1.16.8
+
 # Mod Properties
-	mod_version = 0.1
+	mod_version = 1.2
 	maven_group = markil3
 	archives_base_name = immersive_hud
-
-# Dependencies
-	# currently not on the main fabric site, check on the maven: https://maven.fabricmc.net/net/fabricmc/fabric-api/fabric-api
-	fabric_version=0.30.3+1.16

src/main/java/markil3/immersive_hud/ConfigManager.java

@@ -0,0 +1,377 @@
+package markil3.immersive_hud;
+
+import net.minecraft.item.Item;
+import net.minecraft.item.Items;
+import net.minecraft.util.Identifier;
+import net.minecraft.util.math.MathHelper;
+import net.minecraft.util.registry.Registry;
+
+import me.shedaniel.autoconfig.AutoConfig;
+
+import static markil3.immersive_hud.Main.TICKS_PER_SECOND;
+
+import java.util.Arrays;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+/**
+ * Configuration manager of this mod, which reads from and writes to this mod's
+ * configuration file.
+ * <p>
+ * The methods that change this mod's configuration do not automatically write
+ * those changes to the configuration file on disk. Instead, they only update
+ * the configuration in memory.
+ *
+ * @author Markil 3
+ */
+public class ConfigManager
+{
+    public static class TimeValues
+    {
+        private static final int SHOW_TIME = 6 * TICKS_PER_SECOND;
+        private static final int FADE_IN = TICKS_PER_SECOND / 2;
+        private static final int FADE_OUT = TICKS_PER_SECOND;
+
+        private int maxTime = SHOW_TIME;
+        private int fadeIn = FADE_IN;
+        private int fadeOut = FADE_OUT;
+
+        /**
+         * Obtains the maximum time that the hotbar can be on the screen,
+         * including fading.
+         *
+         * @return The maximum hotbar display time.
+         */
+        public int getMaxTime()
+        {
+            return this.maxTime;
+        }
+
+        /**
+         * Obtains the time that the hotbar takes to fade in.
+         *
+         * @return The hotbar fade in time.
+         */
+        public int getFadeInTime()
+        {
+            return this.fadeIn;
+        }
+
+        /**
+         * Obtains the time that the hotbar takes to fade out.
+         *
+         * @return The hotbar fade out time.
+         */
+        public int getFadeOutTime()
+        {
+            return this.fadeOut;
+        }
+
+        public void setMaxTime(int time)
+        {
+            this.maxTime = time;
+        }
+
+        public void setFadeInTime(int time)
+        {
+            this.fadeIn = time;
+        }
+
+        public void setFadeOutTime(int time)
+        {
+            this.fadeOut = time;
+        }
+    }
+
+    private TimeValues hotbarTime = new TimeValues();
+    private TimeValues experienceTime = new TimeValues();
+    private TimeValues jumpTime = new TimeValues();
+    private TimeValues healthTime = new TimeValues();
+    private TimeValues hungerTime = new TimeValues();
+    private TimeValues effectTime = new TimeValues();
+    private int crosshairTime = 6 * TICKS_PER_SECOND;
+    private boolean hideCrosshair = true;
+    private int handTime = 30 * TICKS_PER_SECOND;
+    private boolean hideHands = true;
+    private boolean showArmor = true;
+    private double minHealth = 0.5;
+    private int minHunger = 17;
+    private Identifier[] ignoredItems = new Identifier[]{Registry.ITEM.getId(Items.FIREWORK_ROCKET)};
+
+    /**
+     * Returns the instance of this class.
+     *
+     * @return the instance of this class
+     */
+    public static ConfigManager getInstance()
+    {
+        try
+        {
+            if (Class.forName("me.shedaniel.autoconfig.AutoConfig") != null)
+            {
+                return AutoConfig.getConfigHolder(ConfigManagerCloth.class)
+                        .getConfig();
+            }
+            else
+            {
+                throw new ClassNotFoundException();
+            }
+        }
+        catch (ClassNotFoundException e)
+        {
+            return new ConfigManager();
+        }
+    }
+
+    // Validations
+
+    /**
+     * Obtains time values related to the hotbar.
+     *
+     * @return The hotbar display time values.
+     */
+    public TimeValues getHotbarTime()
+    {
+        return this.hotbarTime;
+    }
+
+    /**
+     * Obtains time values related to the experience bar.
+     *
+     * @return The experience bar display time values.
+     */
+    public TimeValues getExperienceTime()
+    {
+        return this.experienceTime;
+    }
+
+    /**
+     * Obtains time values related to the jump bar.
+     *
+     * @return The jump display time values.
+     */
+    public TimeValues getJumpTime()
+    {
+        return this.jumpTime;
+    }
+
+    /**
+     * Obtains time values related to the health bar.
+     *
+     * @return The health display time values.
+     */
+    public TimeValues getHealthTime()
+    {
+        return this.healthTime;
+    }
+
+    /**
+     * Obtains time values related to the hunger bar.
+     *
+     * @return The hunger display time values.
+     */
+    public TimeValues getHungerTime()
+    {
+        return this.hungerTime;
+    }
+
+    /**
+     * Obtains time values related to potion effects.
+     *
+     * @return Potion display time values.
+     */
+    public TimeValues getPotionTime()
+    {
+        return this.effectTime;
+    }
+
+    /**
+     * Obtains the time that the crosshairs are allowed to display.
+     *
+     * @return The crosshair display time values.
+     */
+    public int getCrosshairTime()
+    {
+        return this.crosshairTime;
+    }
+    /**
+     * Checks whether the crosshairs should be hidden after a period of time.
+     *
+     * @return - Whether or not crosshairs will be hidden.
+     */
+    public boolean hideCrosshair()
+    {
+        return this.hideCrosshair;
+    }
+
+    /**
+     * Obtains the time that the hands are allowed to display.
+     *
+     * @return The hand display time values.
+     */
+    public int getHandTime()
+    {
+        return this.handTime;
+    }
+
+    /**
+     * Checks whether hands should be hidden after a period of time.
+     *
+     * @return - Whether or not hands will be hidden.
+     */
+    public boolean hideHands()
+    {
+        return this.hideHands;
+    }
+
+    /**
+     * Checks whether the armor bar should render.
+     *
+     * @return Whether or not armor shows on the HUD.
+     */
+    public boolean shouldShowArmor()
+    {
+        return this.showArmor;
+    }
+
+    /**
+     * Obtains the minimum health for fading. Anything below that and the health
+     * always displays.
+     *
+     * @return The health boundary, from 0 to 1.
+     */
+    public double getMinHealth()
+    {
+        return this.minHealth;
+    }
+
+    /**
+     * Obtains the minimum hunger for fading. Anything below that and the hunger
+     * always displays.
+     *
+     * @return The hunger boundary, from 0 to 20.
+     */
+    public int getMinHunger()
+    {
+        return this.minHunger;
+    }
+
+    /**
+     * Obtains a collection of items that won't cause hands and crosshairs to show when used.
+     *
+     * @return A set of ignored items.
+     */
+    public Set<Item> getIgnoredItems()
+    {
+        return Arrays.stream(ignoredItems).map(Registry.ITEM::get).collect(Collectors.toSet());
+    }
+
+    /**
+     * Obtains a collection of items that won't cause hands and crosshairs to show when used.
+     *
+     * @return An array of identifiers.
+     */
+    public Identifier[] getIgnoredIdentifiers()
+    {
+        return this.ignoredItems;
+    }
+
+    /**
+     * Sets the time that the hands are allowed to display.
+     *
+     * @param time - The hand display time values.
+     */
+    public void setCrosshairTime(int time)
+    {
+        this.crosshairTime = time;
+    }
+
+    /**
+     * Sets whether the crosshairs should be hidden after a period of time.
+     *
+     * @param hide - Whether or not crosshairs will be hidden.
+     */
+    public void hideCrosshair(boolean hide)
+    {
+        this.hideCrosshair = hide;
+    }
+
+    /**
+     * Sets the time that the hands are allowed to display.
+     *
+     * @param time - The hand display time values.
+     */
+    public void setHandTime(int time)
+    {
+        this.handTime = time;
+    }
+
+    /**
+     * Sets whether hands should be hidden after a period of time.
+     *
+     * @param hide - Whether or not hands will be hidden.
+     */
+    public void hideHands(boolean hide)
+    {
+        this.hideHands = hide;
+    }
+
+    /**
+     * Determines whether the armor bar should render.
+     *
+     * @param show - Whether or not armor shows on the HUD.
+     */
+    public void shouldShowArmor(boolean show)
+    {
+        this.showArmor = show;
+    }
+
+    /**
+     * Sets the minimum health for fading. Anything below that and the health
+     * always displays.
+     *
+     * @param boundary - The health boundary, from 0 to 1.
+     */
+    public void setMinHealth(double boundary)
+    {
+        this.minHealth = MathHelper.clamp(boundary, 0, 1);
+    }
+
+    /**
+     * Sets the minimum hunger for fading. Anything below that and the hunger
+     * always displays.
+     *
+     * @param boundary - The hunger boundary, from 0 to 20.
+     */
+    public void setMinHunger(int boundary)
+    {
+        this.minHunger = MathHelper.clamp(boundary, 0, 20);
+    }
+
+    /**
+     * Sets which items won't cause the hands and crosshairs to show when used.
+     *
+     * @param items - A set of ignored items.
+     */
+    public void setIgnoredItems(Item... items)
+    {
+        this.ignoredItems = Arrays.stream(items).map(Registry.ITEM::getId).toArray(Identifier[]::new);
+    }
+
+    /**
+     * Sets which items won't cause the hands and crosshairs to show when used.
+     *
+     * @param items - A set of ignored items.
+     */
+    public void setIgnoredItems(String... items)
+    {
+        this.ignoredItems = Arrays.stream(items).map(Identifier::new).filter(i -> Registry.ITEM.getOrEmpty(i).isPresent()).toArray(Identifier[]::new);
+    }
+/**
+     * Saves changes to this mod's configuration.
+     */
+//    public void save()
+//    {
+//        SPEC.save();
+//    }
+}

src/main/java/markil3/immersive_hud/ConfigManagerCloth.java

@@ -0,0 +1,14 @@
+package markil3.immersive_hud;
+
+import me.shedaniel.autoconfig.ConfigData;
+import me.shedaniel.autoconfig.annotation.Config;
+
+@Config(name = "immersive_hud")
+public class ConfigManagerCloth extends ConfigManager implements ConfigData
+{
+    @Override
+    public void validatePostLoad() throws ValidationException
+    {
+        this.setMinHealth(this.getMinHealth());
+    }
+}

src/main/java/markil3/immersive_hud/Main.java

@@ -18,8 +18,9 @@
 package markil3.immersive_hud;
 
 import net.fabricmc.api.ModInitializer;
-import net.minecraft.client.gui.DrawableHelper;
+
-import net.minecraft.client.util.math.MatrixStack;
+import me.shedaniel.autoconfig.AutoConfig;
+import me.shedaniel.autoconfig.serializer.Toml4jConfigSerializer;
 
 /**
  * The main entry point for the Immersive HUD mod.
@@ -29,9 +30,23 @@ import net.minecraft.client.util.math.MatrixStack;
  */
 public class Main implements ModInitializer
 {
+    public static final int TICKS_PER_SECOND = 20;
+
     @Override
     public void onInitialize()
     {
+        try
+        {
+            if (Class.forName("me.shedaniel.autoconfig.AutoConfig") != null)
+            {
+                AutoConfig.register(ConfigManagerCloth.class,
+                        Toml4jConfigSerializer::new);
+            }
+        }
+        catch (ClassNotFoundException e)
+        {
+            // Do nothing
+        }
     }
 
     /**
@@ -45,9 +60,19 @@ public class Main implements ModInitializer
      *
      * @since 0.1-1.16.4-fabric
      */
-    static float getAlpha(int renderTime)
+    static float getAlpha(double renderTime,
+                          double maxTime,
+                          double fadeInTime,
+                          double fadeOutTime)
     {
-        return Math.min(renderTime / 20.0F,
+        if (renderTime <= fadeOutTime)
-                1.0F);
+        {
+            return (float) (renderTime / fadeOutTime);
+        }
+        else if (renderTime > maxTime - fadeInTime)
+        {
+            return (float) ((maxTime - renderTime) / fadeInTime);
+        }
+        return 1F;
     }
 }

src/main/java/markil3/immersive_hud/ModMenu.java

@@ -0,0 +1,232 @@
+package markil3.immersive_hud;
+
+import com.terraformersmc.modmenu.api.ConfigScreenFactory;
+import com.terraformersmc.modmenu.api.ModMenuApi;
+
+import net.minecraft.item.Items;
+import net.minecraft.text.TranslatableText;
+import net.minecraft.util.Identifier;
+import net.minecraft.util.InvalidIdentifierException;
+import net.minecraft.util.registry.Registry;
+
+import me.shedaniel.autoconfig.AutoConfig;
+import me.shedaniel.clothconfig2.api.ConfigBuilder;
+import me.shedaniel.clothconfig2.api.ConfigCategory;
+import me.shedaniel.clothconfig2.api.ConfigEntryBuilder;
+import me.shedaniel.clothconfig2.gui.entries.DoubleListEntry;
+
+import static markil3.immersive_hud.Main.TICKS_PER_SECOND;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+public class ModMenu implements ModMenuApi
+{
+
+    private void startTimeField(String name, ConfigEntryBuilder entryBuilder,
+                                ConfigCategory cat,
+                                ConfigManager.TimeValues value)
+    {
+        final float SHOW_TIME = 6;
+        final float FADE_IN = 0.25F;
+        final float FADE_OUT = 0.5F;
+
+        DoubleListEntry maxTime =
+                entryBuilder.startDoubleField(new TranslatableText(
+                                "option.immersive_hud." + name +
+                                        "MaxTime"),
+                        (float) value.getMaxTime() / TICKS_PER_SECOND)
+                            .setDefaultValue(SHOW_TIME)
+                            .setMin(0)
+                            .setMax(10 * 60 * TICKS_PER_SECOND) // 10 Minutes
+                            .setTooltip(new TranslatableText(
+                                    "tooltip.immersive_hud." + name +
+                                            "MaxTime"))
+                            .setSaveConsumer(val -> value
+                                    .setMaxTime((int) (val * TICKS_PER_SECOND)))
+                            .build();
+
+        DoubleListEntry fadeIn =
+                entryBuilder.startDoubleField(new TranslatableText(
+                                "option.immersive_hud." + name +
+                                        "FadeIn"),
+                        (float) value.getFadeInTime() / TICKS_PER_SECOND)
+                            .setDefaultValue(FADE_IN)
+                            .setMin(0)
+                            .setMax(10 * 60 * TICKS_PER_SECOND)
+                            .setTooltip(new TranslatableText(
+                                    "tooltip.immersive_hud." + name +
+                                            "FadeIn"))
+                            .setSaveConsumer(val -> value
+                                    .setFadeInTime((int) (val * TICKS_PER_SECOND)))
+                            .build();
+
+        DoubleListEntry fadeOut =
+                entryBuilder.startDoubleField(new TranslatableText(
+                                "option.immersive_hud." + name +
+                                        "FadeOut"),
+                        (float) value.getFadeOutTime() / TICKS_PER_SECOND)
+                            .setDefaultValue(FADE_OUT)
+                            .setMin(0)
+                            .setMax(10 * 60 * TICKS_PER_SECOND)
+                            .setTooltip(new TranslatableText(
+                                    "tooltip.immersive_hud." + name +
+                                            "FadeOut"))
+                            .setSaveConsumer(val -> value
+                                    .setFadeOutTime((int) (val * TICKS_PER_SECOND)))
+                            .build();
+
+        cat.addEntry(maxTime);
+        cat.addEntry(fadeIn);
+        cat.addEntry(fadeOut);
+    }
+
+    @Override
+    public ConfigScreenFactory<?> getModConfigScreenFactory()
+    {
+        return screen -> {
+            ConfigCategory general;
+            ConfigEntryBuilder entryBuilder;
+            ConfigManager instance = ConfigManager.getInstance();
+            final ConfigBuilder builder = ConfigBuilder.create()
+                                                       .setParentScreen(screen)
+                                                       .setTitle(new TranslatableText(
+                                                               "immersive_hud.configGui.title"))
+                                                       .setSavingRunnable(() -> {
+                                                           try
+                                                           {
+                                                               if (Class
+                                                                       .forName("me.shedaniel.autoconfig.AutoConfig") != null)
+                                                               {
+                                                                   AutoConfig
+                                                                           .getConfigHolder(ConfigManagerCloth.class)
+                                                                           .save();
+                                                               }
+                                                           }
+                                                           catch (ClassNotFoundException e)
+                                                           {
+                                                               // Do nothing
+                                                           }
+                                                       });
+            general =
+                    builder.getOrCreateCategory(new TranslatableText(
+                            "category.immersive_hud.general"));
+            entryBuilder = builder.entryBuilder();
+
+            startTimeField("hotbar", entryBuilder,
+                    general,
+                    instance.getHotbarTime());
+            startTimeField("experience", entryBuilder,
+                    general,
+                    instance.getExperienceTime());
+            startTimeField("jump", entryBuilder,
+                    general,
+                    instance.getJumpTime());
+            startTimeField("jump", entryBuilder,
+                    general,
+                    instance.getHealthTime());
+            startTimeField("hunger", entryBuilder,
+                    general,
+                    instance.getHungerTime());
+            startTimeField("effect", entryBuilder,
+                    general,
+                    instance.getPotionTime());
+
+            general.addEntry(entryBuilder.startDoubleField(new TranslatableText(
+                            "option.immersive_hud" +
+                                    ".crosshairTime"),
+                    (float) instance.getCrosshairTime() / TICKS_PER_SECOND)
+                                         .setDefaultValue(6)
+                                         .setTooltip(new TranslatableText(
+                                                 "tooltip.immersive_hud" +
+                                                         ".crosshairTime"))
+                                         .setSaveConsumer(val -> instance
+                                                 .setCrosshairTime((int) (val * TICKS_PER_SECOND)))
+                                         .build());
+
+            general.addEntry(entryBuilder.startBooleanToggle(new TranslatableText(
+                            "option.immersive_hud.hideCrosshair"),
+                    instance.hideCrosshair())
+                                         .setDefaultValue(true)
+                                         .setTooltip(new TranslatableText(
+                                                 "tooltip.immersive_hud.hideCrosshair"))
+                                         .setSaveConsumer(val -> instance.hideCrosshair(val))
+                                         .build());
+
+            general.addEntry(entryBuilder.startDoubleField(new TranslatableText(
+                            "option.immersive_hud.handTime"),
+                    (float) instance.getHandTime() / TICKS_PER_SECOND)
+                                         .setDefaultValue(30)
+                                         .setTooltip(new TranslatableText(
+                                                 "tooltip.immersive_hud.handTime"))
+                                         .setSaveConsumer(val -> instance
+                                                 .setHandTime((int) (val * TICKS_PER_SECOND)))
+                                         .build());
+
+            general.addEntry(entryBuilder.startBooleanToggle(new TranslatableText(
+                            "option.immersive_hud.hideHands"),
+                    instance.hideHands())
+                                         .setDefaultValue(true)
+                                         .setTooltip(new TranslatableText(
+                                                 "tooltip.immersive_hud.hideHands"))
+                                         .setSaveConsumer(val -> instance.hideHands(val))
+                                         .build());
+
+            general.addEntry(entryBuilder.startDoubleField(new TranslatableText(
+                            "option.immersive_hud.minHealth"),
+                    instance.getMinHealth())
+                                         .setDefaultValue(0.5)
+                                         .setTooltip(new TranslatableText(
+                                                 "tooltip.immersive_hud.minHealth"))
+                                         .setSaveConsumer(val -> instance.setMinHealth(val))
+                                         .build());
+
+            general.addEntry(entryBuilder.startIntField(new TranslatableText(
+                            "option.immersive_hud.minHunger"),
+                    instance.getMinHunger())
+                                         .setDefaultValue(17)
+                                         .setTooltip(new TranslatableText(
+                                                 "tooltip.immersive_hud.minHunger"))
+                                         .setSaveConsumer(val -> instance.setMinHunger(val))
+                                         .build());
+
+            general.addEntry(entryBuilder.startBooleanToggle(new TranslatableText(
+                            "option.immersive_hud.showArmor"),
+                    instance.shouldShowArmor())
+                                         .setDefaultValue(true)
+                                         .setTooltip(new TranslatableText(
+                                                 "tooltip.immersive_hud.showArmor"))
+                                         .setSaveConsumer(val -> instance.shouldShowArmor(val))
+                                         .build());
+
+            general.addEntry(entryBuilder
+                    .startStrList(new TranslatableText("option.immersive_hud.ignoreList"), Arrays
+                            .asList(instance
+                                    .getIgnoredIdentifiers()).stream().map(Identifier::toString)
+                            .collect(Collectors.toList()))
+                    .setDefaultValue(Arrays
+                            .asList(Registry.ITEM.getId(Items.FIREWORK_ROCKET).toString()))
+                    .setTooltip(new TranslatableText("tooltip.immersive_hud.ignoreList"))
+                    .setSaveConsumer(val -> instance.setIgnoredItems(val.toArray(new String[0]))).setErrorSupplier(val -> {
+                        try
+                        {
+                            Optional<String> item = val.stream().filter(i -> !Registry.ITEM.getOrEmpty(new Identifier(i)).isPresent()).findFirst();
+                            if (item.isPresent())
+                            {
+                                return Optional.of(new TranslatableText("error.immersive_hud.ignoreList.unknownItem"));
+                            }
+                        }
+                        catch (InvalidIdentifierException e)
+                        {
+                            return Optional.of(new TranslatableText("error.immersive_hud.ignoreList.illegalId"));
+                        }
+                        return Optional.empty();
+                    })
+                    .build());
+
+            return builder.build();
+        };
+    }
+}

src/main/java/markil3/immersive_hud/TimerUtils.java

@@ -23,6 +23,8 @@ import net.minecraft.client.network.ClientPlayerEntity;
 import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.entity.Entity;
 import net.minecraft.entity.LivingEntity;
+import net.minecraft.entity.effect.StatusEffect;
+import net.minecraft.entity.effect.StatusEffectInstance;
 import net.minecraft.entity.effect.StatusEffects;
 import net.minecraft.entity.player.PlayerEntity;
 import net.minecraft.item.BowItem;
@@ -41,12 +43,13 @@ import net.minecraft.item.TridentItem;
 import net.minecraft.util.Hand;
 import net.minecraft.util.hit.EntityHitResult;
 import net.minecraft.util.hit.HitResult;
+import net.minecraft.util.math.MathHelper;
 
-import org.apache.logging.log4j.LogManager;
+import java.util.HashMap;
-import org.apache.logging.log4j.Logger;
+import java.util.HashSet;
-
 import java.util.Iterator;
 import java.util.Optional;
+import java.util.Set;
 
 /**
  * Contains the logic for changing the HUD.
@@ -54,35 +57,19 @@ import java.util.Optional;
  * @author Markil 3
  * @version 0.1-1.16.4-fabric
  */
-public class EventBus
+public class TimerUtils
 {
-    /**
-     * The number of ticks that the hand will be onscreen. Every tick is 1/20th
-     * of a second.
-     */
-    static final int HAND_TIME = 10 * 20;
-    /**
-     * The number of ticks most elements will be onscreen. Every tick is 1/20th
-     * of a second.
-     */
-    static final int VISUAL_TIME = 6 * 20;
-    /**
-     * The number of ticks that the health and hunger bars will be onscreen.
-     * Every tick is 1/20th of a second.
-     */
-    static final int HEALTH_TIME = (int) ((float) VISUAL_TIME * 2.5);
-
     /**
      * How many more ticks the hand will be onscreen. Every tick is 1/20th of a
      * second.
      */
-    private static int mainHandTime, offHandTime;
+    private static double mainHandTime, offHandTime;
 
     /**
      * How many more ticks the crosshair will be onscreen. Every tick is 1/20th
      * of a second.
      */
-    private static int crosshairTime;
+    private static double crosshairTime;
     /**
      * If true, then the hand (and crosshairs) will be locked onto the screen
      * without disappearing until this flag is updated.
@@ -95,11 +82,13 @@ public class EventBus
      */
     private static int mapLock;
 
+    private static HashMap<StatusEffect, Double> effectTime = new HashMap<>();
+
     /**
      * How many more ticks the hotbar will be onscreen. Every tick is 1/20th of
      * a second.
      */
-    private static int hotbarTime;
+    private static double hotbarTime;
     /**
      * The last hotbar slot that was selected. This is used to check for a
      * change in the hotbar slot.
@@ -115,7 +104,7 @@ public class EventBus
      * How many more ticks the health bar will be onscreen. Every tick is 1/20th
      * of a second.
      */
-    private static int healthTime;
+    private static double healthTime;
     /**
      * Records what the health was previously. Used to check for a change in the
      * health.
@@ -133,7 +122,7 @@ public class EventBus
      * How many more ticks the hunger bar will be onscreen. Every tick is 1/20th
      * of a second.
      */
-    private static int hungerTime;
+    private static double hungerTime;
     /**
      * Records what the hunger level was previously. Used to check for a change
      * in hunger.
@@ -149,7 +138,7 @@ public class EventBus
      * How many more ticks the mount's health bar will be onscreen. Every tick
      * is 1/20th of a second.
      */
-    private static int mountTime;
+    private static double mountTime;
     /**
      * Records what the health of the mount was previously. Used to check for a
      * change in the health.
@@ -165,19 +154,135 @@ public class EventBus
      * How many more ticks the mount's jump bar will be onscreen. Every tick is
      * 1/20th of a second.
      */
-    private static int jumpTime;
+    private static double jumpTime;
 
     /**
      * How many more ticks the experience bar will be onscreen. Every tick is
      * 1/20th of a second.
      */
-    private static int experienceTime;
+    private static double experienceTime;
     /**
      * Records what the experience was previously. Used to check for a change in
      * the health.
      */
     private static float experienceProgress = -1;
 
+    /**
+     * Sets the transparency level of the next drawn element.
+     *
+     * @param alpha - The transparency, from 0 to 1.
+     */
+    public static void setAlpha(float alpha)
+    {
+        RenderSystem.color4f(1.0F, 1.0F, 1.0F, alpha);
+    }
+
+    /**
+     * Resets the transparency level.
+     *
+     * @see #setAlpha(float)
+     */
+    public static void resetAlpha()
+    {
+        setAlpha(1.0F);
+    }
+
+    /**
+     * Obtains the offset from the bottom of the screen that the hotbar
+     * receives.
+     *
+     * @return The offset the hotbar uses.
+     */
+    public static int getHotbarTranslation()
+    {
+        ConfigManager.TimeValues hotbar =
+                ConfigManager.getInstance().getHotbarTime();
+        return (int) (22F * (1 - Main.getAlpha(hotbarTime,
+                hotbar.getMaxTime(),
+                hotbar.getFadeInTime(),
+                hotbar.getFadeOutTime())));
+    }
+
+    /**
+     * Obtains the offset from the bottom of the screen that the experience bar
+     * receives.
+     *
+     * @return The offset the experience bar uses.
+     */
+    public static int getExperienceTranslation()
+    {
+        ConfigManager.TimeValues experience =
+                ConfigManager.getInstance().getExperienceTime();
+        return (int) ((12F + (22 - getHotbarTranslation())) * (1 - Main.getAlpha(
+                experienceTime,
+                experience.getMaxTime(),
+                experience.getFadeInTime(),
+                experience.getFadeOutTime()))) + getHotbarTranslation();
+    }
+
+    /**
+     * Obtains the offset from the bottom of the screen that the jump bar
+     * receives.
+     *
+     * @return The offset the jump bar uses.
+     */
+    public static int getJumpTranslation()
+    {
+        ConfigManager.TimeValues jump =
+                ConfigManager.getInstance().getExperienceTime();
+        return (int) ((12F + (22 - getHotbarTranslation())) * (1 - Main.getAlpha(
+                jumpTime,
+                jump.getMaxTime(),
+                jump.getFadeInTime(),
+                jump.getFadeOutTime()))) + getHotbarTranslation();
+    }
+
+    /**
+     * Obtains the offset that the status bars (health, hunger, etc.) gets from
+     * their usual position.
+     *
+     * @return The offset.
+     */
+    public static float getHealthTranslation()
+    {
+        ConfigManager.TimeValues hotbar =
+                ConfigManager.getInstance().getHotbarTime();
+        ConfigManager.TimeValues experience =
+                ConfigManager.getInstance().getExperienceTime();
+        ConfigManager.TimeValues jump =
+                ConfigManager.getInstance().getJumpTime();
+        ConfigManager.TimeValues healthTimes = ConfigManager.getInstance().getHealthTime();
+        ConfigManager.TimeValues hungerTimes = ConfigManager.getInstance().getHungerTime();
+
+        float hotbarAlpha = Main.getAlpha(hotbarTime,
+                hotbar.getMaxTime(),
+                hotbar.getFadeInTime(),
+                hotbar.getFadeOutTime());
+        float experienceAlpha = Main.getAlpha(experienceTime,
+                experience.getMaxTime(),
+                experience.getFadeInTime(),
+                experience.getFadeOutTime());
+        float jumpAlpha = Main.getAlpha(jumpTime,
+                jump.getMaxTime(),
+                jump.getFadeInTime(),
+                jump.getFadeOutTime());
+        float statusAlpha = Main.getAlpha(healthTime,
+                healthTimes.getMaxTime(),
+                healthTimes.getFadeInTime(),
+                healthTimes.getFadeOutTime());
+        statusAlpha = Math.max(statusAlpha, Main.getAlpha(hungerTime,
+                hungerTimes.getMaxTime(),
+                hungerTimes.getFadeInTime(),
+                hungerTimes.getFadeOutTime()));
+        /*
+         * Draw it in its standard location until it is completely transparent, then move it
+         * instantly.
+         */
+        statusAlpha = (float) Math.ceil(statusAlpha);
+        return 7 * (1 - Math.max(experienceAlpha,
+                jumpAlpha)) + 22 * (1 - hotbarAlpha) + 42 * (1 - statusAlpha);
+    }
+
     /**
      * Run whenever the player clicks a mouse button. This brings the hands into
      * view, and briefly brings the health and hunger into view if the held item
@@ -185,15 +290,21 @@ public class EventBus
      *
      * @param hand  - The hand being triggered
      * @param clear - Whether the hand it being enabled or disabled.
-     *
      * @since 0.1-1.16.4-fabric
      */
     public static void onClick(Hand hand, boolean clear)
     {
+        ConfigManager.TimeValues health =
+                ConfigManager.getInstance().getHealthTime();
+        ConfigManager.TimeValues hunger =
+                ConfigManager.getInstance().getHungerTime();
+        double handTime = ConfigManager.getInstance().getHandTime();
+
         MinecraftClient mc = MinecraftClient.getInstance();
         LivingEntity entity;
         Item item;
         Iterator<ItemStack> hands;
+        Set<Item> ignored;
         if (mc.getCameraEntity() instanceof LivingEntity)
         {
             entity = (LivingEntity) mc.getCameraEntity();
@@ -219,23 +330,35 @@ public class EventBus
                             .map(ItemStack::getItem)
                             .orElse(null);
         }
-        crosshairTime = VISUAL_TIME;
+        if (item != null)
+        {
+            ignored = ConfigManager.getInstance().getIgnoredItems();
+            if (ignored.contains(item))
+            {
+                return;
+            }
+        }
+        crosshairTime = ConfigManager.getInstance().getCrosshairTime();
         if (hand == Hand.MAIN_HAND)
         {
-            mainHandTime = HAND_TIME;
+            mainHandTime = handTime;
             mainHandLock = item != null;
         }
         else
         {
-            offHandTime = HAND_TIME;
+            offHandTime = handTime;
             offHandLock = item != null;
         }
         if (item != null)
         {
             if (item.isFood())
             {
-                healthTime = HEALTH_TIME;
+                healthTime = health.getMaxTime() - (healthTime > 0 ?
-                hungerTime = HEALTH_TIME;
+                        health.getFadeInTime() :
+                        0);
+                hungerTime = hunger.getMaxTime() - (hungerTime > 0 ?
+                        hunger.getFadeInTime() :
+                        0);
             }
         }
         else
@@ -250,14 +373,18 @@ public class EventBus
      *
      * @param hand        - The hand being rendered.
      * @param matrixStack - The rendering stack.
-     *
      * @return If true, then don't render this hand at all.
-     *
      * @since 0.1-1.16.4-fabric
      */
-    public static boolean onRenderHand(Hand hand, MatrixStack matrixStack)
+    public static boolean onRenderHand(Hand hand,
+                                       MatrixStack matrixStack,
+                                       float ticks)
+    {
+        final float HAND_UP_TIME = 20F;
+
+        boolean hideHands = ConfigManager.getInstance().hideHands();
+        if (hideHands)
         {
-        final int HAND_UP_TIME = 20;
             switch (hand)
             {
             case OFF_HAND:
@@ -267,7 +394,10 @@ public class EventBus
                 }
                 else if (!offHandLock && (mapLock & 0b01) == 0)
                 {
-                offHandTime--;
+                    if (offHandTime > 0)
+                    {
+                        offHandTime -= ticks;
+                    }
                     if (offHandTime < HAND_UP_TIME)
                     {
                         matrixStack
@@ -285,8 +415,10 @@ public class EventBus
                 }
                 else if (!mainHandLock && (mapLock & 0b10) == 0)
                 {
-                System.out.println("Decreasing main hand time");
+                    if (mainHandTime > 0)
-                mainHandTime--;
+                    {
+                        mainHandTime -= ticks;
+                    }
                     if (mainHandTime < HAND_UP_TIME)
                     {
                         matrixStack
@@ -298,6 +430,7 @@ public class EventBus
                 }
                 break;
             }
+        }
         return false;
     }
 
@@ -306,14 +439,21 @@ public class EventBus
      * needed.
      *
      * @return If true, then cancel drawing the crosshair.
-     *
      * @since 0.1-1.16.4-fabric
      */
-    public static boolean drawCrosshair()
+    public static boolean drawCrosshair(float ticks)
     {
+        final double CROSSHAIR_TIME =
+                ConfigManager.getInstance().getCrosshairTime();
+
         MinecraftClient mc = MinecraftClient.getInstance();
         Entity entity = mc.getCameraEntity();
         boolean changed = false;
+        boolean canceled = false;
+
+        boolean hideCrosshair = ConfigManager.getInstance().hideCrosshair();
+        if (hideCrosshair)
+        {
             if (mc.crosshairTarget != null && mc.crosshairTarget
                     .getType() != HitResult.Type.MISS)
             {
@@ -334,25 +474,20 @@ public class EventBus
             if (changed || mainHandLock || offHandLock || crosshairTime
                     > 0)
             {
-            RenderSystem.color4f(1.0F,
+                setAlpha(Main.getAlpha(crosshairTime > 0 ?
-                    1.0F,
-                    1.0F,
-                    Main.getAlpha(crosshairTime > 0 ?
                         crosshairTime :
-                                  VISUAL_TIME));
+                        CROSSHAIR_TIME, CROSSHAIR_TIME, 0, 0));
             }
             else
             {
-            RenderSystem.color4f(1.0F,
+                canceled = true;
-                    1.0F,
-                    1.0F,
-                    0F);
             }
             if (crosshairTime > 0)
             {
-            crosshairTime--;
+                crosshairTime -= ticks;
             }
-        return false;
+        }
+        return canceled;
     }
 
     /**
@@ -360,17 +495,20 @@ public class EventBus
      * as needed.
      *
      * @return If true, then cancel drawing the mount health bar.
-     *
      * @since 0.1-1.16.4-fabric
      */
-    public static boolean drawMountHealth()
+    public static boolean drawMountHealth(MatrixStack stack, float ticks)
     {
         /*
          * When the health percentage falls to this level or below, the
          * health bar won't disappear, allowing the player to be constantly
          * reminded of their low health.
          */
-        final float CONST_BOUNDARY = 0.5F;
+        final double HEALTH_BOUNDARY =
+                ConfigManager.getInstance().getMinHealth();
+
+        ConfigManager.TimeValues healthTimes =
+                ConfigManager.getInstance().getHealthTime();
 
         MinecraftClient mc = MinecraftClient.getInstance();
         Entity entity = mc.getCameraEntity();
@@ -378,7 +516,7 @@ public class EventBus
         LivingEntity mount;
         boolean changed = false;
 
-        if (tmp == null)
+        if (tmp == null || !(tmp instanceof LivingEntity))
         {
             mountHealth = -1;
             mountMaxHealth = -1;
@@ -399,74 +537,172 @@ public class EventBus
         }
         if (changed)
         {
-            mountTime = VISUAL_TIME;
+            mountTime = healthTimes.getMaxTime() - (mountTime > 0 ?
+                    healthTimes.getFadeInTime() :
+                    0);
         }
         else if (mountTime > 0)
         {
-            mountTime--;
+            mountTime -= ticks;
         }
+
+        /*
+         * Only makes a change if the player is healthy. Otherwise,
+         * the bar is shown.
+         */
+        if (mountHealth / mountMaxHealth > HEALTH_BOUNDARY)
+        {
             if (mountTime > 0)
             {
-            /*
+                stack.push();
-             * Renders it along with health.
+                stack.translate(0F,
-             */
+                        getHealthTranslation(),
-            RenderSystem.color4f(1.0F,
+                        0F);
-                    1.0F,
+                setAlpha(Main.getAlpha(mountTime,
-                    1.0F,
+                        healthTimes.getMaxTime(),
-                    Main.getAlpha(mountTime));
+                        healthTimes.getFadeInTime(),
+                        healthTimes.getFadeOutTime()));
                 return false;
             }
             return true;
         }
+        stack.push();
+        stack.translate(0F,
+                getHealthTranslation(),
+                0F);
+        return false;
+    }
+
+    /**
+     * Updates the timings of some of the potions currently affecting the
+     * player.
+     *
+     * @param player - The player being affected.
+     */
+    public static void updatePotions(ClientPlayerEntity player)
+    {
+        for (StatusEffect effect :
+                new HashSet<>(effectTime.keySet()))
+        {
+            if (!player.hasStatusEffect(effect))
+            {
+                effectTime.remove(effect);
+            }
+        }
+    }
+
+    /**
+     * Updates the timings of some of the potions currently affecting the
+     * player.
+     *
+     * @param effectinstance - The effect to update
+     * @param ticks
+     */
+    public static boolean updatePotion(StatusEffectInstance effectinstance,
+                                       float ticks)
+    {
+        final int BLINK_TIME = 200;
+
+        ConfigManager.TimeValues potion =
+                ConfigManager.getInstance().getPotionTime();
+
+        Double time = effectTime.get(effectinstance.getEffectType());
+        if (time == null)
+        {
+            effectTime.put(effectinstance.getEffectType(),
+                    (time = (double) potion.getMaxTime()));
+        }
+        else
+        {
+            effectTime.put(effectinstance.getEffectType(), (time -= ticks));
+        }
+        return Main.getAlpha(time,
+                potion.getMaxTime(),
+                potion.getFadeInTime(),
+                potion.getFadeOutTime()) > 0 || effectinstance.getDuration() <= BLINK_TIME;
+    }
+
+    /**
+     * Obtains how transparent
+     *
+     * @param effectinstance
+     * @return
+     */
+    public static float getPotionAlpha(StatusEffectInstance effectinstance)
+    {
+        ConfigManager.TimeValues potion =
+                ConfigManager.getInstance().getPotionTime();
+        final int BLINK_TIME = 200;
+        float effectAlpha = 0.0F;
+        if (effectinstance.getDuration() <= BLINK_TIME)
+        {
+            effectAlpha =
+                    MathHelper.sin(7000F / (effectinstance
+                            .getDuration() + 16F * (float) Math.PI)) * 50F / (effectinstance
+                            .getDuration() + 100F) + 0.5F;
+        }
+        else if (effectinstance.getDuration() <= BLINK_TIME + potion.getFadeInTime())
+        {
+            effectAlpha =
+                    -(effectinstance.getDuration() - BLINK_TIME) / 22F + 0.454F;
+        }
+        else
+        {
+            effectAlpha =
+                    Main.getAlpha(effectTime.getOrDefault(effectinstance.getEffectType(),
+                            0.0),
+                            potion.getMaxTime(),
+                            potion.getFadeInTime(),
+                            potion.getFadeOutTime());
+        }
+        return effectAlpha;
+    }
 
     /**
      * Determines whether or not to draw the armor bar, adjusting the alpha as
      * needed.
      *
      * @return If true, then cancel drawing the armor bar.
-     *
      * @since 0.1-1.16.4-fabric
      */
     public static boolean drawArmor()
     {
+        ConfigManager.TimeValues healthTimes;
         /*
          * Sets the armor to fade in and out in sync with the health.
          * Technically, since this method gets called before health, it will
          * be 1 tick behind, but I'm not too concerned about it.
          */
-        if (healthTime > 0)
+        if (ConfigManager.getInstance().shouldShowArmor() && healthTime > 0)
         {
-            RenderSystem.color4f(1.0F,
+            healthTimes = ConfigManager.getInstance().getHealthTime();
-                    1.0F,
+            setAlpha(Main.getAlpha(healthTime,
-                    1.0F,
+                    healthTimes.getMaxTime(),
-                    Main.getAlpha(healthTime));
+                    healthTimes.getFadeInTime(),
-        }
+                    healthTimes.getFadeOutTime()));
-        else
-        {
-            RenderSystem.color4f(1.0F,
-                    1.0F,
-                    1.0F,
-                    0.0F);
-        }
             return false;
         }
+        return true;
+    }
 
     /**
      * Determines whether or not to draw the health bar, adjusting the alpha as
      * needed.
      *
      * @return If true, then cancel drawing the health.
-     *
      * @since 0.1-1.16.4-fabric
      */
-    public static boolean drawHealth()
+    public static boolean drawHealth(float ticks)
     {
         /*
          * When the health percentage falls to this level or below, the
          * health bar won't disappear, allowing the player to be constantly
          * reminded of their low health.
          */
-        final float CONST_BOUNDARY = 0.5F;
+        final double HEALTH_BOUNDARY =
+                ConfigManager.getInstance().getMinHealth();
+        ConfigManager.TimeValues healthTimes =
+                ConfigManager.getInstance().getHealthTime();
 
         MinecraftClient mc = MinecraftClient.getInstance();
         LivingEntity entity;
@@ -479,14 +715,7 @@ public class EventBus
             return true;
         }
         boolean changed = false;
-
+        boolean canceled;
-        /*
-         * Resets the transparency from the armor call.
-         */
-        RenderSystem.color4f(1.0F,
-                1.0F,
-                1.0F,
-                1F);
 
         /**
          * Checks for a change in current or max health.
@@ -503,24 +732,32 @@ public class EventBus
         }
         if (changed)
         {
-            healthTime = HEALTH_TIME;
+            healthTime = healthTimes.getMaxTime() - (healthTime > 0 ?
+                    healthTimes.getFadeInTime() :
+                    0);
         }
         else if (healthTime > 0)
         {
-            healthTime--;
+            healthTime -= ticks;
         }
         /*
          * Only makes a change if the player is healthy. Otherwise,
          * the bar is shown.
          */
-        if (health / maxHealth > CONST_BOUNDARY)
+        if (health / maxHealth > HEALTH_BOUNDARY && !entity
+                .hasStatusEffect(StatusEffects.WITHER) && !entity.hasStatusEffect(
+                StatusEffects.POISON))
         {
-            RenderSystem.color4f(1.0F,
+            setAlpha(Main.getAlpha(healthTime,
-                    1.0F,
+                    healthTimes.getMaxTime(),
-                    1.0F,
+                    healthTimes.getFadeInTime(),
-                    Main.getAlpha(healthTime));
+                    healthTimes.getFadeOutTime()));
         }
-        return false;
+        canceled =
+                healthTime == 0 && health / maxHealth > HEALTH_BOUNDARY && !entity
+                        .hasStatusEffect(StatusEffects.WITHER) && !entity.hasStatusEffect(
+                        StatusEffects.POISON);
+        return canceled;
     }
 
     /**
@@ -528,29 +765,24 @@ public class EventBus
      * needed.
      *
      * @return If true, then cancel drawing the hunger bar.
-     *
      * @since 0.1-1.16.4-fabric
      */
-    public static boolean drawHunger()
+    public static boolean drawHunger(float ticks)
     {
         /*
          * When hunger falls to this level or below, the hunger bar won't
          * disappear, allowing the player to be constantly reminded of their
          * low hunger.
          */
-        final int HUNGER_BOUNDARY = 15;
+        final int HUNGER_BOUNDARY = ConfigManager.getInstance().getMinHunger();
+        ConfigManager.TimeValues hungerTimes =
+                ConfigManager.getInstance().getHungerTime();
 
         MinecraftClient mc = MinecraftClient.getInstance();
         PlayerEntity entity;
+        boolean canceled;
         boolean changed = false;
 
-        /*
-         * Resets the transparency from last time.
-         */
-        RenderSystem.color4f(1.0F,
-                1.0F,
-                1.0F,
-                1F);
         if (mc.getCameraEntity() instanceof PlayerEntity)
         {
             entity = (PlayerEntity) mc.getCameraEntity();
@@ -578,37 +810,49 @@ public class EventBus
         }
         if (changed)
         {
-            hungerTime = HEALTH_TIME;
+            hungerTime = hungerTimes.getMaxTime() - (hungerTime > 0 ?
+                    hungerTimes.getFadeInTime() :
+                    0);
         }
         else if (hungerTime > 0)
         {
-            hungerTime--;
+            hungerTime -= ticks;
+        }
+
+        if (hungerTime <= 0 && hunger > HUNGER_BOUNDARY)
+        {
+            return true;
         }
-        RenderSystem.color4f(1.0F,
-                1.0F,
-                1.0F,
-                Main.getAlpha(hungerTime));
         /*
-         * Only makes a change if the player is satisfied. Otherwise,
+         * Only makes a change if the player is healthy. Otherwise,
          * the bar is shown.
          */
-        return false;
+        if (hunger > HUNGER_BOUNDARY && !entity.hasStatusEffect(StatusEffects.HUNGER))
+        {
+            setAlpha(Main.getAlpha(hungerTime,
+                    hungerTimes.getMaxTime(),
+                    hungerTimes.getFadeInTime(),
+                    hungerTimes.getFadeOutTime()));
+        }
+        return hungerTime == 0 && hunger > HUNGER_BOUNDARY && !entity
+                .hasStatusEffect(StatusEffects.HUNGER);
     }
 
     /**
      * Determines whether or not to draw the horse jump bar, adjusting the alpha
      * as needed.
      *
+     * @param stack
      * @return If true, then cancel drawing the jump bar.
-     *
      * @since 0.1-1.16.4-fabric
      */
-    public static boolean drawJumpbar()
+    public static boolean drawJumpbar(MatrixStack stack, float ticks)
     {
+        ConfigManager.TimeValues jump =
+                ConfigManager.getInstance().getJumpTime();
+
         MinecraftClient mc = MinecraftClient.getInstance();
         ClientPlayerEntity entity;
-        boolean changed = false;
-
         if (mc.getCameraEntity() instanceof ClientPlayerEntity)
         {
             entity = (ClientPlayerEntity) mc.getCameraEntity();
@@ -620,18 +864,22 @@ public class EventBus
 
         if (entity.method_3151() > 0)
         {
-            jumpTime = VISUAL_TIME;
+            jumpTime = jump.getMaxTime() - (jumpTime > 0 ?
+                    jump.getFadeInTime() :
+                    0);
         }
         else if (jumpTime > 0)
         {
-            jumpTime--;
+            jumpTime -= ticks;
         }
-        if (experienceTime > 0)
+        if (jumpTime > 0)
         {
-            RenderSystem.color4f(1.0F,
+            stack.push();
-                    1.0F,
+            stack.translate(0F, TimerUtils.getJumpTranslation(), 0F);
-                    1.0F,
+            setAlpha(Main.getAlpha(jumpTime,
-                    Main.getAlpha(jumpTime));
+                    jump.getMaxTime(),
+                    jump.getFadeInTime(),
+                    jump.getFadeOutTime()));
             return false;
         }
         return true;
@@ -642,11 +890,13 @@ public class EventBus
      * as needed.
      *
      * @return If true, then cancel drawing the experience bar.
-     *
      * @since 0.1-1.16.4-fabric
      */
-    public static boolean drawExperience()
+    public static boolean drawExperience(MatrixStack stack, float ticks)
     {
+        ConfigManager.TimeValues experience =
+                ConfigManager.getInstance().getExperienceTime();
+
         MinecraftClient mc = MinecraftClient.getInstance();
         ClientPlayerEntity entity;
         boolean changed = false;
@@ -667,18 +917,22 @@ public class EventBus
         }
         if (changed)
         {
-            experienceTime = VISUAL_TIME;
+            experienceTime = experience.getMaxTime() - (experienceTime > 0 ?
+                    experience.getFadeInTime() :
+                    0);
         }
         else if (experienceTime > 0)
         {
-            experienceTime--;
+            experienceTime -= ticks;
         }
         if (experienceTime > 0)
         {
-            RenderSystem.color4f(1.0F,
+            stack.push();
-                    1.0F,
+            stack.translate(0F, TimerUtils.getExperienceTranslation(), 0F);
-                    1.0F,
+            setAlpha(Main.getAlpha(experienceTime,
-                    Main.getAlpha(experienceTime));
+                    experience.getMaxTime(),
+                    experience.getFadeInTime(),
+                    experience.getFadeOutTime()));
             return false;
         }
         return true;
@@ -690,12 +944,19 @@ public class EventBus
      * or not to draw it.
      *
      * @return If true, then cancel drawing the hotbar.
-     *
+     * @see #recolorHotbar(MatrixStack)
-     * @see #recolorHotbar()
      * @since 0.1-1.16.4-fabric
      */
-    public static boolean updateHotbar()
+    public static boolean updateHotbar(float ticks)
     {
+        ConfigManager.TimeValues health =
+                ConfigManager.getInstance().getHealthTime();
+        ConfigManager.TimeValues hunger =
+                ConfigManager.getInstance().getHungerTime();
+        ConfigManager.TimeValues hotbar =
+                ConfigManager.getInstance().getHotbarTime();
+        double handTime = ConfigManager.getInstance().getHandTime();
+
         MinecraftClient mc = MinecraftClient.getInstance();
         ClientPlayerEntity entity;
         Item item, handItem = null;
@@ -853,18 +1114,22 @@ public class EventBus
                  */
                 if (item.isFood())
                 {
-                    healthTime = HEALTH_TIME;
+                    healthTime = health.getMaxTime() - (healthTime > 0 ?
-                    hungerTime = HEALTH_TIME;
+                            health.getFadeInTime() :
+                            0);
+                    hungerTime = hunger.getMaxTime() - (hungerTime > 0 ?
+                            hunger.getFadeInTime() :
+                            0);
                 }
                 if (i == 0)
                 {
                     mainHandItem = item;
-                    mainHandTime = HAND_TIME;
+                    mainHandTime = handTime;
                 }
                 else if (i == 1)
                 {
                     offHandItem = item;
-                    offHandTime = HAND_TIME;
+                    offHandTime = handTime;
                 }
             }
             i++;
@@ -876,17 +1141,19 @@ public class EventBus
         if (selectedHotbarSlot != entity.inventory.selectedSlot)
         {
             selectedHotbarSlot = entity.inventory.selectedSlot;
-            mainHandTime = HAND_TIME;
+            mainHandTime = handTime;
             changed = true;
         }
 
         if (changed)
         {
-            hotbarTime = VISUAL_TIME;
+            hotbarTime = hotbar.getMaxTime() - (hotbarTime > 0 ?
+                    hotbar.getFadeInTime() :
+                    0);
         }
         else if (hotbarTime > 0)
         {
-            hotbarTime--;
+            hotbarTime -= ticks;
         }
 
         return hotbarTime == 0;
@@ -897,14 +1164,18 @@ public class EventBus
      * needed.
      *
      * @return If true, then cancel drawing the crosshair.
-     *
      * @since 0.1-1.16.4-fabric
      */
-    public static void recolorHotbar()
+    public static void recolorHotbar(MatrixStack stack)
     {
-        RenderSystem.color4f(1.0F,
+        ConfigManager.TimeValues hotbar =
-                1.0F,
+                ConfigManager.getInstance().getHotbarTime();
-                1.0F,
+        RenderSystem.pushMatrix();
-                Main.getAlpha(hotbarTime));
+        stack.push();
+        RenderSystem.translatef(0F, TimerUtils.getHotbarTranslation(), 0F);
+        setAlpha(Main.getAlpha(hotbarTime,
+                hotbar.getMaxTime(),
+                hotbar.getFadeInTime(),
+                hotbar.getFadeOutTime()));
     }
 }

src/main/java/markil3/immersive_hud/mixin/ClientPlayerHook.java

@@ -17,25 +17,22 @@
 package markil3.immersive_hud.mixin;
 
 import net.minecraft.client.MinecraftClient;
-import net.minecraft.client.network.AbstractClientPlayerEntity;
 import net.minecraft.client.network.ClientPlayerEntity;
-import net.minecraft.client.render.VertexConsumerProvider;
-import net.minecraft.client.render.item.HeldItemRenderer;
-import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.entity.LivingEntity;
-import net.minecraft.item.ItemStack;
 import net.minecraft.util.Hand;
 
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
-import markil3.immersive_hud.EventBus;
+import markil3.immersive_hud.TimerUtils;
 
 /**
  * This mixin hooks into the client player class to check for when the hands
- * move. Note that most of the logic can be found in {@link EventBus}.
+ * move. Note that most of the logic can be found in {@link TimerUtils}.
  *
  * @author Markil 3
  * @version 0.1-1.16.4-fabric
@@ -43,6 +40,9 @@ import markil3.immersive_hud.EventBus;
 @Mixin(ClientPlayerEntity.class)
 public class ClientPlayerHook
 {
+    private static final Logger LOGGER =
+            LogManager.getLogger(ClientPlayerHook.class);
+
     /**
      * Updates hand timing every time an attack is initiated.
      *
@@ -54,7 +54,18 @@ public class ClientPlayerHook
     @Inject(method = "swingHand", at = @At(value = "TAIL"))
     public void swingHand(Hand hand, CallbackInfo callbackInfo)
     {
-        EventBus.onClick(hand, hand == null);
+        try
+        {
+            TimerUtils.onClick(hand, hand == null);
+        }
+        catch (Exception e)
+        {
+            LOGGER.error(
+                    "Error in running net.minecraft.client.network" +
+                            ".ClientPlayerEntity#swingHand " +
+                            "event",
+                    e);
+        }
     }
 
     /**
@@ -68,7 +79,18 @@ public class ClientPlayerHook
     @Inject(method = "setCurrentHand", at = @At(value = "TAIL"))
     public void setCurrentHand(Hand hand, CallbackInfo callbackInfo)
     {
-        EventBus.onClick(hand, hand == null);
+        try
+        {
+            TimerUtils.onClick(hand, hand == null);
+        }
+        catch (Exception e)
+        {
+            LOGGER.error(
+                    "Error in running net.minecraft.client.network" +
+                            ".ClientPlayerEntity#setCurrentHand " +
+                            "event",
+                    e);
+        }
     }
 
     /**
@@ -80,11 +102,22 @@ public class ClientPlayerHook
      */
     @Inject(method = "clearActiveItem", at = @At(value = "HEAD"))
     public void clearActiveItem(CallbackInfo callbackInfo)
+    {
+        try
         {
             if (MinecraftClient.getInstance().cameraEntity instanceof LivingEntity)
             {
-            EventBus.onClick(((LivingEntity) MinecraftClient.getInstance().cameraEntity)
+                TimerUtils.onClick(((LivingEntity) MinecraftClient.getInstance().cameraEntity)
                         .getActiveHand(), true);
             }
         }
+        catch (Exception e)
+        {
+            LOGGER.error(
+                    "Error in running net.minecraft.client.network" +
+                            ".ClientPlayerEntity#clearActiveItem " +
+                            "event",
+                    e);
+        }
+    }
 }

src/main/java/markil3/immersive_hud/mixin/HeldItemHook.java

@@ -16,9 +16,6 @@
  */
 package markil3.immersive_hud.mixin;
 
-import com.mojang.blaze3d.systems.RenderSystem;
-
-import net.minecraft.client.gui.hud.InGameHud;
 import net.minecraft.client.network.AbstractClientPlayerEntity;
 import net.minecraft.client.render.VertexConsumerProvider;
 import net.minecraft.client.render.item.HeldItemRenderer;
@@ -26,16 +23,18 @@ import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.item.ItemStack;
 import net.minecraft.util.Hand;
 
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
-import markil3.immersive_hud.EventBus;
+import markil3.immersive_hud.TimerUtils;
 
 /**
  * This mixin hooks into the hand renderer to make the hands move in and out of
- * view. Note that most of the logic can be found in {@link EventBus}.
+ * view. Note that most of the logic can be found in {@link TimerUtils}.
  *
  * @author Markil 3
  * @version 0.1-1.16.4-fabric
@@ -43,6 +42,9 @@ import markil3.immersive_hud.EventBus;
 @Mixin(HeldItemRenderer.class)
 public class HeldItemHook
 {
+    private static final Logger LOGGER =
+            LogManager.getLogger(HeldItemHook.class);
+
     /**
      * Determines whether or not to render a certain hand.
      *
@@ -75,10 +77,21 @@ public class HeldItemHook
                            int light,
                            CallbackInfo callbackInfo)
     {
-        if (EventBus.onRenderHand(hand, matrices))
+        try
+        {
+            if (TimerUtils.onRenderHand(hand, matrices, tickDelta))
             {
                 callbackInfo.cancel();
             }
         }
+        catch (Exception e)
+        {
+            LOGGER.error(
+                    "Error in running net.minecraft.client.render.item" +
+                            ".HeldItemRenderer#renderFirstPersonItem " +
+                            "event",
+                    e);
+        }
+    }
 
 }

src/main/java/markil3/immersive_hud/mixin/HudHook.java

@@ -18,20 +18,26 @@ package markil3.immersive_hud.mixin;
 
 import com.mojang.blaze3d.systems.RenderSystem;
 
+import net.minecraft.client.MinecraftClient;
 import net.minecraft.client.gui.hud.InGameHud;
+import net.minecraft.client.network.ClientPlayerEntity;
 import net.minecraft.client.util.math.MatrixStack;
-import net.minecraft.util.profiler.DummyProfiler;
+import net.minecraft.entity.effect.StatusEffectInstance;
 
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.ModifyVariable;
+import org.spongepowered.asm.mixin.injection.Redirect;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
-import markil3.immersive_hud.EventBus;
+import markil3.immersive_hud.TimerUtils;
 
 /**
  * This mixin hooks into the HUD class to modify most of the HUD elements. Note
- * that most of the logic can be found in {@link EventBus}.
+ * that most of the logic can be found in {@link TimerUtils}.
  *
  * @author Markil 3
  * @version 0.1-1.16.4-fabric
@@ -39,18 +45,39 @@ import markil3.immersive_hud.EventBus;
 @Mixin(InGameHud.class)
 public class HudHook
 {
+    private static final Logger LOGGER = LogManager.getLogger(HudHook.class);
+
+    private StatusEffectInstance currentEffect;
+
     /**
      * Determines whether or not to draw the crosshair.
      *
      * @param stack - The matrix drawing stack.
      * @param callbackInfo
      *
+     * @version 0.2-1.16.4-fabric
      * @since 0.1-1.16.4-fabric
      */
-    @Inject(method = "renderCrosshair", at = @At(value = "HEAD"))
+    @Inject(method = "renderCrosshair", at = @At(value = "HEAD"),
+            cancellable = true)
     public void startCrosshair(MatrixStack stack, CallbackInfo callbackInfo)
     {
-        EventBus.drawCrosshair();
+        try
+        {
+            if (TimerUtils.drawCrosshair(MinecraftClient.getInstance()
+                    .getTickDelta()))
+            {
+                callbackInfo.cancel();
+            }
+        }
+        catch (Exception e)
+        {
+            LOGGER.error(
+                    "Error in running net.minecraft.client.gui.hud" +
+                            ".InGameHud#startCrosshair " +
+                            "event",
+                    e);
+        }
     }
 
     /**
@@ -59,15 +86,27 @@ public class HudHook
      * @param stack - The matrix drawing stack.
      * @param callbackInfo
      *
+     * @version 0.2-1.16.4-fabric
      * @since 0.1-1.16.4-fabric
      */
     @Inject(method = "renderCrosshair", at = @At(value = "TAIL"))
     public void finishCrosshair(MatrixStack stack, CallbackInfo callbackInfo)
+    {
+        try
         {
             /*
              * Resets the color so that nothing else is bothered.
              */
-        RenderSystem.color4f(1, 1, 1, 1F);
+            TimerUtils.resetAlpha();
+        }
+        catch (Exception e)
+        {
+            LOGGER.error(
+                    "Error in running net.minecraft.client.gui.hud" +
+                            ".InGameHud#renderCrosshair " +
+                            "event",
+                    e);
+        }
     }
 
     /**
@@ -76,14 +115,31 @@ public class HudHook
      * @param stack - The matrix drawing stack.
      * @param callbackInfo
      *
+     * @version 0.2-1.16.4-fabric
      * @since 0.1-1.16.4-fabric
      */
-    @Inject(method = "renderMountJumpBar", at = @At(value = "HEAD"))
+    @Inject(method = "renderMountJumpBar", at = @At(value = "HEAD"),
+            cancellable = true)
     public void startJumpbar(MatrixStack stack,
                              int x,
                              CallbackInfo callbackInfo)
     {
-        EventBus.drawJumpbar();
+        try
+        {
+            if (TimerUtils.drawJumpbar(stack,
+                    MinecraftClient.getInstance().getTickDelta()))
+            {
+                callbackInfo.cancel();
+            }
+        }
+        catch (Exception e)
+        {
+            LOGGER.error(
+                    "Error in running net.minecraft.client.gui.hud" +
+                            ".InGameHud#renderMountJumpBar " +
+                            "event",
+                    e);
+        }
     }
 
     /**
@@ -92,6 +148,7 @@ public class HudHook
      * @param stack - The matrix drawing stack.
      * @param callbackInfo
      *
+     * @version 0.2-1.16.4-fabric
      * @since 0.1-1.16.4-fabric
      */
     @Inject(method = "renderMountJumpBar", at = @At(value = "TAIL"))
@@ -99,10 +156,22 @@ public class HudHook
                               int x,
                               CallbackInfo callbackInfo)
     {
+        try
+        {
+            stack.pop();
             /*
              * Resets the color so that nothing else is bothered.
              */
-        RenderSystem.color4f(1, 1, 1, 1F);
+            TimerUtils.resetAlpha();
+        }
+        catch (Exception e)
+        {
+            LOGGER.error(
+                    "Error in running net.minecraft.client.gui.hud" +
+                            ".InGameHud#renderMountJumpBar " +
+                            "event",
+                    e);
+        }
     }
 
     /**
@@ -111,6 +180,7 @@ public class HudHook
      * @param stack - The matrix drawing stack.
      * @param callbackInfo
      *
+     * @version 0.2-1.16.4-fabric
      * @since 0.1-1.16.4-fabric
      */
     @Inject(method = "renderExperienceBar", at = @At(value = "HEAD"),
@@ -119,11 +189,23 @@ public class HudHook
                                 int x,
                                 CallbackInfo callbackInfo)
     {
-        if (EventBus.drawExperience())
+        try
+        {
+            if (TimerUtils.drawExperience(stack,
+                    MinecraftClient.getInstance().getTickDelta()))
             {
                 callbackInfo.cancel();
             }
         }
+        catch (Exception e)
+        {
+            LOGGER.error(
+                    "Error in running net.minecraft.client.gui.hud" +
+                            ".InGameHud#renderExperienceBar " +
+                            "event",
+                    e);
+        }
+    }
 
     /**
      * Resets any changes from drawing the experience bar.
@@ -131,6 +213,7 @@ public class HudHook
      * @param stack - The matrix drawing stack.
      * @param callbackInfo
      *
+     * @version 0.2-1.16.4-fabric
      * @since 0.1-1.16.4-fabric
      */
     @Inject(method = "renderExperienceBar", at = @At(value = "TAIL"))
@@ -138,10 +221,194 @@ public class HudHook
                                  int x,
                                  CallbackInfo callbackInfo)
     {
+        try
+        {
+            stack.pop();
             /*
              * Resets the color so that nothing else is bothered.
              */
-        RenderSystem.color4f(1, 1, 1, 1F);
+            TimerUtils.resetAlpha();
+        }
+        catch (Exception e)
+        {
+            LOGGER.error(
+                    "Error in running net.minecraft.client.gui.hud" +
+                            ".InGameHud#renderExperienceBar " +
+                            "event",
+                    e);
+        }
+    }
+
+    /**
+     * Changes the position of the status bars as the ones below them move up
+     * and down.
+     *
+     * @param stack - The matrix stack used.
+     *
+     * @return The same matrix stack, with a new matrix pushed onto it.
+     */
+    @ModifyVariable(method = "renderStatusBars(Lnet/minecraft/client/util" +
+            "/math/MatrixStack;)V", at = @At("HEAD"))
+    public MatrixStack startStatus(MatrixStack stack)
+    {
+        try
+        {
+            stack.push();
+            stack.translate(0F, TimerUtils.getHealthTranslation(), 0F);
+        }
+        catch (Exception e)
+        {
+            LOGGER.error(
+                    "Error in running net.minecraft.client.gui.hud" +
+                            ".InGameHud#renderStatusBars " +
+                            "event",
+                    e);
+        }
+        return stack;
+    }
+
+    /**
+     * Adjusts the armor GUI.
+     *
+     * @param matrices
+     * @param callbackInfo
+     */
+    @Inject(method = "renderStatusBars(Lnet/minecraft/client/util" +
+            "/math/MatrixStack;)V", at = @At(value = "INVOKE", target = "Lnet" +
+            "/minecraft/util/profiler/Profiler;push(Ljava/lang/String;)V"))
+    public void renderArmor(MatrixStack matrices, CallbackInfo callbackInfo)
+    {
+        try
+        {
+            if (TimerUtils.drawArmor())
+            {
+                TimerUtils.setAlpha(0F);
+            }
+        }
+        catch (Exception e)
+        {
+            LOGGER.error(
+                    "Error in running net.minecraft.client.gui.hud" +
+                            ".InGameHud#renderStatusBars " +
+                            "event",
+                    e);
+        }
+    }
+
+    /**
+     * Adjusts the health GUI.
+     *
+     * @param matrices
+     * @param callbackInfo
+     */
+    @Inject(method = "renderStatusBars(Lnet/minecraft/client/util" +
+            "/math/MatrixStack;)V", at = @At(value = "INVOKE", target = "Lnet" +
+            "/minecraft/util/profiler/Profiler;swap(Ljava/lang/String;)V",
+            ordinal = 0))
+    public void renderHealth(MatrixStack matrices, CallbackInfo callbackInfo)
+    {
+        try
+        {
+            /*
+             * Resets the transparency from the previous call.
+             */
+            TimerUtils.setAlpha(1F);
+            if (TimerUtils.drawHealth(MinecraftClient.getInstance()
+                    .getTickDelta()))
+            {
+                TimerUtils.setAlpha(0F);
+            }
+        }
+        catch (Exception e)
+        {
+            LOGGER.error(
+                    "Error in running net.minecraft.client.gui.hud" +
+                            ".InGameHud#renderStatusBars " +
+                            "event",
+                    e);
+        }
+    }
+
+    /**
+     * Adjusts the food GUI.
+     *
+     * @param matrices
+     * @param callbackInfo
+     */
+    @Inject(method = "renderStatusBars(Lnet/minecraft/client/util" +
+            "/math/MatrixStack;)V", at = @At(value = "INVOKE", target = "Lnet" +
+            "/minecraft/util/profiler/Profiler;swap(Ljava/lang/String;)V",
+            ordinal = 1, shift = At.Shift.BY, by = 3))
+    public void renderFood(MatrixStack matrices, CallbackInfo callbackInfo)
+    {
+        try
+        {
+            /*
+             * Resets the transparency from the previous call.
+             */
+            TimerUtils.setAlpha(1F);
+            if (TimerUtils.drawHunger(MinecraftClient.getInstance()
+                    .getTickDelta()))
+            {
+                TimerUtils.setAlpha(0F);
+            }
+        }
+        catch (Exception e)
+        {
+            LOGGER.error(
+                    "Error in running net.minecraft.client.gui.hud" +
+                            ".InGameHud#renderStatusBars " +
+                            "event",
+                    e);
+        }
+    }
+
+    /**
+     * Resets the air GUI.
+     *
+     * @param matrices
+     * @param callbackInfo
+     */
+    @Inject(method = "renderStatusBars(Lnet/minecraft/client/util" +
+            "/math/MatrixStack;)V", at = @At(value = "INVOKE", target = "Lnet" +
+            "/minecraft/util/profiler/Profiler;swap(Ljava/lang/String;)V",
+            ordinal = 2))
+    public void renderAir(MatrixStack matrices, CallbackInfo callbackInfo)
+    {
+        try
+        {
+            /*
+             * Resets the color so that nothing else is bothered.
+             */
+            TimerUtils.setAlpha(1F);
+        }
+        catch (Exception e)
+        {
+            LOGGER.error(
+                    "Error in running net.minecraft.client.gui.hud" +
+                            ".InGameHud#renderStatusBars " +
+                            "event",
+                    e);
+        }
+    }
+
+    @ModifyVariable(method = "renderStatusBars(Lnet/minecraft/client/util" +
+            "/math/MatrixStack;)V", at = @At("TAIL"))
+    public MatrixStack finishStatus(MatrixStack stack)
+    {
+        try
+        {
+            stack.pop();
+        }
+        catch (Exception e)
+        {
+            LOGGER.error(
+                    "Error in running net.minecraft.client.gui.hud" +
+                            ".InGameHud#renderStatusBars " +
+                            "event",
+                    e);
+        }
+        return stack;
     }
 
     /**
@@ -150,12 +417,29 @@ public class HudHook
      * @param stack - The matrix drawing stack.
      * @param callbackInfo
      *
+     * @version 0.2-1.16.4-fabric
      * @since 0.1-1.16.4-fabric
      */
-    @Inject(method = "renderMountHealth", at = @At(value = "HEAD"))
+    @Inject(method = "renderMountHealth", at = @At(value = "HEAD"),
+            cancellable = true)
     public void startMountHealth(MatrixStack stack, CallbackInfo callbackInfo)
     {
-        EventBus.drawMountHealth();
+        try
+        {
+            if (TimerUtils.drawMountHealth(stack,
+                    MinecraftClient.getInstance().getTickDelta()))
+            {
+                callbackInfo.cancel();
+            }
+        }
+        catch (Exception e)
+        {
+            LOGGER.error(
+                    "Error in running net.minecraft.client.gui.hud" +
+                            ".InGameHud#renderMountHealth " +
+                            "event",
+                    e);
+        }
     }
 
     /**
@@ -164,15 +448,146 @@ public class HudHook
      * @param stack - The matrix drawing stack.
      * @param callbackInfo
      *
+     * @version 0.2-1.16.4-fabric
      * @since 0.1-1.16.4-fabric
      */
     @Inject(method = "renderMountHealth", at = @At(value = "TAIL"))
     public void finishMountHealth(MatrixStack stack, CallbackInfo callbackInfo)
+    {
+        try
         {
             /*
              * Resets the color so that nothing else is bothered.
              */
-        RenderSystem.color4f(1, 1, 1, 1F);
+            stack.pop();
+            TimerUtils.resetAlpha();
+        }
+        catch (Exception e)
+        {
+            LOGGER.error(
+                    "Error in running net.minecraft.client.gui.hud" +
+                            ".InGameHud#renderMountHealth " +
+                            "event",
+                    e);
+        }
+    }
+
+    /**
+     * Makes the actual adjustment to the hotbar as needed.
+     *
+     * @version 0.2-1.16.4-fabric
+     * @since 0.1-1.16.4-fabric
+     */
+    @Inject(method = "renderStatusEffectOverlay" +
+            "(Lnet/minecraft/client/util/math/MatrixStack;)V", at =
+    @At(value = "HEAD", shift = At.Shift.AFTER))
+    public void startPotion(MatrixStack effect, CallbackInfo info)
+    {
+        try
+        {
+            TimerUtils.updatePotions(MinecraftClient.getInstance().cameraEntity instanceof ClientPlayerEntity ?
+                                     ((ClientPlayerEntity) MinecraftClient.getInstance().cameraEntity) :
+                                     null);
+        }
+        catch (Exception e)
+        {
+            LOGGER.error(
+                    "Error in running net.minecraft.client.gui.hud" +
+                            ".InGameHud#renderStatusEffectOverlay " +
+                            "event",
+                    e);
+        }
+    }
+
+    /**
+     * Makes the actual adjustment to the hotbar as needed.
+     *
+     * @version 0.2-1.16.4-fabric
+     * @since 0.1-1.16.4-fabric
+     */
+    @Redirect(method = "renderStatusEffectOverlay" +
+            "(Lnet/minecraft/client/util/math/MatrixStack;)V", at =
+    @At(value = "INVOKE",
+            target =
+                    "Lnet/minecraft/entity/effect/StatusEffectInstance;" +
+                            "shouldShowIcon()Z"))
+    public boolean shouldRenderPotion(StatusEffectInstance effect)
+    {
+        try
+        {
+            currentEffect = effect;
+            return TimerUtils.updatePotion(effect,
+                    MinecraftClient.getInstance().getTickDelta());
+        }
+        catch (Exception e)
+        {
+            LOGGER.error(
+                    "Error in running net.minecraft.client.gui.hud" +
+                            ".InGameHud#renderStatusEffectOverlay " +
+                            "event",
+                    e);
+        }
+        return true;
+    }
+
+    /**
+     * Makes the actual adjustment to the hotbar as needed.
+     *
+     * @param f - The original transparency
+     * @param stack - The matrix stack
+     *
+     * @version 0.2-1.16.4-fabric
+     * @since 0.1-1.16.4-fabric
+     */
+    @ModifyVariable(method = "renderStatusEffectOverlay" +
+            "(Lnet/minecraft/client/util/math/MatrixStack;)V", at =
+    @At(value = "STORE"))
+    public float updatePotion(float f,
+                              MatrixStack stack)
+    {
+        try
+        {
+            return TimerUtils.getPotionAlpha(currentEffect);
+        }
+        catch (Exception e)
+        {
+            LOGGER.error(
+                    "Error in running net.minecraft.client.gui.hud" +
+                            ".InGameHud#renderStatusEffectOverlay " +
+                            "event",
+                    e);
+        }
+        return 1F;
+    }
+
+    /**
+     * Resets any changes from drawing the potion effects.
+     *
+     * @param matrices - The matrix drawing stack.
+     * @param callbackInfo
+     *
+     * @version 0.2-1.16.4-fabric
+     * @since 0.2-1.16.4-fabric
+     */
+    @Inject(method = "renderStatusEffectOverlay", at = @At(value = "TAIL"))
+    public void finishPotion(MatrixStack matrices,
+                             CallbackInfo callbackInfo)
+    {
+        try
+        {
+            /*
+             * Resets the color so that nothing else is bothered.
+             */
+            TimerUtils.resetAlpha();
+        }
+        catch (Exception e)
+        {
+            LOGGER.error(
+                    "Error in running net.minecraft.client.gui.hud" +
+                            ".InGameHud#renderStatusEffectOverlay " +
+                            "event",
+                    e);
+        }
     }
 
     /**
@@ -182,6 +597,7 @@ public class HudHook
      * @param matrices - The matrix drawing stack.
      * @param callbackInfo
      *
+     * @version 0.2-1.16.4-fabric
      * @since 0.1-1.16.4-fabric
      */
     @Inject(method = "renderHotbar", at = @At(value = "HEAD"), cancellable =
@@ -190,11 +606,22 @@ public class HudHook
                             MatrixStack matrices,
                             CallbackInfo callbackInfo)
     {
-        if (EventBus.updateHotbar())
+        try
+        {
+            if (TimerUtils.updateHotbar(tickDelta))
             {
                 callbackInfo.cancel();
             }
         }
+        catch (Exception e)
+        {
+            LOGGER.error(
+                    "Error in running net.minecraft.client.gui.hud" +
+                            ".InGameHud#renderHotbar " +
+                            "event",
+                    e);
+        }
+    }
 
     /**
      * Makes the actual adjustment to the hotbar as needed.
@@ -203,6 +630,7 @@ public class HudHook
      * @param matrices - The matrix drawing stack.
      * @param callbackInfo
      *
+     * @version 0.2-1.16.4-fabric
      * @since 0.1-1.16.4-fabric
      */
     @Inject(method = "renderHotbar", at = @At(value = "INVOKE", target =
@@ -212,26 +640,51 @@ public class HudHook
                              MatrixStack matrices,
                              CallbackInfo callbackInfo)
     {
-        EventBus.recolorHotbar();
+        try
+        {
+            TimerUtils.recolorHotbar(matrices);
+        }
+        catch (Exception e)
+        {
+            LOGGER.error(
+                    "Error in running net.minecraft.client.gui.hud" +
+                            ".InGameHud#renderHotbar " +
+                            "event",
+                    e);
+        }
     }
 
     /**
      * Resets any changes from drawing the hotbar.
      *
      * @param tickDelta
-     * @param matrices - The matrix drawing stack.
+     * @param stack - The matrix drawing stack.
      * @param callbackInfo
      *
+     * @version 0.2-1.16.4-fabric
      * @since 0.1-1.16.4-fabric
      */
     @Inject(method = "renderHotbar", at = @At(value = "TAIL"))
     public void finishHotbar(float tickDelta,
-                             MatrixStack matrices,
+                             MatrixStack stack,
                              CallbackInfo callbackInfo)
     {
+        try
+        {
+            RenderSystem.popMatrix();
+            stack.pop();
             /*
              * Resets the color so that nothing else is bothered.
              */
-        RenderSystem.color4f(1, 1, 1, 1F);
+            TimerUtils.resetAlpha();
+        }
+        catch (Exception e)
+        {
+            LOGGER.error(
+                    "Error in running net.minecraft.client.gui.hud" +
+                            ".InGameHud#renderHotbar " +
+                            "event",
+                    e);
+        }
     }
 }

src/main/java/markil3/immersive_hud/mixin/ProfilerHook.java

@@ -1,85 +0,0 @@
-/**
- * Copyright (C) 2021 Markil 3
- * <p>
- * This program is free software: you can redistribute it and/or modify it under
- * the terms of the GNU General Public License as published by the Free Software
- * Foundation, either version 3 of the License, or (at your option) any later
- * version.
- * <p>
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
- * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
- * details.
- * <p>
- * You should have received a copy of the GNU General Public License along with
- * this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-package markil3.immersive_hud.mixin;
-
-import com.mojang.blaze3d.systems.RenderSystem;
-
-import net.minecraft.util.profiler.DummyProfiler;
-
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
-
-import markil3.immersive_hud.EventBus;
-
-/**
- * This class hooks into the profiler to trigger color changes for the status
- * indicators.
- *
- * @author Markil 3
- * @version 0.1-1.16.4-fabric
- */
-@Mixin(DummyProfiler.class)
-public class ProfilerHook
-{
-    /**
-     * Hooks into the profiler to add logic to drawing armor.
-     *
-     * @param section - The profiler section
-     * @param callbackInfo
-     *
-     * @since 0.1-1.16.4-fabric
-     */
-    @Inject(method = "push", at = @At(value = "TAIL"))
-    public void renderArmor(String section, CallbackInfo callbackInfo)
-    {
-        if (section.equals("armor"))
-        {
-            EventBus.drawArmor();
-        }
-    }
-
-    /**
-     * Hooks into the profiler to add logic to drawing status bars besides
-     * armor.
-     *
-     * @param section - The profiler section
-     * @param callbackInfo
-     *
-     * @since 0.1-1.16.4-fabric
-     */
-    @Inject(method = "swap", at = @At(value = "TAIL"))
-    public void renderStatus(String section, CallbackInfo callbackInfo)
-    {
-        switch (section)
-        {
-        case "health":
-            EventBus.drawHealth();
-            break;
-        case "food":
-            EventBus.drawHunger();
-            break;
-        case "air":
-            /*
-             * Resets the color so that nothing else is bothered.
-             */
-            RenderSystem.color4f(1, 1, 1, 1F);
-            break;
-        }
-    }
-}

src/main/resources/assets/immersive_hud/lang/en_us.json

@@ -0,0 +1,57 @@
+{
+  "immersive_hud.configGui.title": "Immersive HUD Configuration",
+  "option.immersive_hud.hotbarMaxTime": "Hotbar Display Time",
+  "option.immersive_hud.hotbarFadeIn": "Hotbar Fade In Time",
+  "option.immersive_hud.hotbarFadeOut": "Hotbar Fade Out Time",
+  "option.immersive_hud.experienceMaxTime": "Experience Display Time",
+  "option.immersive_hud.experienceFadeIn": "Experience Fade In Time",
+  "option.immersive_hud.experienceFadeOut": "Experience Fade Out Time",
+  "option.immersive_hud.jumpMaxTime": "Jump Bar Display Time",
+  "option.immersive_hud.jumpFadeIn": "Jump Bar Fade In Time",
+  "option.immersive_hud.jumpFadeOut": "Jump Bar Fade Out Time",
+  "option.immersive_hud.healthMaxTime": "Health Bar Display Time",
+  "option.immersive_hud.healthFadeIn": "Health Bar Fade In Time",
+  "option.immersive_hud.healthFadeOut": "Health Bar Fade Out Time",
+  "option.immersive_hud.hungerMaxTime": "Hunger Bar Display Time",
+  "option.immersive_hud.hungerFadeIn": "Hunger Bar Fade In Time",
+  "option.immersive_hud.hungerFadeOut": "Hunger Bar Fade Out Time",
+  "option.immersive_hud.effectMaxTime": "Potion Display Time",
+  "option.immersive_hud.effectFadeIn": "Potion Fade In Time",
+  "option.immersive_hud.effectFadeOut": "Potion Fade Out Time",
+  "option.immersive_hud.crosshairTime": "Crosshair Display Time",
+  "option.immersive_hud.hideCrosshair": "Hide Crosshair",
+  "option.immersive_hud.handTime": "Hand Display Time",
+  "option.immersive_hud.hideHands": "Hide Hands",
+  "option.immersive_hud.minHealth": "Minimum Health Fade",
+  "option.immersive_hud.minHunger": "Minimum Hunger Fade",
+  "option.immersive_hud.showArmor": "Show Armor",
+  "option.immersive_hud.ignoreList": "Ignored Items",
+  "tooltip.immersive_hud.hotbarMaxTime": "How long the hotbar can be displayed on screen in seconds",
+  "tooltip.immersive_hud.hotbarFadeIn": "How many seconds it takes for the hotbar to fade in",
+  "tooltip.immersive_hud.hotbarFadeOut": "How many seconds it takes for the hotbar to move out",
+  "tooltip.immersive_hud.experienceMaxTime": "How long the experience bar can be displayed on screen in seconds",
+  "tooltip.immersive_hud.experienceFadeIn": "How many seconds it takes for the experience bar to fade in",
+  "tooltip.immersive_hud.experienceFadeOut": "How many seconds it takes for the experience bar to move out",
+  "tooltip.immersive_hud.jumpMaxTime": "How long the horse jump bar can be displayed on screen in seconds",
+  "tooltip.immersive_hud.jumpFadeIn": "How many seconds it takes for the horse jump bar to fade in",
+  "tooltip.immersive_hud.jumpFadeOut": "How many seconds it takes for the horse jump bar to fade out",
+  "tooltip.immersive_hud.healthMaxTime": "How long the health bar can be displayed on screen in seconds",
+  "tooltip.immersive_hud.healthFadeIn": "How many seconds it takes for the health bar to fade in",
+  "tooltip.immersive_hud.healthFadeOut": "How many seconds it takes for the health bar to fade out",
+  "tooltip.immersive_hud.hungerMaxTime": "How long the hunger bar can be displayed on screen in seconds",
+  "tooltip.immersive_hud.hungerFadeIn": "How many seconds it takes for the hunger bar to fade in",
+  "tooltip.immersive_hud.hungerFadeOut": "How many seconds it takes for the hunger bar to fade out",
+  "tooltip.immersive_hud.effectMaxTime": "How long potion icons can be displayed on screen in seconds",
+  "tooltip.immersive_hud.effectFadeIn": "How many seconds it takes for potion icons to fade in",
+  "tooltip.immersive_hud.effectFadeOut": "How many seconds it takes for potion icons to fade out",
+  "tooltip.immersive_hud.crosshairTime": "How many seconds the crosshairs can be on screen",
+  "tooltip.immersive_hud.hideCrosshair": "Whether or not the crosshairs should be hidden after a period of time",
+  "tooltip.immersive_hud.handTime": "How many seconds the hands can be on screen",
+  "tooltip.immersive_hud.hideHands": "Whether or not hands should be hidden after a period of time",
+  "tooltip.immersive_hud.minHealth": "When the percentage of health goes below this level, the health bar won't fade away",
+  "tooltip.immersive_hud.minHunger": "When the hunger level goes below this level, the hunger bar won't fade away",
+  "tooltip.immersive_hud.showArmor": "Whether or not the armor bar should display on the HUD",
+  "tooltip.immersive_hud.ignoreList": "Which items will not trigger the arm and crosshairs when used",
+  "error.immersive_hud.ignoreList.unknownItem": "Unknown item %s",
+  "error.immersive_hud.ignoreList.illegalId": "%s is not a legal item identifier"
+}

src/main/resources/fabric.mod.json

@@ -9,8 +9,9 @@
     "Markil 3"
   ],
   "contact": {
-    "homepage": "https://fabricmc.net/",
+    "homepage": "https://www.planetminecraft.com/mod/immersive-hud/",
-    "sources": "https://github.com/FabricMC/fabric-example-mod"
+    "sources": "https://github.com/Markil3/MinecraftImmersiveHUD",
+    "issues": "https://github.com/Markil3/MinecraftImmersiveHUD/issues"
   },
 
   "license": "GPL-3.0-only",
@@ -20,18 +21,24 @@
   "entrypoints": {
     "main": [
       "markil3.immersive_hud.Main"
+    ],
+    "modmenu": [
+      "markil3.immersive_hud.ModMenu"
     ]
   },
   "mixins": [
     {
-      "config": "modid.mixins.json",
+      "config": "immersive_hud.mixins.json",
       "environment": "client"
     }
   ],
 
   "depends": {
     "fabricloader": ">=0.7.4",
-    "fabric": "*",
     "minecraft": "1.16.x"
+  },
+  "suggests": {
+    "modmenu": "*",
+    "cloth-config2": "*"
   }
 }

src/main/resources/immersive_hud.mixins.json

@@ -8,8 +8,7 @@
   "client": [
     "ClientPlayerHook",
     "HeldItemHook",
-    "HudHook",
+    "HudHook"
-    "ProfilerHook"
   ],
   "injectors": {
     "defaultRequire": 1