committed

or something

38 files changed, 3780 insertions, 0 deletions

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..36367f5
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,29 @@
+# eclipse
+eclipse
+bin
+*.launch
+.settings
+.metadata
+.classpath
+.project
+
+# idea
+out
+classes
+*.ipr
+*.iws
+*.iml
+.idea
+
+# gradle
+build
+.gradle
+
+#Netbeans
+.nb-gradle
+.nb-gradle-properties
+
+# other
+run
+.DS_Store
+Thumbs.db
\ No newline at end of file
diff --git a/build.gradle b/build.gradle
new file mode 100644
index 0000000..dceb049
--- /dev/null
+++ b/build.gradle
@@ -0,0 +1,94 @@
+plugins {
+    id "net.minecraftforge.gradle.forge" version "6f53277"
+    id "com.github.johnrengelman.shadow" version "6.1.0"
+    id "org.spongepowered.mixin" version "0.6-SNAPSHOT"
+}
+
+version = "2.0.1"
+group = "rosegoldaddons"
+archivesBaseName = "RoseGoldAddons"
+
+sourceCompatibility = targetCompatibility = 1.8
+compileJava.options.encoding = 'UTF-8'
+
+minecraft {
+    version = "1.8.9-11.15.1.2318-1.8.9"
+    runDir = "run"
+    mappings = "stable_22"
+    makeObfSourceJar = false
+    clientRunArgs += ["--tweakClass gg.essential.loader.stage0.EssentialSetupTweaker", "--mixin mixins.rosegoldaddons.json"]
+}
+
+repositories {
+    mavenCentral()
+    maven { url "https://jitpack.io" }
+    maven { url "https://repo.spongepowered.org/repository/maven-public/" }
+    maven { url "https://repo.sk1er.club/repository/maven-public" }
+    maven { url "https://repo.sk1er.club/repository/maven-releases/" }
+}
+
+configurations {
+    packageLib
+    configurations.implementation.extendsFrom(configurations.packageLib)
+}
+
+
+dependencies {
+    annotationProcessor("org.spongepowered:mixin:0.7.11-SNAPSHOT")
+    implementation("org.spongepowered:mixin:0.7.11-SNAPSHOT")
+    packageLib("gg.essential:loader-launchwrapper:1.1.1")
+    implementation("gg.essential:essential-1.8.9-forge:1498")
+}
+
+mixin {
+    disableRefMapWarning = true
+    defaultObfuscationEnv searge
+    add sourceSets.main, "mixins.rosegoldaddons.refmap.json"
+}
+
+jar {
+
+    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+
+    manifest.attributes(
+            "FMLCorePluginContainsFMLMod": true,
+            "FMLCorePlugin": "rosegoldaddons.FMLLoadingPlugin",
+            "ForceLoadAsMod": true,
+            "MixinConfigs": "mixins.rosegoldaddons.json",
+            "ModSide": "CLIENT",
+            "TweakClass": "gg.essential.loader.stage0.EssentialSetupTweaker",
+            "TweakOrder": "0"
+    )
+
+    enabled = false
+}
+
+shadowJar {
+    archiveFileName = jar.archiveFileName
+    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+    configurations = [project.configurations.packageLib]
+}
+
+reobf {
+    shadowJar {
+        classpath = sourceSets.main.compileClasspath
+    }
+}
+
+processResources {
+    inputs.property "version", project.version
+    inputs.property "mcversion", project.minecraft.version
+    from(sourceSets.main.resources.srcDirs) {
+        include 'mcmod.info'
+        expand 'version':project.version, 'mcversion':project.minecraft.version
+    }
+    from(sourceSets.main.resources.srcDirs) {
+        exclude 'mcmod.info'
+    }
+}
+
+sourceSets {
+    main { output.resourcesDir = java.outputDir }
+}
+
+tasks.reobfJar.dependsOn(shadowJar)
diff --git a/gradle.properties b/gradle.properties
new file mode 100644
index 0000000..bf86fb7
--- /dev/null
+++ b/gradle.properties
@@ -0,0 +1 @@
+org.gradle.jvmargs=-Xmx2G
\ No newline at end of file
diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar
new file mode 100644
index 0000000..e708b1c
--- /dev/null
+++ b/gradle/wrapper/gradle-wrapper.jar
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
new file mode 100644
index 0000000..8cf6eb5
--- /dev/null
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -0,0 +1,5 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.8.3-all.zip
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
diff --git a/gradlew b/gradlew
new file mode 100644
index 0000000..4f906e0
--- /dev/null
+++ b/gradlew
@@ -0,0 +1,185 @@
+#!/usr/bin/env sh
+
+#
+# Copyright 2015 the original author or authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+##############################################################################
+##
+##  Gradle start up script for UN*X
+##
+##############################################################################
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn () {
+    echo "$*"
+}
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+  NONSTOP* )
+    nonstop=true
+    ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+        JAVACMD="$JAVA_HOME/bin/java"
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD="java"
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
+    MAX_FD_LIMIT=`ulimit -H -n`
+    if [ $? -eq 0 ] ; then
+        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+            MAX_FD="$MAX_FD_LIMIT"
+        fi
+        ulimit -n $MAX_FD
+        if [ $? -ne 0 ] ; then
+            warn "Could not set maximum file descriptor limit: $MAX_FD"
+        fi
+    else
+        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+    fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
+    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+
+    JAVACMD=`cygpath --unix "$JAVACMD"`
+
+    # We build the pattern for arguments to be converted via cygpath
+    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+    SEP=""
+    for dir in $ROOTDIRSRAW ; do
+        ROOTDIRS="$ROOTDIRS$SEP$dir"
+        SEP="|"
+    done
+    OURCYGPATTERN="(^($ROOTDIRS))"
+    # Add a user-defined pattern to the cygpath arguments
+    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+    fi
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    i=0
+    for arg in "$@" ; do
+        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
+
+        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
+            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+        else
+            eval `echo args$i`="\"$arg\""
+        fi
+        i=`expr $i + 1`
+    done
+    case $i in
+        0) set -- ;;
+        1) set -- "$args0" ;;
+        2) set -- "$args0" "$args1" ;;
+        3) set -- "$args0" "$args1" "$args2" ;;
+        4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+    esac
+fi
+
+# Escape application args
+save () {
+    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+    echo " "
+}
+APP_ARGS=`save "$@"`
+
+# Collect all arguments for the java command, following the shell quoting and substitution rules
+eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+
+exec "$JAVACMD" "$@"
diff --git a/gradlew.bat b/gradlew.bat
new file mode 100644
index 0000000..107acd3
--- /dev/null
+++ b/gradlew.bat
@@ -0,0 +1,89 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto execute
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto execute
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega
diff --git a/settings.gradle b/settings.gradle
new file mode 100644
index 0000000..f66dbc7
--- /dev/null
+++ b/settings.gradle
@@ -0,0 +1,31 @@
+pluginManagement {
+    repositories {
+        mavenCentral()
+        gradlePluginPortal()
+
+        // Add the Forge Repository (ForgeGradle fetches most of its stuff from here)
+        maven {
+            name = "Forge"
+            url = "https://maven.minecraftforge.net"
+        }
+
+        // Add the Jitpack Repository (We fetch ForgeGradle from this)
+        maven {
+            name = "Jitpack"
+            url = "https://jitpack.io/"
+        }
+    }
+    resolutionStrategy {
+        eachPlugin {
+            // If the "net.minecraftforge.gradle.forge" plugin is requested we redirect it to asbyth's ForgeGradle fork
+            if (requested.id.id == "net.minecraftforge.gradle.forge") {
+                useModule("com.github.asbyth:ForgeGradle:${requested.version}")
+            }
+            if (requested.id.id == "org.spongepowered.mixin") {
+                useModule("com.github.xcfrg:MixinGradle:${requested.version}")
+            }
+        }
+    }
+}
+
+rootProject.name = "ForgeTemplate"
\ No newline at end of file
diff --git a/src/main/java/rosegoldaddons/Config.java b/src/main/java/rosegoldaddons/Config.java
new file mode 100644
index 0000000..0047b65
--- /dev/null
+++ b/src/main/java/rosegoldaddons/Config.java
@@ -0,0 +1,52 @@
+package rosegoldaddons;
+
+import gg.essential.vigilance.Vigilant;
+import gg.essential.vigilance.data.Property;
+import gg.essential.vigilance.data.PropertyType;
+
+import java.awt.*;
+import java.io.File;
+import java.util.Arrays;
+
+import java.io.File;
+
+public class Config extends Vigilant {
+    public static Config INSTANCE = new Config();
+
+    @Property(type = PropertyType.SWITCH, name = "Auto Start Dungeon + Ready", description = "Automatically starts the dungeon and gets ready.",
+            category = "RoseGoldAddons", subcategory = "General")
+    public boolean AutoReady = true;
+
+    @Property(type = PropertyType.SWITCH, name = "Party Untransfer", description = "When you really dont wanna be party leader.",
+            category = "RoseGoldAddons", subcategory = "General")
+    public boolean AutoUntransfer = true;
+
+    @Property(type = PropertyType.SWITCH, name = "Enderman ESP", description = "**NOT** Needed for enderman macro.",
+            category = "RoseGoldAddons", subcategory = "General")
+    public boolean EndermanESP = false;
+
+    @Property(type = PropertyType.SWITCH, name = "Use Utility Items when Swapping", description = "Automatically use Tuba / Orb / Wand when AOTS or Whip swap are enabled",
+            category = "RoseGoldAddons", subcategory = "General")
+    public boolean UseUtility = false;
+
+    @Property(type = PropertyType.SLIDER, name = "Sword Swap Delay", description = "How often to swap swords (in miliseconds)",
+            category = "RoseGoldAddons", subcategory = "General", max = 2000)
+    public int swapFrequency = 500;
+
+    @Property(type = PropertyType.SLIDER, name = "ItemFrame Terminal Aura Delay", description = "How often to click an item frame (in miliseconds)",
+            category = "RoseGoldAddons", subcategory = "General", max = 500)
+    public int auraDelay = 10;
+
+    @Property(type = PropertyType.SLIDER, name = "Smooth Look Velocity", description = "How fast should head rotation changes be (in miliseconds)",
+            category = "RoseGoldAddons", subcategory = "General", min = 1, max = 200)
+    public int smoothLookVelocity = 50;
+
+    @Property(type = PropertyType.SLIDER, name = "Macro Range", description = "Look for entities only in radius of the player, 0 = unlimited",
+            category = "RoseGoldAddons", subcategory = "General", min = 0, max = 100)
+    public int macroRadius = 0;
+
+    public Config() {
+        super(new File("./config/rosegoldaddons/config.toml"), "RoseGold Addons");
+        initialize();
+    }
+}
diff --git a/src/main/java/rosegoldaddons/FMLLoadingPlugin.java b/src/main/java/rosegoldaddons/FMLLoadingPlugin.java
new file mode 100644
index 0000000..57d237e
--- /dev/null
+++ b/src/main/java/rosegoldaddons/FMLLoadingPlugin.java
@@ -0,0 +1,45 @@
+package rosegoldaddons;
+
+import net.minecraftforge.common.ForgeVersion;
+import net.minecraftforge.fml.relauncher.IFMLLoadingPlugin;
+import org.spongepowered.asm.launch.MixinBootstrap;
+import org.spongepowered.asm.mixin.MixinEnvironment;
+import org.spongepowered.asm.mixin.Mixins;
+
+
+import java.util.Map;
+
+@IFMLLoadingPlugin.MCVersion(ForgeVersion.mcVersion)
+public class FMLLoadingPlugin implements IFMLLoadingPlugin {
+
+    public FMLLoadingPlugin() {
+        MixinBootstrap.init();
+        Mixins.addConfiguration("mixins.rosegoldaddons.json");
+        MixinEnvironment.getCurrentEnvironment().setObfuscationContext("searge");
+    }
+
+    @Override
+    public String[] getASMTransformerClass() {
+        return new String[0];
+    }
+
+    @Override
+    public String getModContainerClass() {
+        return null;
+    }
+
+    @Override
+    public String getSetupClass() {
+        return null;
+    }
+
+    @Override
+    public void injectData(Map<String, Object> data) {
+
+    }
+
+    @Override
+    public String getAccessTransformerClass() {
+        return null;
+    }
+}
diff --git a/src/main/java/rosegoldaddons/Main.java b/src/main/java/rosegoldaddons/Main.java
new file mode 100644
index 0000000..9c2a338
--- /dev/null
+++ b/src/main/java/rosegoldaddons/Main.java
@@ -0,0 +1,159 @@
+package rosegoldaddons;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.GuiScreen;
+import net.minecraft.client.settings.KeyBinding;
+import net.minecraft.util.ChatComponentText;
+import net.minecraftforge.client.ClientCommandHandler;
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.fml.client.registry.ClientRegistry;
+import net.minecraftforge.fml.common.Mod;
+import net.minecraftforge.fml.common.event.FMLInitializationEvent;
+import net.minecraftforge.fml.common.event.FMLPreInitializationEvent;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import net.minecraftforge.fml.common.gameevent.InputEvent;
+import net.minecraftforge.fml.common.gameevent.TickEvent;
+import net.minecraftforge.fml.common.network.FMLNetworkEvent;
+import org.lwjgl.input.Keyboard;
+import rosegoldaddons.commands.*;
+import rosegoldaddons.features.BlockBreakAura;
+import rosegoldaddons.features.*;
+import rosegoldaddons.utils.OpenSkyblockGui;
+
+import java.io.*;
+
+@Mod(modid = "timechanger", name = "RoseGold Addons", version = "2.1")
+public class Main {
+    public static GuiScreen display = null;
+    public static Config configFile = Config.INSTANCE;
+    public static KeyBinding[] keyBinds = new KeyBinding[11];
+    public static int tickCount = 0;
+    public static boolean endermanMacro = false;
+    public static boolean powderMacro = false;
+    public static String u = "";
+    public static boolean AOTSMacro = false;
+    public static boolean SoulWhipMacro = false;
+    public static boolean verified = false;
+    public static boolean GhostMacro = false;
+    public static boolean legitToggle = false;
+    public static boolean gemNukeToggle = false;
+    public static boolean wartToggle = false;
+    public static boolean autoUseItems = false;
+    public static boolean autoHardStone = false;
+
+    @Mod.EventHandler
+    public void onFMLInitialization(FMLPreInitializationEvent event) {
+        File directory = new File(event.getModConfigurationDirectory(), "rosegoldaddons");
+        if (!directory.exists()) {
+            directory.mkdirs();
+        }
+    }
+
+    @Mod.EventHandler
+    public void init(FMLInitializationEvent event) {
+        MinecraftForge.EVENT_BUS.register(this);
+        MinecraftForge.EVENT_BUS.register(new AutoReady());
+        MinecraftForge.EVENT_BUS.register(new OpenSkyblockGui());
+        MinecraftForge.EVENT_BUS.register(new EndermanMacro());
+        MinecraftForge.EVENT_BUS.register(new ItemFrameAura());
+        MinecraftForge.EVENT_BUS.register(new PowderMacro());
+        MinecraftForge.EVENT_BUS.register(new SwordSwapping());
+        MinecraftForge.EVENT_BUS.register(new PartyUntransfer());
+        MinecraftForge.EVENT_BUS.register(new GhostMacro());
+        MinecraftForge.EVENT_BUS.register(new BlockBreakAura());
+        MinecraftForge.EVENT_BUS.register(new WartMacro());
+        MinecraftForge.EVENT_BUS.register(new CustomItemMacro());
+        MinecraftForge.EVENT_BUS.register(new HardstoneMacro());
+
+        configFile.initialize();
+        ClientCommandHandler.instance.registerCommand(new OpenSettings());
+        ClientCommandHandler.instance.registerCommand(new Rosedrobe());
+        ClientCommandHandler.instance.registerCommand(new LobbySwap());
+        ClientCommandHandler.instance.registerCommand(new Backpack());
+        ClientCommandHandler.instance.registerCommand(new WartSetup());
+        ClientCommandHandler.instance.registerCommand(new UseCooldown());
+
+        keyBinds[0] = new KeyBinding("Custom Item Macro Toggle", Keyboard.KEY_NONE, "RoseGold Addons");
+        keyBinds[1] = new KeyBinding("Toggle Enderman Macro", Keyboard.KEY_NONE, "RoseGold Addons");
+        keyBinds[2] = new KeyBinding("Item Frame Aura", Keyboard.KEY_NONE, "RoseGold Addons");
+        keyBinds[3] = new KeyBinding("Powder Macro Toggle", Keyboard.KEY_NONE, "RoseGold Addons");
+        keyBinds[4] = new KeyBinding("AOTS SS Toggle", Keyboard.KEY_NONE, "RoseGold Addons");
+        keyBinds[5] = new KeyBinding("Soul Whip SS Toggle", Keyboard.KEY_NONE, "RoseGold Addons");
+        keyBinds[6] = new KeyBinding("Ghost Macro Toggle", Keyboard.KEY_NONE, "RoseGold Addons");
+        keyBinds[7] = new KeyBinding("Item Frame Legit Mode Toggle", Keyboard.KEY_NONE, "RoseGold Addons");
+        keyBinds[8] = new KeyBinding("Gemstone Smart Nuke", Keyboard.KEY_NONE, "RoseGold Addons");
+        keyBinds[9] = new KeyBinding("Wart Macro", Keyboard.KEY_NONE, "RoseGold Addons");
+        keyBinds[10] = new KeyBinding("Hardstone Macro", Keyboard.KEY_NONE, "RoseGold Addons");
+
+        for (KeyBinding keyBind : keyBinds) {
+            ClientRegistry.registerKeyBinding(keyBind);
+        }
+    }
+
+    @SubscribeEvent
+    public void tick(TickEvent.ClientTickEvent event) {
+        if (event.phase != TickEvent.Phase.START) return;
+        if (display != null) {
+            try {
+                Minecraft.getMinecraft().displayGuiScreen(display);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+            display = null;
+        }
+    }
+
+    @SubscribeEvent
+    public void connect(FMLNetworkEvent.ClientConnectedToServerEvent event) {
+
+    }
+
+    @SubscribeEvent
+    public void key(InputEvent.KeyInputEvent event) {
+        if (keyBinds[0].isPressed()) {
+            autoUseItems = !autoUseItems;
+            String str = autoUseItems ? "§aCustom Item Macro Activated" : "§cCustom Item Macro Deactivated";
+            Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentText(str));
+        } else if (keyBinds[1].isPressed()) {
+            endermanMacro = !endermanMacro;
+            String str = endermanMacro ? "§aZealot Macro Activated" : "§cZealot Macro Deactivated";
+            Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentText(str));
+        } else if (keyBinds[2].isPressed()) {
+            ItemFrameAura.mainAura();
+        } else if (keyBinds[3].isPressed()) {
+            powderMacro = !powderMacro;
+            String str = powderMacro ? "§aPowder Macro Activated" : "§cPowder Macro Deactivated";
+            Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentText(str));
+        } else if (keyBinds[4].isPressed()) {
+            AOTSMacro = !AOTSMacro;
+            String str = AOTSMacro ? "§aAOTS Macro Activated" : "§cAOTS Macro Deactivated";
+            Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentText(str));
+        } else if (keyBinds[5].isPressed()) {
+            SoulWhipMacro = !SoulWhipMacro;
+            String str = SoulWhipMacro ? "§aSoul Whip Macro Activated" : "§cSoul Whip Macro Deactivated";
+            Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentText(str));
+        } else if(keyBinds[6].isPressed()) {
+            GhostMacro = !GhostMacro;
+            String str = GhostMacro ? "§aGhost Macro Activated" : "§cGhost Macro Deactivated";
+            Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentText(str));
+        } else if(keyBinds[7].isPressed()) {
+            legitToggle = !legitToggle;
+            String str = legitToggle ? "§aLegit Mode Activated" : "§cLegit Mode Deactivated";
+            SwordSwapping.tickCount = 0;
+            Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentText(str));
+        } else if(keyBinds[8].isPressed()) {
+            gemNukeToggle = !gemNukeToggle;
+            String str = gemNukeToggle ? "§aGemstone Nuke Activated" : "§cGemstone Nuke Deactivated";
+            Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentText(str));
+        } else if(keyBinds[9].isPressed()) {
+            wartToggle = !wartToggle;
+            String str = wartToggle ? "§aWart Macro Activated" : "§cWart Macro Deactivated";
+            Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentText(str));
+        } else if(keyBinds[10].isPressed()) {
+            autoHardStone = !autoHardStone;
+            String str = autoHardStone ? "§aHardstone Macro Activated" : "§cHardstone Macro Deactivated";
+            Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentText(str));
+        }
+    }
+
+}
diff --git a/src/main/java/rosegoldaddons/OpenSettings.java b/src/main/java/rosegoldaddons/OpenSettings.java
new file mode 100644
index 0000000..0e79b74
--- /dev/null
+++ b/src/main/java/rosegoldaddons/OpenSettings.java
@@ -0,0 +1,57 @@
+package rosegoldaddons;
+
+import net.minecraft.command.CommandBase;
+import net.minecraft.command.ICommand;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.util.BlockPos;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class OpenSettings implements ICommand {
+    @Override
+    public String getCommandName() {
+        return "rosegoldaddons";
+    }
+
+    @Override
+    public String getCommandUsage(ICommandSender sender) {
+        return "/" + getCommandName();
+    }
+
+    @Override
+    public List<String> getCommandAliases() {
+        return new ArrayList<>(Arrays.asList("rosegoldaddons", "rga"));
+    }
+
+    @Override
+    public void processCommand(ICommandSender sender, String[] args) {
+        /*EntityPlayerSP player = (EntityPlayerSP) sender;
+        player.addChatMessage(new ChatComponentText("hi "+player.getName()+"!"));*/
+        Main.display = Main.configFile.gui();
+        return;
+    }
+
+    @Override
+    public boolean canCommandSenderUseCommand(ICommandSender sender) {
+        return true;
+    }
+
+    @Override
+    public List<String> addTabCompletionOptions(ICommandSender sender, String[] args, BlockPos pos) {
+        return new ArrayList<>();
+    }
+
+    @Override
+    public boolean isUsernameIndex(String[] args, int index) {
+        return false;
+    }
+
+    @Override
+    public int compareTo(@NotNull ICommand o) {
+        return 0;
+    }
+}
+
diff --git a/src/main/java/rosegoldaddons/commands/Backpack.java b/src/main/java/rosegoldaddons/commands/Backpack.java
new file mode 100644
index 0000000..f69cd87
--- /dev/null
+++ b/src/main/java/rosegoldaddons/commands/Backpack.java
@@ -0,0 +1,87 @@
+package rosegoldaddons.commands;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.inventory.GuiChest;
+import net.minecraft.command.CommandBase;
+import net.minecraft.command.CommandException;
+import net.minecraft.command.ICommand;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.inventory.Container;
+import net.minecraft.inventory.ContainerChest;
+import net.minecraft.inventory.Slot;
+import net.minecraft.util.BlockPos;
+import net.minecraft.util.ChatComponentText;
+import net.minecraft.util.StringUtils;
+import net.minecraftforge.client.event.GuiScreenEvent;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import org.jetbrains.annotations.NotNull;
+import rosegoldaddons.Main;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class Backpack implements ICommand {
+    public static boolean openBP = false;
+    public static int bpSlot = 0;
+
+    @Override
+    public String getCommandName() {
+        return "backpack";
+    }
+
+    @Override
+    public String getCommandUsage(ICommandSender sender) {
+        return "/" + getCommandName();
+    }
+
+    @Override
+    public List<String> getCommandAliases() {
+        return new ArrayList<>(Arrays.asList("backpack", "bp"));
+    }
+
+    @Override
+    public void processCommand(ICommandSender sender, String[] args) throws CommandException {
+        if (args.length == 0) {
+            Minecraft.getMinecraft().thePlayer.sendChatMessage("/storage");
+        } else {
+            if (isNumeric(args[0])) {
+                Minecraft.getMinecraft().thePlayer.sendChatMessage("/storage");
+                openBP = true;
+                bpSlot = Integer.parseInt(args[0]);
+            } else {
+                Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentText("§cInvalid Arguments."));
+                return;
+            }
+        }
+    }
+
+    @Override
+    public boolean canCommandSenderUseCommand(ICommandSender sender) {
+        return true;
+    }
+
+    @Override
+    public List<String> addTabCompletionOptions(ICommandSender sender, String[] args, BlockPos pos) {
+        return new ArrayList<>();
+    }
+
+    @Override
+    public boolean isUsernameIndex(String[] args, int index) {
+        return false;
+    }
+
+    private boolean isNumeric(String str) {
+        try {
+            Double.parseDouble(str);
+            return true;
+        } catch (NumberFormatException e) {
+            return false;
+        }
+    }
+
+    @Override
+    public int compareTo(@NotNull ICommand o) {
+        return 0;
+    }
+}
diff --git a/src/main/java/rosegoldaddons/commands/LobbySwap.java b/src/main/java/rosegoldaddons/commands/LobbySwap.java
new file mode 100644
index 0000000..517354b
--- /dev/null
+++ b/src/main/java/rosegoldaddons/commands/LobbySwap.java
@@ -0,0 +1,57 @@
+package rosegoldaddons.commands;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.command.CommandException;
+import net.minecraft.command.ICommand;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.util.BlockPos;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class LobbySwap implements ICommand {
+    public static boolean swapLobby = false;
+
+    @Override
+    public String getCommandName() {
+        return "lobbyswap";
+    }
+
+    @Override
+    public String getCommandUsage(ICommandSender sender) {
+        return "/" + getCommandName();
+    }
+
+    @Override
+    public List<String> getCommandAliases() {
+        return new ArrayList<>();
+    }
+
+    @Override
+    public void processCommand(ICommandSender sender, String[] args) throws CommandException {
+        swapLobby = true;
+        Minecraft.getMinecraft().thePlayer.sendChatMessage("/sbmenu");
+
+    }
+
+    @Override
+    public boolean canCommandSenderUseCommand(ICommandSender sender) {
+        return true;
+    }
+
+    @Override
+    public List<String> addTabCompletionOptions(ICommandSender sender, String[] args, BlockPos pos) {
+        return null;
+    }
+
+    @Override
+    public boolean isUsernameIndex(String[] args, int index) {
+        return false;
+    }
+
+    @Override
+    public int compareTo(@NotNull ICommand o) {
+        return 0;
+    }
+}
diff --git a/src/main/java/rosegoldaddons/commands/Rosedrobe.java b/src/main/java/rosegoldaddons/commands/Rosedrobe.java
new file mode 100644
index 0000000..1f7fd62
--- /dev/null
+++ b/src/main/java/rosegoldaddons/commands/Rosedrobe.java
@@ -0,0 +1,90 @@
+package rosegoldaddons.commands;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.inventory.GuiChest;
+import net.minecraft.command.CommandBase;
+import net.minecraft.command.CommandException;
+import net.minecraft.command.ICommand;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.inventory.Container;
+import net.minecraft.inventory.ContainerChest;
+import net.minecraft.inventory.Slot;
+import net.minecraft.util.BlockPos;
+import net.minecraft.util.ChatComponentText;
+import net.minecraft.util.StringUtils;
+import net.minecraftforge.client.event.GuiScreenEvent;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import org.jetbrains.annotations.NotNull;
+import rosegoldaddons.Main;
+import scala.actors.threadpool.Arrays;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Rosedrobe implements ICommand {
+    public static boolean openWardrobe = false;
+    public static int slot = 0;
+    int windowId;
+
+    @Override
+    public String getCommandName() {
+        return "rosedrobe";
+    }
+
+    @Override
+    public String getCommandUsage(ICommandSender sender) {
+        return "/" + getCommandName();
+    }
+
+    @Override
+    public List<String> getCommandAliases() {
+        return new ArrayList<>();
+    }
+
+    @Override
+    public void processCommand(ICommandSender sender, String[] args) throws CommandException {
+        if (args.length == 0) {
+            Minecraft.getMinecraft().thePlayer.sendChatMessage("/pets");
+            slot = 0;
+            openWardrobe = true;
+        } else {
+            if (isNumeric(args[0])) {
+                Minecraft.getMinecraft().thePlayer.sendChatMessage("/pets");
+                openWardrobe = true;
+                slot = Integer.parseInt(args[0]);
+            } else {
+                Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentText("§cInvalid Arguments."));
+                return;
+            }
+        }
+    }
+
+    @Override
+    public boolean canCommandSenderUseCommand(ICommandSender sender) {
+        return true;
+    }
+
+    @Override
+    public List<String> addTabCompletionOptions(ICommandSender sender, String[] args, BlockPos pos) {
+        return new ArrayList<>();
+    }
+
+    @Override
+    public boolean isUsernameIndex(String[] args, int index) {
+        return false;
+    }
+
+    private boolean isNumeric(String str) {
+        try {
+            Double.parseDouble(str);
+            return true;
+        } catch (NumberFormatException e) {
+            return false;
+        }
+    }
+
+    @Override
+    public int compareTo(@NotNull ICommand o) {
+        return 0;
+    }
+}
diff --git a/src/main/java/rosegoldaddons/commands/UseCooldown.java b/src/main/java/rosegoldaddons/commands/UseCooldown.java
new file mode 100644
index 0000000..912c75a
--- /dev/null
+++ b/src/main/java/rosegoldaddons/commands/UseCooldown.java
@@ -0,0 +1,90 @@
+package rosegoldaddons.commands;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.command.CommandException;
+import net.minecraft.command.ICommand;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.BlockPos;
+import net.minecraft.util.ChatComponentText;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+public class UseCooldown implements ICommand {
+    public static HashMap<String, Integer> items = new HashMap<String, Integer>();
+
+    @Override
+    public String getCommandName() {
+        return "usecooldown";
+    }
+
+    @Override
+    public String getCommandUsage(ICommandSender sender) {
+        return "/" + getCommandName();
+    }
+
+    @Override
+    public List<String> getCommandAliases() {
+        return new ArrayList<>();
+    }
+
+    @Override
+    public void processCommand(ICommandSender sender, String[] args) throws CommandException {
+        if (args.length == 1 && isNumeric(args[0])) {
+            InventoryPlayer inv = Minecraft.getMinecraft().thePlayer.inventory;
+
+            ItemStack curStack = inv.getStackInSlot(Minecraft.getMinecraft().thePlayer.inventory.currentItem);
+            if (curStack != null) {
+                int cd = Integer.parseInt(args[0]);
+                if (cd == 0) {
+                    items.remove(curStack.getDisplayName());
+                    Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentText("§aSuccessfully Removed " + curStack.getDisplayName() + "§a."));
+                    return;
+                }
+                if (cd < 1) {
+                    Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentText("§cInvalid Miliseconds, Minimum delay 1 Milisecond."));
+                    return;
+                }
+                Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentText("§aSuccessfully Added " + curStack.getDisplayName() + "§a with delay of " + cd + " ms."));
+                items.put(curStack.getDisplayName(), cd);
+            } else {
+                Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentText("§cError getting current held item."));
+            }
+        } else {
+            Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentText("§cInvalid Arguments."));
+        }
+    }
+
+    @Override
+    public boolean canCommandSenderUseCommand(ICommandSender sender) {
+        return true;
+    }
+
+    @Override
+    public List<String> addTabCompletionOptions(ICommandSender sender, String[] args, BlockPos pos) {
+        return new ArrayList<>();
+    }
+
+    @Override
+    public boolean isUsernameIndex(String[] args, int index) {
+        return false;
+    }
+
+    private boolean isNumeric(String str) {
+        try {
+            Double.parseDouble(str);
+            return true;
+        } catch (NumberFormatException e) {
+            return false;
+        }
+    }
+
+    @Override
+    public int compareTo(@NotNull ICommand o) {
+        return 0;
+    }
+}
diff --git a/src/main/java/rosegoldaddons/commands/WartSetup.java b/src/main/java/rosegoldaddons/commands/WartSetup.java
new file mode 100644
index 0000000..a5cca13
--- /dev/null
+++ b/src/main/java/rosegoldaddons/commands/WartSetup.java
@@ -0,0 +1,82 @@
+package rosegoldaddons.commands;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.command.CommandException;
+import net.minecraft.command.ICommand;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.util.BlockPos;
+import net.minecraft.util.ChatComponentText;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class WartSetup implements ICommand {
+    public static int wartEnd = 99999;
+    public static String cardinal = "west";
+
+    @Override
+    public String getCommandName() {
+        return "wartsetup";
+    }
+
+    @Override
+    public String getCommandUsage(ICommandSender sender) {
+        return "/" + getCommandName();
+    }
+
+    @Override
+    public List<String> getCommandAliases() {
+        return new ArrayList<>();
+    }
+
+    @Override
+    public void processCommand(ICommandSender sender, String[] args) throws CommandException {
+        if(args.length == 2) {
+            if(args[0].equals("west")) {
+                cardinal = "west";
+            } else if(args[0].equals("north")) {
+                cardinal = "north";
+            } else if(args[0].equals("east")) {
+                cardinal = "east";
+            } else if(args[0].equals("south")) {
+                cardinal = "south";
+            }
+
+            if(isNumeric(args[1])) {
+                wartEnd = (int) Math.floor(Double.parseDouble(args[1]));
+            }
+        } else {
+            Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentText("§cInvalid Arguments."));
+        }
+    }
+
+    @Override
+    public boolean canCommandSenderUseCommand(ICommandSender sender) {
+        return true;
+    }
+
+    @Override
+    public List<String> addTabCompletionOptions(ICommandSender sender, String[] args, BlockPos pos) {
+        return new ArrayList<>();
+    }
+
+    @Override
+    public boolean isUsernameIndex(String[] args, int index) {
+        return false;
+    }
+
+    @Override
+    public int compareTo(@NotNull ICommand o) {
+        return 0;
+    }
+
+    private boolean isNumeric(String str) {
+        try {
+            Double.parseDouble(str);
+            return true;
+        } catch (NumberFormatException e) {
+            return false;
+        }
+    }
+}
diff --git a/src/main/java/rosegoldaddons/events/ReceivePacketEvent.java b/src/main/java/rosegoldaddons/events/ReceivePacketEvent.java
new file mode 100644
index 0000000..e658a1e
--- /dev/null
+++ b/src/main/java/rosegoldaddons/events/ReceivePacketEvent.java
@@ -0,0 +1,16 @@
+package rosegoldaddons.events;
+
+import net.minecraft.network.Packet;
+import net.minecraftforge.fml.common.eventhandler.Cancelable;
+import net.minecraftforge.fml.common.eventhandler.Event;
+
+@Cancelable
+public class ReceivePacketEvent extends Event {
+
+    public Packet<?> packet;
+
+    public ReceivePacketEvent(Packet<?> packet) {
+        this.packet = packet;
+    }
+
+}
diff --git a/src/main/java/rosegoldaddons/events/RenderLivingEntityEvent.java b/src/main/java/rosegoldaddons/events/RenderLivingEntityEvent.java
new file mode 100644
index 0000000..8a6c9ed
--- /dev/null
+++ b/src/main/java/rosegoldaddons/events/RenderLivingEntityEvent.java
@@ -0,0 +1,26 @@
+package rosegoldaddons.events;
+
+import net.minecraft.client.model.ModelBase;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraftforge.fml.common.eventhandler.Cancelable;
+import net.minecraftforge.fml.common.eventhandler.Event;
+
+@Cancelable
+public class RenderLivingEntityEvent extends Event {
+
+    public EntityLivingBase entity;
+    public float p_77036_2_, p_77036_3_, p_77036_4_, p_77036_5_, p_77036_6_, scaleFactor;
+    public ModelBase modelBase;
+
+    public RenderLivingEntityEvent(EntityLivingBase entity, float p_77036_2_, float p_77036_3_, float p_77036_4_, float p_77036_5_, float p_77036_6_, float scaleFactor, ModelBase modelBase) {
+        this.entity = entity;
+        this.p_77036_2_ = p_77036_2_;
+        this.p_77036_3_ = p_77036_3_;
+        this.p_77036_4_ = p_77036_4_;
+        this.p_77036_5_ = p_77036_5_;
+        this.p_77036_6_ = p_77036_6_;
+        this.scaleFactor = scaleFactor;
+        this.modelBase = modelBase;
+    }
+
+}
\ No newline at end of file
diff --git a/src/main/java/rosegoldaddons/features/AutoReady.java b/src/main/java/rosegoldaddons/features/AutoReady.java
new file mode 100644
index 0000000..12089a1
--- /dev/null
+++ b/src/main/java/rosegoldaddons/features/AutoReady.java
@@ -0,0 +1,122 @@
+package rosegoldaddons.features;
+
+import com.mojang.realmsclient.gui.ChatFormatting;
+
+import java.awt.Color;
+import java.util.List;
+import java.util.Locale;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.entity.EntityPlayerSP;
+import net.minecraft.client.gui.GuiScreen;
+import net.minecraft.client.gui.inventory.GuiChest;
+import net.minecraft.client.network.NetHandlerPlayClient;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.Container;
+import net.minecraft.inventory.ContainerChest;
+import net.minecraft.inventory.Slot;
+import net.minecraft.network.play.server.S45PacketTitle;
+import net.minecraft.potion.Potion;
+import net.minecraft.util.ChatComponentText;
+import net.minecraft.util.IChatComponent;
+import net.minecraft.util.StringUtils;
+import net.minecraftforge.client.event.ClientChatReceivedEvent;
+import net.minecraftforge.client.event.GuiScreenEvent;
+import net.minecraftforge.client.event.RenderWorldLastEvent;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import rosegoldaddons.Config;
+import rosegoldaddons.Main;
+import rosegoldaddons.events.RenderLivingEntityEvent;
+import rosegoldaddons.utils.OutlineUtils;
+import net.minecraft.network.play.client.C02PacketUseEntity;
+import net.minecraft.client.multiplayer.PlayerControllerMP;
+import scala.collection.parallel.ParIterableLike;
+
+public class AutoReady {
+    boolean startDung = false;
+    boolean checkingEntities = false;
+    String currentMenu = "";
+    static int windowId;
+
+    private double getDist2Entities(Entity entity1, Entity entity2) {
+        return Math.sqrt(Math.pow((entity1.getPosition().getX() - entity2.getPosition().getX()), 2) + Math.pow((entity1.getPosition().getY() - entity2.getPosition().getY()), 2) + Math.pow((entity1.getPosition().getZ() - entity2.getPosition().getZ()), 2));
+    }
+
+    private static void interactWithEntity(Entity entity) {
+        PlayerControllerMP playerControllerMP = Minecraft.getMinecraft().playerController;
+        playerControllerMP.interactWithEntitySendPacket(Minecraft.getMinecraft().thePlayer, entity);
+    }
+
+    @SubscribeEvent
+    public void renderWorld(RenderWorldLastEvent event) {
+        if (!Main.configFile.AutoReady || !startDung || checkingEntities) return;
+        new Thread(() -> {
+            try {
+                checkingEntities = true;
+                Thread.sleep(500);
+                Entity mort = null;
+                for (Entity entity1 : (Minecraft.getMinecraft().theWorld.loadedEntityList)) {
+                    if (entity1.getName().contains("Mort")) {
+                        mort = entity1;
+                        interactWithEntity(mort);
+                        startDung = false;
+                        break;
+                    }
+                }
+                checkingEntities = false;
+            } catch (Exception e) {}
+        }).start();
+    }
+
+    @SubscribeEvent
+    public void chat(ClientChatReceivedEvent event) {
+        if (!Main.configFile.AutoReady) return;
+        String message = StringUtils.stripControlCodes(event.message.getUnformattedText()).toLowerCase();
+        if (message.contains("active potion effects have been paused")) {
+            startDung = true;
+        }
+    }
+
+    @SubscribeEvent
+    public void guiDraw(GuiScreenEvent.BackgroundDrawnEvent event) {
+        if (!Main.configFile.AutoReady) return;
+        if (event.gui instanceof GuiChest) {
+            Container container = ((GuiChest) event.gui).inventorySlots;
+            if (container instanceof ContainerChest) {
+                String chestName = ((ContainerChest) container).getLowerChestInventory().getDisplayName().getUnformattedText();
+                List<Slot> invSlots = container.inventorySlots;
+                //Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentText(chestName));
+                if (chestName.contains("Start Dungeon?")) {
+                    int i;
+                    for(i = 0; i < invSlots.size(); i++) {
+                        if(!invSlots.get(i).getHasStack()) continue;
+                        String slotName = StringUtils.stripControlCodes(invSlots.get(i).getStack().getDisplayName());
+                        if(slotName.equals("Start Dungeon?")) {
+                            clickSlot(invSlots.get(i));
+                        }
+                    }
+                } else if (chestName.contains("Catacombs -")) {
+                    int i;
+                    for(i = 0; i < invSlots.size(); i++) {
+                        if(!invSlots.get(i).getHasStack()) continue;
+                        String slotName = StringUtils.stripControlCodes(invSlots.get(i).getStack().getDisplayName());
+                        if(slotName.contains(Minecraft.getMinecraft().thePlayer.getName())) {
+                            i += 9;
+                            if(invSlots.get(i).getHasStack()) {
+                                if (StringUtils.stripControlCodes(invSlots.get(i).getStack().getDisplayName()).equals("Not Ready")) {
+                                    clickSlot(invSlots.get(i));
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    private void clickSlot(Slot slot) {
+        windowId = Minecraft.getMinecraft().thePlayer.openContainer.windowId;
+        Minecraft.getMinecraft().playerController.windowClick(windowId, slot.slotNumber, 1, 0, Minecraft.getMinecraft().thePlayer);
+    }
+}
diff --git a/src/main/java/rosegoldaddons/features/BlockBreakAura.java b/src/main/java/rosegoldaddons/features/BlockBreakAura.java
new file mode 100644
index 0000000..e8b7219
--- /dev/null
+++ b/src/main/java/rosegoldaddons/features/BlockBreakAura.java
@@ -0,0 +1,98 @@
+package rosegoldaddons.features;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.multiplayer.PlayerControllerMP;
+import net.minecraft.client.settings.KeyBinding;
+import net.minecraft.init.Blocks;
+import net.minecraft.network.play.client.C07PacketPlayerDigging;
+import net.minecraft.util.*;
+import net.minecraftforge.client.event.RenderWorldLastEvent;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import net.minecraftforge.fml.common.gameevent.TickEvent;
+import rosegoldaddons.Main;
+import rosegoldaddons.utils.RenderUtils;
+import rosegoldaddons.utils.RotationUtils;
+
+import java.awt.*;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+
+public class BlockBreakAura {
+    BlockPos gem = null;
+    private Thread thread;
+    private boolean breaking = false;
+
+    @SubscribeEvent
+    public void onTick(TickEvent.ClientTickEvent event) {
+        if(!Main.gemNukeToggle) {
+            if(breaking) {
+                KeyBinding.setKeyBindState(Minecraft.getMinecraft().gameSettings.keyBindAttack.getKeyCode(), false);
+                breaking = false;
+            }
+            return;
+        }
+        if(event.phase.toString().equals("START") && gem != null) {
+            RotationUtils.facePos(new Vec3(gem.getX()+0.5, gem.getY()-1, gem.getZ()+0.5));
+            MovingObjectPosition objectMouseOver = Minecraft.getMinecraft().objectMouseOver;
+            if(objectMouseOver != null && objectMouseOver.typeOfHit.toString() == "BLOCK") {
+                BlockPos pos = objectMouseOver.getBlockPos();
+                Block gem = Minecraft.getMinecraft().theWorld.getBlockState(pos).getBlock();
+                if(gem == Blocks.stained_glass || gem == Blocks.stained_glass_pane) {
+                    if(!breaking) {
+                        KeyBinding.setKeyBindState(Minecraft.getMinecraft().gameSettings.keyBindAttack.getKeyCode(), true);
+                        breaking = true;
+                    }
+                } else {
+                    if(breaking) {
+                        KeyBinding.setKeyBindState(Minecraft.getMinecraft().gameSettings.keyBindAttack.getKeyCode(), false);
+                        breaking = false;
+                    }
+                }
+
+            }
+        }
+    }
+
+    @SubscribeEvent
+    public void renderWorld(RenderWorldLastEvent event) {
+        if(!Main.gemNukeToggle) return;
+        gem = closestGemstone();
+        if (gem != null) {
+            RenderUtils.drawBlockBox(gem, Color.RED, true, event.partialTicks);
+        }
+    }
+
+    private BlockPos closestGemstone() {
+        int r = 4;
+        BlockPos playerPos = Minecraft.getMinecraft().thePlayer.getPosition();
+        playerPos.add(0, 1, 0);
+        Vec3 playerVec = Minecraft.getMinecraft().thePlayer.getPositionVector();
+        Vec3i vec3i = new Vec3i(r, r, r);
+        ArrayList<Vec3> chests = new ArrayList<Vec3>();
+        if (playerPos != null) {
+            for (BlockPos blockPos : BlockPos.getAllInBox(playerPos.add(vec3i), playerPos.subtract(vec3i))) {
+                IBlockState blockState = Minecraft.getMinecraft().theWorld.getBlockState(blockPos);
+                //Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentText(blockState.getBlock().toString()));
+                if (blockState.getBlock() == Blocks.stained_glass) {
+                    chests.add(new Vec3(blockPos.getX() + 0.5, blockPos.getY(), blockPos.getZ() + 0.5));
+                }
+            }
+        }
+        double smallest = 9999;
+        Vec3 closest = null;
+        for (int i = 0; i < chests.size(); i++) {
+            double dist = chests.get(i).distanceTo(playerVec);
+            if (dist < smallest) {
+                smallest = dist;
+                closest = chests.get(i);
+            }
+        }
+        if (closest != null && smallest < 4) {
+            return new BlockPos(closest.xCoord, closest.yCoord, closest.zCoord);
+        }
+        return null;
+    }
+
+}
diff --git a/src/main/java/rosegoldaddons/features/CustomItemMacro.java b/src/main/java/rosegoldaddons/features/CustomItemMacro.java
new file mode 100644
index 0000000..57c650f
--- /dev/null
+++ b/src/main/java/rosegoldaddons/features/CustomItemMacro.java
@@ -0,0 +1,77 @@
+package rosegoldaddons.features;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.settings.KeyBinding;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ChatComponentText;
+import net.minecraftforge.client.event.RenderWorldLastEvent;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import net.minecraftforge.fml.common.gameevent.TickEvent;
+import rosegoldaddons.Main;
+import rosegoldaddons.commands.UseCooldown;
+import rosegoldaddons.commands.WartSetup;
+
+import java.lang.reflect.Method;
+
+public class CustomItemMacro {
+    private Thread thread;
+    private int milis = 0;
+
+    @SubscribeEvent
+    public void onRender(RenderWorldLastEvent event) {
+        if (!Main.autoUseItems) return;
+        if (thread == null || !thread.isAlive()) {
+            thread = new Thread(() -> {
+                try {
+                    milis++;
+                    int prevItem = Minecraft.getMinecraft().thePlayer.inventory.currentItem;
+                    for (String i : UseCooldown.items.keySet()) {
+                        //Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentText(Math.floor(UseCooldown.items.get(i)/1000) + " " + milis));
+                        if (milis % Math.floor(UseCooldown.items.get(i)/100) == 0) {
+                            int slot = findItemInHotbar(i);
+                            if (slot != -1) {
+                                Minecraft.getMinecraft().thePlayer.inventory.currentItem = slot;
+                                rightClick();
+                                Thread.sleep(1);
+                            }
+                        }
+                    }
+                    Minecraft.getMinecraft().thePlayer.inventory.currentItem = prevItem;
+                    Thread.sleep(100);
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }, "Custom Item Use");
+            thread.start();
+        }
+    }
+
+    public static void rightClick() {
+        try {
+            Method rightClickMouse = null;
+            try {
+                rightClickMouse = Minecraft.class.getDeclaredMethod("rightClickMouse");
+            } catch (NoSuchMethodException e) {
+                rightClickMouse = Minecraft.class.getDeclaredMethod("func_147121_ag");
+            }
+            rightClickMouse.setAccessible(true);
+            rightClickMouse.invoke(Minecraft.getMinecraft());
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    private static int findItemInHotbar(String name) {
+        InventoryPlayer inv = Minecraft.getMinecraft().thePlayer.inventory;
+        for (int i = 0; i < 9; i++) {
+            ItemStack curStack = inv.getStackInSlot(i);
+            if (curStack != null) {
+                if (curStack.getDisplayName().contains(name)) {
+                    return i;
+                }
+            }
+        }
+        return -1;
+    }
+}
diff --git a/src/main/java/rosegoldaddons/features/EndermanMacro.java b/src/main/java/rosegoldaddons/features/EndermanMacro.java
new file mode 100644
index 0000000..fb31a0b
--- /dev/null
+++ b/src/main/java/rosegoldaddons/features/EndermanMacro.java
@@ -0,0 +1,63 @@
+package rosegoldaddons.features;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.monster.EntityCreeper;
+import net.minecraft.entity.monster.EntityEnderman;
+import net.minecraft.util.ChatComponentText;
+import net.minecraft.util.IChatComponent;
+import net.minecraftforge.client.event.RenderWorldEvent;
+import net.minecraftforge.client.event.RenderWorldLastEvent;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import rosegoldaddons.Main;
+import rosegoldaddons.events.RenderLivingEntityEvent;
+import rosegoldaddons.utils.OutlineUtils;
+import rosegoldaddons.utils.RenderUtils;
+import rosegoldaddons.utils.RotationUtils;
+
+import java.awt.*;
+import java.util.HashSet;
+import java.util.Random;
+
+public class EndermanMacro {
+
+    @SubscribeEvent
+    public void renderWorld(RenderWorldLastEvent event) {
+        if (Main.endermanMacro) {
+            Entity entity1 = getClosestEnderman();
+            if(entity1 == null) return;
+            RenderUtils.drawEntityBox(entity1, Color.RED, true, event.partialTicks);
+            RotationUtils.faceEntity(entity1);
+            Random r = new Random();
+            if(r.nextInt(1000) == 1) {
+                RotationUtils.antiAfk();
+            }
+        } else if (Main.configFile.EndermanESP) {
+            for (Entity entity1 : (Minecraft.getMinecraft().theWorld.loadedEntityList)) {
+                if (entity1 instanceof EntityEnderman) {
+                    RenderUtils.drawEntityBox(entity1, Color.RED, true, event.partialTicks);
+                }
+            }
+        }
+    }
+
+    private static Entity getClosestEnderman() {
+        Entity eman = null;
+        Double closest = Double.valueOf(9999);
+        for (Entity entity1 : (Minecraft.getMinecraft().theWorld.loadedEntityList)) {
+            if (entity1 instanceof EntityEnderman && !(((EntityEnderman) entity1).getHealth() == 0)) {
+                double dist = entity1.getDistanceSq(Minecraft.getMinecraft().thePlayer.posX, Minecraft.getMinecraft().thePlayer.posY, Minecraft.getMinecraft().thePlayer.posZ);
+                if (dist < closest) {
+                    if(Main.configFile.macroRadius != 0 && dist < Main.configFile.macroRadius) {
+                        closest = dist;
+                        eman = entity1;
+                    } if(Main.configFile.macroRadius == 0) {
+                        closest = dist;
+                        eman = entity1;
+                    }
+                }
+            }
+        }
+        return eman;
+    }
+}
diff --git a/src/main/java/rosegoldaddons/features/GhostMacro.java b/src/main/java/rosegoldaddons/features/GhostMacro.java
new file mode 100644
index 0000000..8fb2dfc
--- /dev/null
+++ b/src/main/java/rosegoldaddons/features/GhostMacro.java
@@ -0,0 +1,51 @@
+package rosegoldaddons.features;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.monster.EntityCreeper;
+import net.minecraft.entity.monster.EntityEnderman;
+import net.minecraft.util.ChatComponentText;
+import net.minecraftforge.client.event.RenderWorldLastEvent;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import rosegoldaddons.Main;
+import rosegoldaddons.utils.RenderUtils;
+import rosegoldaddons.utils.RotationUtils;
+
+import java.awt.*;
+import java.util.Random;
+
+public class GhostMacro {
+    @SubscribeEvent
+    public void renderWorld(RenderWorldLastEvent event) {
+        if (Main.GhostMacro) {
+            Entity entity1 = getClosestCreeper();
+            if (entity1 == null) return;
+            RenderUtils.drawEntityBox(entity1, Color.RED, true, event.partialTicks);
+            RotationUtils.faceEntity(entity1);
+            Random r = new Random();
+            if(r.nextInt(800) == 1) {
+                RotationUtils.antiAfk();
+            }
+        }
+    }
+
+    private static Entity getClosestCreeper() {
+        Entity eman = null;
+        Double closest = Double.valueOf(9999);
+        for (Entity entity1 : (Minecraft.getMinecraft().theWorld.loadedEntityList)) {
+            if (entity1 instanceof EntityCreeper && !(((EntityCreeper) entity1).getHealth() == 0)) {
+                double dist = entity1.getDistanceSq(Minecraft.getMinecraft().thePlayer.posX, Minecraft.getMinecraft().thePlayer.posY, Minecraft.getMinecraft().thePlayer.posZ);
+                if (dist < closest) {
+                    if(Main.configFile.macroRadius != 0 && dist < Main.configFile.macroRadius) {
+                        closest = dist;
+                        eman = entity1;
+                    } if(Main.configFile.macroRadius == 0) {
+                        closest = dist;
+                        eman = entity1;
+                    }
+                }
+            }
+        }
+        return eman;
+    }
+}
diff --git a/src/main/java/rosegoldaddons/features/HardstoneMacro.java b/src/main/java/rosegoldaddons/features/HardstoneMacro.java
new file mode 100644
index 0000000..95c1808
--- /dev/null
+++ b/src/main/java/rosegoldaddons/features/HardstoneMacro.java
@@ -0,0 +1,201 @@
+package rosegoldaddons.features;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.inventory.GuiChest;
+import net.minecraft.client.settings.KeyBinding;
+import net.minecraft.init.Blocks;
+import net.minecraft.inventory.Container;
+import net.minecraft.inventory.ContainerChest;
+import net.minecraft.inventory.Slot;
+import net.minecraft.network.play.server.S2APacketParticles;
+import net.minecraft.util.*;
+import net.minecraftforge.client.event.GuiScreenEvent;
+import net.minecraftforge.client.event.RenderWorldLastEvent;
+import net.minecraftforge.event.world.WorldEvent;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import net.minecraftforge.fml.common.gameevent.TickEvent;
+import rosegoldaddons.Main;
+import rosegoldaddons.events.ReceivePacketEvent;
+import rosegoldaddons.utils.RenderUtils;
+import rosegoldaddons.utils.RotationUtils;
+
+import java.awt.*;
+import java.util.ArrayList;
+
+public class HardstoneMacro {
+    private ArrayList<Vec3> solved = new ArrayList<>();
+    private BlockPos closestStone = null;
+    private Vec3 closestChest = null;
+    private Thread thread;
+    private boolean breaking = false;
+    private boolean stopHardstone = false;
+
+    @SubscribeEvent
+    public void onTick(TickEvent.ClientTickEvent event) {
+        if (!Main.autoHardStone) {
+            if (breaking) {
+                KeyBinding.setKeyBindState(Minecraft.getMinecraft().gameSettings.keyBindAttack.getKeyCode(), false);
+                breaking = false;
+            }
+            return;
+        }
+        if (event.phase.toString().equals("START") && closestStone != null && !stopHardstone) {
+            RotationUtils.facePos(new Vec3(closestStone.getX() + 0.5, closestStone.getY() - 1, closestStone.getZ() + 0.5));
+            //Minecraft.getMinecraft().playerController.onPlayerDamageBlock(closestStone, EnumFacing.fromAngle(Minecraft.getMinecraft().thePlayer.rotationYaw));
+            MovingObjectPosition objectMouseOver = Minecraft.getMinecraft().objectMouseOver;
+            if (objectMouseOver != null && objectMouseOver.typeOfHit.toString() == "BLOCK") {
+                BlockPos pos = objectMouseOver.getBlockPos();
+                Block block = Minecraft.getMinecraft().theWorld.getBlockState(pos).getBlock();
+                if (block == Blocks.stone || block == Blocks.coal_ore || block == Blocks.diamond_ore || block == Blocks.emerald_ore
+                        || block == Blocks.gold_ore || block == Blocks.iron_ore || block == Blocks.lapis_ore || block == Blocks.redstone_ore) {
+                    int pickaxe = PowderMacro.findItemInHotbar("Jungle");
+                    if (pickaxe != -1) Minecraft.getMinecraft().thePlayer.inventory.currentItem = pickaxe;
+                    if (!breaking) {
+                        KeyBinding.setKeyBindState(Minecraft.getMinecraft().gameSettings.keyBindAttack.getKeyCode(), true);
+                        breaking = true;
+                    }
+                } else {
+                    if (breaking) {
+                        KeyBinding.setKeyBindState(Minecraft.getMinecraft().gameSettings.keyBindAttack.getKeyCode(), false);
+                        breaking = false;
+                    }
+                }
+
+            }
+        }
+        if (stopHardstone) {
+            if (breaking) {
+                KeyBinding.setKeyBindState(Minecraft.getMinecraft().gameSettings.keyBindAttack.getKeyCode(), false);
+                breaking = false;
+            }
+        }
+    }
+
+    @SubscribeEvent
+    public void receivePacket(ReceivePacketEvent event) {
+        if (!Main.autoHardStone) return;
+        if (event.packet instanceof S2APacketParticles) {
+            S2APacketParticles packet = (S2APacketParticles) event.packet;
+            if (packet.getParticleType().equals(EnumParticleTypes.CRIT)) {
+                Vec3 particlePos = new Vec3(packet.getXCoordinate(), packet.getYCoordinate() - 0.7, packet.getZCoordinate());
+                if (closestChest != null) {
+                    stopHardstone = true;
+                    double dist = closestChest.distanceTo(particlePos);
+                    if (dist < 1) {
+                        particlePos = particlePos.add(new Vec3(0, -1, 0));
+                        int drill = PowderMacro.findItemInHotbar("X655");
+                        if (drill != -1) Minecraft.getMinecraft().thePlayer.inventory.currentItem = drill;
+                        RotationUtils.facePos(particlePos);
+                    }
+                }
+            }
+        }
+    }
+
+    @SubscribeEvent
+    public void guiDraw(GuiScreenEvent.BackgroundDrawnEvent event) {
+        new Thread(() -> {
+            try {
+                if (event.gui instanceof GuiChest) {
+                    Container container = ((GuiChest) event.gui).inventorySlots;
+                    if (container instanceof ContainerChest) {
+                        String chestName = ((ContainerChest) container).getLowerChestInventory().getDisplayName().getUnformattedText();
+                        if (chestName.contains("Treasure")) {
+                            breaking = false;
+                            solved.add(closestChest);
+                            stopHardstone = false;
+                            Thread.sleep(20);
+                            Minecraft.getMinecraft().thePlayer.closeScreen();
+                        }
+                    }
+                }
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }).start();
+    }
+
+    @SubscribeEvent
+    public void renderWorld(RenderWorldLastEvent event) {
+        if (!Main.autoHardStone) return;
+        closestStone = closestStone();
+        closestChest = closestChest();
+        if (closestStone != null) {
+            RenderUtils.drawBlockBox(closestStone, new Color(128, 128, 128), true, event.partialTicks);
+        }
+        if (closestChest != null) {
+            RenderUtils.drawBlockBox(new BlockPos(closestChest.xCoord, closestChest.yCoord, closestChest.zCoord), new Color(255, 128, 0), true, event.partialTicks);
+        } else {
+            stopHardstone = false;
+        }
+    }
+
+    @SubscribeEvent
+    public void clear(WorldEvent.Load event) {
+        solved.clear();
+    }
+
+    private BlockPos closestStone() {
+        int r = 6;
+        BlockPos playerPos = Minecraft.getMinecraft().thePlayer.getPosition();
+        playerPos.add(0, 1, 0);
+        Vec3 playerVec = Minecraft.getMinecraft().thePlayer.getPositionVector();
+        Vec3i vec3i = new Vec3i(r, 1, r);
+        Vec3i vec3i2 = new Vec3i(r, 0, r);
+        ArrayList<Vec3> stones = new ArrayList<Vec3>();
+        if (playerPos != null) {
+            for (BlockPos blockPos : BlockPos.getAllInBox(playerPos.add(vec3i), playerPos.subtract(vec3i2))) {
+                IBlockState blockState = Minecraft.getMinecraft().theWorld.getBlockState(blockPos);
+                //Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentText(blockState.getBlock().toString()));
+                if (blockState.getBlock() == Blocks.stone) {
+                    stones.add(new Vec3(blockPos.getX() + 0.5, blockPos.getY(), blockPos.getZ() + 0.5));
+                }
+            }
+        }
+        double smallest = 9999;
+        Vec3 closest = null;
+        for (Vec3 stone : stones) {
+            double dist = stone.distanceTo(playerVec);
+            if (dist < smallest) {
+                smallest = dist;
+                closest = stone;
+            }
+        }
+        if (closest != null && smallest < 5) {
+            return new BlockPos(closest.xCoord, closest.yCoord, closest.zCoord);
+        }
+        return null;
+    }
+
+    private Vec3 closestChest() {
+        int r = 6;
+        BlockPos playerPos = Minecraft.getMinecraft().thePlayer.getPosition();
+        playerPos.add(0, 1, 0);
+        Vec3 playerVec = Minecraft.getMinecraft().thePlayer.getPositionVector();
+        Vec3i vec3i = new Vec3i(r, r, r);
+        ArrayList<Vec3> chests = new ArrayList<>();
+        if (playerPos != null) {
+            for (BlockPos blockPos : BlockPos.getAllInBox(playerPos.add(vec3i), playerPos.subtract(vec3i))) {
+                IBlockState blockState = Minecraft.getMinecraft().theWorld.getBlockState(blockPos);
+                //Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentText(blockState.getBlock().toString()));
+                if (blockState.getBlock() == Blocks.chest) {
+                    chests.add(new Vec3(blockPos.getX() + 0.5, blockPos.getY(), blockPos.getZ() + 0.5));
+                }
+            }
+        }
+        double smallest = 9999;
+        Vec3 closest = null;
+        for (Vec3 chest : chests) {
+            if(!solved.contains(chest)) {
+                double dist = chest.distanceTo(playerVec);
+                if (dist < smallest) {
+                    smallest = dist;
+                    closest = chest;
+                }
+            }
+        }
+        return closest;
+    }
+}
diff --git a/src/main/java/rosegoldaddons/features/ItemFrameAura.java b/src/main/java/rosegoldaddons/features/ItemFrameAura.java
new file mode 100644
index 0000000..0e7426f
--- /dev/null
+++ b/src/main/java/rosegoldaddons/features/ItemFrameAura.java
@@ -0,0 +1,413 @@
+package rosegoldaddons.features;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.multiplayer.PlayerControllerMP;
+import net.minecraft.client.settings.KeyBinding;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.item.EntityItemFrame;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.BlockPos;
+import net.minecraft.util.ChatComponentText;
+import net.minecraft.util.IChatComponent;
+import net.minecraft.util.MovingObjectPosition;
+import net.minecraftforge.client.event.RenderWorldLastEvent;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import net.minecraftforge.fml.common.gameevent.TickEvent;
+import rosegoldaddons.Main;
+
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+
+public class ItemFrameAura {
+    private static ArrayList<Entity> itemFrames = new ArrayList<Entity>();
+    private static boolean clicking = false;
+    private static ArrayList<Entity> clicked = new ArrayList<Entity>();
+    private Thread thread;
+
+    public static void rightClick() {
+        try {
+            Method rightClickMouse = null;
+            try {
+                rightClickMouse = Minecraft.class.getDeclaredMethod("rightClickMouse");
+            } catch (NoSuchMethodException e) {
+                rightClickMouse = Minecraft.class.getDeclaredMethod("func_147121_ag");
+            }
+            rightClickMouse.setAccessible(true);
+            rightClickMouse.invoke(Minecraft.getMinecraft());
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    @SubscribeEvent
+    public void onTick(TickEvent.PlayerTickEvent event) {
+        if (!Main.legitToggle) return;
+        if (thread == null || !thread.isAlive()) {
+            thread = new Thread(() -> {
+                try {
+                    BlockPos topLeft = new BlockPos(196, 125, 278);
+                    ArrayList<Entity> redWools = new ArrayList<Entity>();
+                    ArrayList<Entity> greenWools = new ArrayList<Entity>();
+
+                    itemFrames.forEach(itemFrame -> {
+                        ItemStack itemStack = ((EntityItemFrame) itemFrame).getDisplayedItem();
+                        if (itemStack != null) {
+                            String itemString = itemStack.toString();
+                            if (itemString.contains("cloth@14")) {
+                                redWools.add(itemFrame);
+                            } else if (itemString.contains("cloth@5")) {
+                                greenWools.add(itemFrame);
+                            }
+                        }
+                    });
+                    String patternName = getPattern(redWools, greenWools, topLeft);
+                    MovingObjectPosition objectMouseOver = Minecraft.getMinecraft().objectMouseOver;
+                    if (objectMouseOver != null && objectMouseOver.entityHit != null) {
+                        Entity entity = objectMouseOver.entityHit;
+                        if (entity instanceof EntityItemFrame) {
+                            Entity itemFrame = entity;
+                            ItemStack itemStack = ((EntityItemFrame) itemFrame).getDisplayedItem();
+                            if (itemStack != null) {
+                                String itemString = itemStack.toString();
+                                if (itemString.contains("arrow@0")) {
+                                    int endRotationAmount = howMuchToClick(patternName, itemFrame, topLeft, true);
+                                    int currRotationAmount = ((EntityItemFrame) itemFrame).getRotation();
+                                    int toClick = 0;
+                                    if (currRotationAmount < endRotationAmount) {
+                                        toClick = endRotationAmount - currRotationAmount;
+                                    } else if (currRotationAmount > endRotationAmount) {
+                                        currRotationAmount = currRotationAmount - 8;
+                                        toClick = endRotationAmount - currRotationAmount;
+                                    }
+                                    Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentText("" + toClick));
+                                    for (int i = 0; i < toClick; i++) {
+                                        //Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentText("clicked"));
+                                        rightClick();
+                                        Thread.sleep(Main.configFile.auraDelay);
+                                    }
+                                    Thread.sleep(200);
+                                }
+                            }
+                        }
+                    }
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }, "Legit Mode");
+            thread.start();
+        }
+    }
+
+    @SubscribeEvent
+    public void renderWorld(RenderWorldLastEvent event) {
+        itemFrames.clear();
+        for (Entity entity1 : (Minecraft.getMinecraft().theWorld.loadedEntityList)) {
+            if (entity1 instanceof EntityItemFrame) {
+                itemFrames.add(entity1);
+            }
+        }
+    }
+
+    private static void interactWithEntity(Entity entity) {
+        PlayerControllerMP playerControllerMP = Minecraft.getMinecraft().playerController;
+        playerControllerMP.interactWithEntitySendPacket(Minecraft.getMinecraft().thePlayer, entity);
+    }
+
+    public static void mainAura() {
+        BlockPos topLeft = new BlockPos(196, 125, 278);
+        ArrayList<Entity> redWools = new ArrayList<Entity>();
+        ArrayList<Entity> greenWools = new ArrayList<Entity>();
+
+        itemFrames.forEach(itemFrame -> {
+            ItemStack itemStack = ((EntityItemFrame) itemFrame).getDisplayedItem();
+            if (itemStack != null) {
+                String itemString = itemStack.toString();
+                if (itemString.contains("cloth@14")) {
+                    redWools.add(itemFrame);
+                } else if (itemString.contains("cloth@5")) {
+                    greenWools.add(itemFrame);
+                }
+            }
+        });
+
+        String patternName = getPattern(redWools, greenWools, topLeft);
+        Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentText(patternName));
+        clickPatternAura(patternName, topLeft);
+    }
+
+    private static void clickPatternAura(String patternName, BlockPos topLeft) {
+        new Thread(() -> {
+            itemFrames.forEach(itemFrame -> {
+                ItemStack itemStack = ((EntityItemFrame) itemFrame).getDisplayedItem();
+                if (itemStack != null) {
+                    String itemString = itemStack.toString();
+                    if (itemString.contains("arrow@0")) {
+                        int endRotationAmount = howMuchToClick(patternName, itemFrame, topLeft, false);
+                        int currRotationAmount = ((EntityItemFrame) itemFrame).getRotation();
+                        int toClick = 0;
+                        if (currRotationAmount < endRotationAmount) {
+                            toClick = endRotationAmount - currRotationAmount;
+                        } else if (currRotationAmount > endRotationAmount) {
+                            currRotationAmount = currRotationAmount - 8;
+                            toClick = endRotationAmount - currRotationAmount;
+                        }
+                        for (int i = 0; i < toClick; i++) {
+                            interactWithEntity(itemFrame);
+                        }
+                    }
+                }
+            });
+        }).start();
+    }
+
+    private static int howMuchToClick(String patternName, Entity entity, BlockPos topLeft, boolean legitMode) {
+        //prepare to see top tier code right here boys
+        int y = entity.getPosition().getY();
+        int z = entity.getPosition().getZ();
+        int relativeY = topLeft.getY() - y;
+        int relativeX = topLeft.getZ() - z; //intentional
+
+        //shit tier code!! i didn't know how to use hashmaps when i made this :)
+        if (patternName == "legs") {
+            if (relativeY == 0) {
+                if (relativeX == 3 || relativeX == 2) {
+                    return 5;
+                } else if (relativeX == 1) {
+                    return 3;
+                }
+            }
+            if (relativeY == 1 || relativeY == 2 || relativeY == 3) {
+                if (relativeX == 1) {
+                    return 3;
+                } else if (relativeX == 3) {
+                    return 7;
+                }
+            }
+            if (relativeY == 4) {
+                if (relativeX == 1) {
+                    if (legitMode) return 5;
+                    return 4;
+                }
+                if (relativeX == 3) {
+                    return 7;
+                }
+            }
+        }
+        if (patternName == "lines") {
+            if (relativeY == 4 && relativeX == 2) {
+                if (legitMode) return 5;
+                return 4;
+            }
+            return 5;
+        }
+        if (patternName == "S") {
+            if (relativeY == 0) {
+                if (relativeX == 4) {
+                    return 3;
+                }
+                if (relativeX < 4) {
+                    return 1;
+                }
+            }
+            if (relativeY == 1) {
+                if (relativeX == 2) {
+                    return 7;
+                }
+                if (relativeX == 4) {
+                    return 3;
+                }
+            }
+            if (relativeY == 3) {
+                if (relativeX == 0) {
+                    return 7;
+                }
+                if (relativeX == 2) {
+                    if (legitMode) return 3;
+                    return 2;
+                }
+            }
+            if (relativeY == 4) {
+                if (relativeX == 0) {
+                    return 7;
+                }
+                if (relativeX > 0) {
+                    return 5;
+                }
+            }
+        }
+        if (patternName == "W") {
+            if (relativeY == 1 || relativeY == 2) {
+                return 3;
+            }
+            if (relativeY == 3) {
+                if (relativeX == 0 || relativeX == 4) {
+                    return 3;
+                }
+                if (relativeX == 2) {
+                    if (legitMode) return 7;
+                    return 6;
+                }
+            }
+            if (relativeY == 4) {
+                if (relativeX < 2) {
+                    return 1;
+                }
+                if (relativeX == 2) {
+                    return 7;
+                }
+                if (relativeX > 2) {
+                    return 5;
+                }
+            }
+        }
+        if (patternName == "spiral") {
+            if (relativeY == 0) {
+                if (relativeX == 0) {
+                    return 3;
+                }
+                return 5;
+            }
+            if (relativeY == 3 && relativeX == 2) {
+                if (legitMode) return 7;
+                return 6;
+            }
+            if (relativeY < 4) {
+                if (relativeX == 0) {
+                    return 3;
+                }
+                if (relativeX == 2 || relativeX == 4) {
+                    return 7;
+                }
+            }
+            if (relativeY == 4) {
+                if (relativeX == 2) {
+                    return 7;
+                }
+                return 1;
+            }
+        }
+        if (patternName == "zigzag") {
+            if (relativeY == 3) {
+                if (relativeX == 2) {
+                    if (legitMode) return 5;
+                    return 4;
+                }
+            }
+            if (relativeY == 1 || relativeY == 3 || relativeX == 3) {
+                return 5;
+            }
+            if (relativeX == 2) {
+                if (relativeY == 0) {
+                    return 3;
+                }
+                if (relativeY == 2 || relativeY == 4) {
+                    return 7;
+                }
+            }
+        }
+        if (patternName == "N") {
+            if (relativeY == 3 && relativeX == 2) {
+                if (legitMode) return 3;
+                return 2;
+            }
+            if (relativeY == 0) {
+                if (relativeX == 2) {
+                    return 3;
+                }
+                return 5;
+            }
+            if (relativeY < 4) {
+                if (relativeX == 0 || relativeX == 4) {
+                    return 7;
+                }
+                if (relativeX == 2) {
+                    return 3;
+                }
+            }
+            if (relativeY == 4) {
+                if (relativeX > 0) {
+                    return 5;
+                }
+                if (relativeX == 0) {
+                    return 7;
+                }
+            }
+        }
+        if (patternName == "bottleneck") {
+            if (relativeY == 3 && relativeX == 1) {
+                if (legitMode) return 7;
+                return 6;
+            }
+            if (relativeY == 0) {
+                if (relativeX < 2) {
+                    return 1;
+                }
+                if (relativeX > 2) {
+                    return 5;
+                }
+            }
+            if (relativeY == 1 || relativeY == 3) {
+                return 7;
+            }
+            if (relativeY == 2) {
+                if (relativeX == 0 || relativeX == 4) {
+                    return 7;
+                }
+                if (relativeX == 1) {
+                    return 5;
+                }
+                if (relativeX == 3) {
+                    return 1;
+                }
+            }
+        }
+
+        return 0;
+    }
+
+    private static String getPattern(ArrayList<Entity> redWools, ArrayList<Entity> greenWools, BlockPos topleft) {
+        if (redWools.size() == 1) {
+            if (greenWools.size() == 1) {
+                Entity ry1 = (Entity) redWools.toArray()[0];
+                Entity gy1 = (Entity) greenWools.toArray()[0];
+                BlockPos redPos1 = ry1.getPosition();
+                BlockPos greenPos1 = gy1.getPosition();
+                //Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentText("red 1: "+redPos1));
+                int relativeR1 = topleft.getY() - redPos1.getY();
+                int relativeG1 = topleft.getY() - greenPos1.getY();
+                if (relativeG1 == 4 && relativeR1 == 4) {
+                    return "legs";
+                }
+                if (relativeG1 == 4 && relativeR1 == 0) {
+                    return "N";
+                }
+                if (relativeG1 == 4 && relativeR1 == 2) {
+                    return "spiral";
+                }
+            } else if (greenWools.size() == 2) {
+                Entity ry1 = (Entity) redWools.toArray()[0];
+                BlockPos redPos1 = ry1.getPosition();
+                int relativeR1 = topleft.getY() - redPos1.getY();
+                if (relativeR1 == 2) {
+                    return "W";
+                }
+                return "bottleneck";
+            }
+
+        } else if (redWools.size() == 2) {
+            Entity ry1 = (Entity) redWools.toArray()[0];
+            Entity ry2 = (Entity) redWools.toArray()[0];
+            BlockPos redPos1 = ry1.getPosition();
+            BlockPos redPos2 = ry2.getPosition();
+            int relativeR1 = topleft.getY() - redPos1.getY();
+            int relativeR2 = topleft.getY() - redPos2.getY();
+            if (greenWools.size() > 1) return "zigzag";
+            return "S";
+
+        } else if (redWools.size() == 3) {
+            return "lines";
+        }
+
+        return "Unrecognized";
+    }
+}
diff --git a/src/main/java/rosegoldaddons/features/PartyUntransfer.java b/src/main/java/rosegoldaddons/features/PartyUntransfer.java
new file mode 100644
index 0000000..c88b4e3
--- /dev/null
+++ b/src/main/java/rosegoldaddons/features/PartyUntransfer.java
@@ -0,0 +1,34 @@
+package rosegoldaddons.features;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.util.ChatComponentText;
+import net.minecraft.util.StringUtils;
+import net.minecraftforge.client.event.ClientChatReceivedEvent;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import rosegoldaddons.Main;
+
+public class PartyUntransfer {
+    @SubscribeEvent
+    public void chat(ClientChatReceivedEvent event) {
+        if (!Main.configFile.AutoUntransfer) return;
+        String message = StringUtils.stripControlCodes(event.message.getUnformattedText()).toLowerCase();
+        if (message.contains("the party was transferred to")) {
+            String playerName = Minecraft.getMinecraft().thePlayer.getName();
+            String leader = stripRank(message.substring(message.indexOf("by")+3));
+            Minecraft.getMinecraft().thePlayer.sendChatMessage("/p transfer "+leader);
+        }
+        if(message.contains("has promoted")) {
+            String playerName = Minecraft.getMinecraft().thePlayer.getName();
+            String leader = stripRank(message.substring(0 ,message.indexOf("has promoted")-1));
+            Minecraft.getMinecraft().thePlayer.sendChatMessage("/p transfer "+leader);
+        }
+    }
+
+    private String stripRank(String name) {
+        if(!name.contains("]")) {
+            System.out.println("non detected");
+            return name;
+        }
+        return name.substring(name.indexOf("]")+2);
+    }
+}
diff --git a/src/main/java/rosegoldaddons/features/PowderMacro.java b/src/main/java/rosegoldaddons/features/PowderMacro.java
new file mode 100644
index 0000000..3666e0d
--- /dev/null
+++ b/src/main/java/rosegoldaddons/features/PowderMacro.java
@@ -0,0 +1,98 @@
+package rosegoldaddons.features;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.client.Minecraft;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.ItemStack;
+import net.minecraft.network.play.server.S2APacketParticles;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.*;
+import net.minecraftforge.client.event.RenderWorldLastEvent;
+import net.minecraftforge.event.entity.living.LivingEvent;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import rosegoldaddons.Main;
+import rosegoldaddons.events.ReceivePacketEvent;
+import rosegoldaddons.utils.RenderUtils;
+import rosegoldaddons.utils.RotationUtils;
+
+import java.awt.*;
+import java.util.ArrayList;
+
+public class PowderMacro {
+    private static Vec3 closestChest = null;
+
+    @SubscribeEvent
+    public void receivePacket(ReceivePacketEvent event) {
+        if (!Main.powderMacro) return;
+        if (event.packet instanceof S2APacketParticles) {
+            S2APacketParticles packet = (S2APacketParticles) event.packet;
+            if (packet.getParticleType().equals(EnumParticleTypes.CRIT)) {
+                Vec3 particlePos = new Vec3(packet.getXCoordinate(), packet.getYCoordinate() - 0.7, packet.getZCoordinate());
+                if (closestChest != null) {
+                    double dist = closestChest.distanceTo(particlePos);
+                    /*Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentText(dist + ""));
+                    Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentText(closestChest.toString()));
+                    Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentText(particlePos.toString()));*/
+                    if (dist < 1) {
+                        particlePos = particlePos.add(new Vec3(0, -1, 0));
+                        int drill = findItemInHotbar("X655");
+                        if(drill != -1) Minecraft.getMinecraft().thePlayer.inventory.currentItem = drill;
+                        RotationUtils.facePos(particlePos);
+                    }
+                }
+            }
+        }
+    }
+
+    @SubscribeEvent
+    public void renderWorld(RenderWorldLastEvent event) {
+        if (!Main.powderMacro) return;
+        closestChest = closestChest();
+        if (closestChest != null) {
+            RenderUtils.drawBlockBox(new BlockPos(closestChest.xCoord, closestChest.yCoord, closestChest.zCoord), new Color(255, 128, 0), true, event.partialTicks);
+        }
+    }
+
+    private static Vec3 closestChest() {
+        int r = 6;
+        BlockPos playerPos = Minecraft.getMinecraft().thePlayer.getPosition();
+        playerPos.add(0, 1, 0);
+        Vec3 playerVec = Minecraft.getMinecraft().thePlayer.getPositionVector();
+        Vec3i vec3i = new Vec3i(r, r, r);
+        ArrayList<Vec3> chests = new ArrayList<Vec3>();
+        if (playerPos != null) {
+            for (BlockPos blockPos : BlockPos.getAllInBox(playerPos.add(vec3i), playerPos.subtract(vec3i))) {
+                IBlockState blockState = Minecraft.getMinecraft().theWorld.getBlockState(blockPos);
+                //Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentText(blockState.getBlock().toString()));
+                if (blockState.getBlock() == Blocks.chest) {
+                    chests.add(new Vec3(blockPos.getX() + 0.5, blockPos.getY(), blockPos.getZ() + 0.5));
+                }
+            }
+        }
+        double smallest = 9999;
+        Vec3 closest = null;
+        for (int i = 0; i <chests.size(); i++){
+            double dist = chests.get(i).distanceTo(playerVec);
+            if (dist < smallest) {
+                smallest = dist;
+                closest = chests.get(i);
+            }
+        }
+        return closest;
+    }
+
+    public static int findItemInHotbar(String name) {
+        InventoryPlayer inv = Minecraft.getMinecraft().thePlayer.inventory;
+        for (int i = 0; i < 9; i++) {
+            ItemStack curStack = inv.getStackInSlot(i);
+            if (curStack != null) {
+                if (curStack.getDisplayName().contains(name)) {
+                    return i;
+                }
+            }
+        }
+        return -1;
+    }
+}
diff --git a/src/main/java/rosegoldaddons/features/SwordSwapping.java b/src/main/java/rosegoldaddons/features/SwordSwapping.java
new file mode 100644
index 0000000..099b9d7
--- /dev/null
+++ b/src/main/java/rosegoldaddons/features/SwordSwapping.java
@@ -0,0 +1,106 @@
+package rosegoldaddons.features;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ChatComponentText;
+import net.minecraft.util.StringUtils;
+import net.minecraft.world.World;
+import net.minecraftforge.client.event.ClientChatReceivedEvent;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import net.minecraftforge.fml.common.gameevent.TickEvent;
+import rosegoldaddons.Main;
+
+import java.lang.reflect.Method;
+
+public class SwordSwapping {
+    public static int tickCount = 0;
+    private Thread thread;
+
+    public static void rightClick() {
+        try {
+            Method rightClickMouse = null;
+            try {
+                rightClickMouse = Minecraft.class.getDeclaredMethod("rightClickMouse");
+            } catch (NoSuchMethodException e) {
+                rightClickMouse = Minecraft.class.getDeclaredMethod("func_147121_ag");
+            }
+            rightClickMouse.setAccessible(true);
+            rightClickMouse.invoke(Minecraft.getMinecraft());
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    private static int findItemInHotbar(String name) {
+        InventoryPlayer inv = Minecraft.getMinecraft().thePlayer.inventory;
+        for (int i = 0; i < 9; i++) {
+            ItemStack curStack = inv.getStackInSlot(i);
+            if (curStack != null) {
+                if (curStack.getDisplayName().contains(name)) {
+                    return i;
+                }
+            }
+        }
+        return -1;
+    }
+
+    @SubscribeEvent
+    public void onTick(TickEvent.PlayerTickEvent event) {
+        if (Minecraft.getMinecraft().currentScreen != null) return;
+        if (!Main.AOTSMacro && !Main.SoulWhipMacro) {
+            tickCount = 0;
+            return;
+        }
+        if (thread == null || !thread.isAlive()) {
+            thread = new Thread(() -> {
+                try {
+                    Thread.sleep(Main.configFile.swapFrequency);
+                    int prevItem = Minecraft.getMinecraft().thePlayer.inventory.currentItem;
+                    int orbSlot = findItemInHotbar("Power Orb");
+                    int tubaSlot = findItemInHotbar("Tuba");
+                    int wandSlot = findItemInHotbar("Atonement");
+                    int whipSlot = -1;
+                    int aotsSlot = -1;
+                    if(Main.AOTSMacro) {
+                        aotsSlot = findItemInHotbar("Shredded");
+                    }
+                    if(Main.SoulWhipMacro) {
+                        whipSlot = findItemInHotbar("Whip");
+                    }
+                    if(whipSlot != -1) {
+                        Minecraft.getMinecraft().thePlayer.inventory.currentItem = whipSlot;
+                        rightClick();
+                    }
+                    if(aotsSlot != -1) {
+                        Minecraft.getMinecraft().thePlayer.inventory.currentItem = aotsSlot;
+                        rightClick();
+                    }
+                    if(Main.configFile.UseUtility) {
+                        if(tickCount % Math.round((1000/Main.configFile.swapFrequency*20)) == 1 && tubaSlot != -1) {
+                            Thread.sleep(1);
+                            Minecraft.getMinecraft().thePlayer.inventory.currentItem = tubaSlot;
+                            rightClick();
+                        }
+                        if(tickCount % Math.round((1000/Main.configFile.swapFrequency*59)) == 1 && orbSlot != -1) {
+                            Thread.sleep(1);
+                            Minecraft.getMinecraft().thePlayer.inventory.currentItem = orbSlot;
+                            rightClick();
+                        }
+                        if(tickCount % Math.round((1000/Main.configFile.swapFrequency*7)) == 1 && wandSlot != -1) {
+                            Thread.sleep(1);
+                            Minecraft.getMinecraft().thePlayer.inventory.currentItem = wandSlot;
+                            rightClick();
+                        }
+                    }
+                    Minecraft.getMinecraft().thePlayer.inventory.currentItem = prevItem;
+                    tickCount++;
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }, "Sword Swap");
+            thread.start();
+        }
+    }
+}
diff --git a/src/main/java/rosegoldaddons/features/WartMacro.java b/src/main/java/rosegoldaddons/features/WartMacro.java
new file mode 100644
index 0000000..8b47fcb
--- /dev/null
+++ b/src/main/java/rosegoldaddons/features/WartMacro.java
@@ -0,0 +1,146 @@
+package rosegoldaddons.features;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.settings.KeyBinding;
+import net.minecraft.init.Blocks;
+import net.minecraft.util.*;
+import net.minecraftforge.client.event.RenderWorldLastEvent;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import net.minecraftforge.fml.common.gameevent.TickEvent;
+import rosegoldaddons.Main;
+import rosegoldaddons.commands.WartSetup;
+import rosegoldaddons.utils.RenderUtils;
+
+import java.awt.*;
+import java.util.ArrayList;
+
+public class WartMacro {
+    private boolean breaking = false;
+    private boolean walking = false;
+    private double savex = -999;
+    private double savez = -999;
+    private Thread thread;
+    private Thread thread2;
+
+    @SubscribeEvent
+    public void move(TickEvent.ClientTickEvent event) {
+        if (!Main.wartToggle || Minecraft.getMinecraft().currentScreen != null) {
+            if (walking) {
+                KeyBinding.setKeyBindState(Minecraft.getMinecraft().gameSettings.keyBindForward.getKeyCode(), false);
+                walking = false;
+            }
+            return;
+        }
+        if (thread == null || !thread.isAlive()) {
+            thread = new Thread(() -> {
+                try {
+                    //if (event.phase.toString().equals("START")) {
+                        if (!walking) {
+                            KeyBinding.setKeyBindState(Minecraft.getMinecraft().gameSettings.keyBindForward.getKeyCode(), true);
+                            walking = true;
+                        }
+                        float prevYaw = Minecraft.getMinecraft().thePlayer.rotationYaw;
+                        float nextYaw = -1;
+                        if (WartSetup.cardinal.equals("east")) {
+                            if (Minecraft.getMinecraft().thePlayer.getPosition().getZ() == WartSetup.wartEnd) {
+                                nextYaw = 230;
+                            } else if (Minecraft.getMinecraft().thePlayer.getPosition().getZ() == -WartSetup.wartEnd) {
+                                nextYaw = 310;
+                            }
+                        } else if (WartSetup.cardinal.equals("north")) {
+                            if (Minecraft.getMinecraft().thePlayer.getPosition().getX() == WartSetup.wartEnd) {
+                                nextYaw = 140;
+                            } else if (Minecraft.getMinecraft().thePlayer.getPosition().getX() == -WartSetup.wartEnd) {
+                                nextYaw = 220;
+                            }
+                        } else if (WartSetup.cardinal.equals("west")) {
+                            if (Minecraft.getMinecraft().thePlayer.getPosition().getZ() == WartSetup.wartEnd) {
+                                nextYaw = 130;
+                            } else if (Minecraft.getMinecraft().thePlayer.getPosition().getZ() == -WartSetup.wartEnd) {
+                                nextYaw = 50;
+                            }
+                        } else if (WartSetup.cardinal.equals("south")) {
+                            if (Minecraft.getMinecraft().thePlayer.getPosition().getX() == WartSetup.wartEnd) {
+                                nextYaw = 40;
+                            } else if (Minecraft.getMinecraft().thePlayer.getPosition().getX() == -WartSetup.wartEnd) {
+                                nextYaw = 320;
+                            }
+                        }
+                        if(nextYaw != -1) {
+                            for (int i = 0; i < 50; i++) {
+                                Minecraft.getMinecraft().thePlayer.rotationYaw += (nextYaw - prevYaw) / 50;
+                                Thread.sleep(10);
+                            }
+                        }
+                    //}
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }, "Wart Rotation");
+            thread.start();
+        }
+    }
+
+
+    @SubscribeEvent
+    public void click(TickEvent.ClientTickEvent event) {
+        if (!Main.wartToggle || Minecraft.getMinecraft().currentScreen != null) {
+            if (breaking) {
+                KeyBinding.setKeyBindState(Minecraft.getMinecraft().gameSettings.keyBindAttack.getKeyCode(), false);
+                breaking = false;
+            }
+            return;
+        }
+        if (event.phase.toString().equals("START")) {
+            MovingObjectPosition objectMouseOver = Minecraft.getMinecraft().objectMouseOver;
+            if (objectMouseOver != null && objectMouseOver.typeOfHit.toString() == "BLOCK") {
+                BlockPos pos = objectMouseOver.getBlockPos();
+                Block gem = Minecraft.getMinecraft().theWorld.getBlockState(pos).getBlock();
+                if (gem == Blocks.nether_wart) {
+                    if (!breaking) {
+                        KeyBinding.setKeyBindState(Minecraft.getMinecraft().gameSettings.keyBindAttack.getKeyCode(), true);
+                        breaking = true;
+                    }
+                } else {
+                    if (breaking) {
+                        KeyBinding.setKeyBindState(Minecraft.getMinecraft().gameSettings.keyBindAttack.getKeyCode(), false);
+                        breaking = false;
+                    }
+                }
+            }
+        }
+    }
+
+    @SubscribeEvent
+    public void antiStuck(TickEvent.ClientTickEvent event) {
+        if (!Main.wartToggle || Minecraft.getMinecraft().currentScreen != null) return;
+        if (event.phase.toString().equals("START")) {
+            if (thread2 == null || !thread2.isAlive()) {
+                thread2 = new Thread(() -> {
+                    try {
+                        Thread.sleep(1500);
+                        double xdiff = Math.abs(savex - Minecraft.getMinecraft().thePlayer.posX);
+                        double zdiff = Math.abs(savez - Minecraft.getMinecraft().thePlayer.posZ);
+                        if(xdiff < 2 && zdiff < 2) {
+                            Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentText("stuck detected."));
+                            KeyBinding.setKeyBindState(Minecraft.getMinecraft().gameSettings.keyBindLeft.getKeyCode(), true);
+                            Thread.sleep(500);
+                            KeyBinding.setKeyBindState(Minecraft.getMinecraft().gameSettings.keyBindLeft.getKeyCode(), false);
+                            Thread.sleep(1000);
+                            KeyBinding.setKeyBindState(Minecraft.getMinecraft().gameSettings.keyBindRight.getKeyCode(), true);
+                            Thread.sleep(500);
+                            KeyBinding.setKeyBindState(Minecraft.getMinecraft().gameSettings.keyBindRight.getKeyCode(), false);
+                        }
+                        savex = Minecraft.getMinecraft().thePlayer.posX;
+                        savez = Minecraft.getMinecraft().thePlayer.posZ;
+                    } catch (InterruptedException e) {
+                        e.printStackTrace();
+                    }
+                }, "Anti Stuck");
+                thread2.start();
+            }
+        }
+    }
+}
diff --git a/src/main/java/rosegoldaddons/mixins/MixinNetworkManager.java b/src/main/java/rosegoldaddons/mixins/MixinNetworkManager.java
new file mode 100644
index 0000000..29fc19d
--- /dev/null
+++ b/src/main/java/rosegoldaddons/mixins/MixinNetworkManager.java
@@ -0,0 +1,20 @@
+package rosegoldaddons.mixins;
+
+import io.netty.channel.ChannelHandlerContext;
+import net.minecraft.network.NetworkManager;
+import net.minecraft.network.Packet;
+import net.minecraftforge.common.MinecraftForge;
+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 rosegoldaddons.events.ReceivePacketEvent;
+
+@Mixin(NetworkManager.class)
+public class MixinNetworkManager {
+
+    @Inject(method = "channelRead0", at = @At("HEAD"), cancellable = true)
+    private void onReceivePacket(ChannelHandlerContext context, Packet<?> packet, CallbackInfo ci) {
+        if (MinecraftForge.EVENT_BUS.post(new ReceivePacketEvent(packet))) ci.cancel();
+    }
+}
diff --git a/src/main/java/rosegoldaddons/mixins/MixinRendererLivingEntity.java b/src/main/java/rosegoldaddons/mixins/MixinRendererLivingEntity.java
new file mode 100644
index 0000000..bc1033f
--- /dev/null
+++ b/src/main/java/rosegoldaddons/mixins/MixinRendererLivingEntity.java
@@ -0,0 +1,28 @@
+package rosegoldaddons.mixins;
+
+import net.minecraft.client.model.ModelBase;
+import net.minecraft.client.renderer.entity.RendererLivingEntity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import rosegoldaddons.events.RenderLivingEntityEvent;
+
+@Mixin(RendererLivingEntity.class)
+@SideOnly(Side.CLIENT)
+public abstract class MixinRendererLivingEntity {
+
+    @Shadow
+    protected ModelBase mainModel;
+
+    @Inject(method = "renderModel", at = @At("HEAD"), cancellable = true)
+    private <T extends EntityLivingBase> void renderModel(T entity, float p_77036_2_, float p_77036_3_, float p_77036_4_, float p_77036_5_, float p_77036_6_, float scaleFactor, CallbackInfo ci) {
+        if (MinecraftForge.EVENT_BUS.post(new RenderLivingEntityEvent(entity, p_77036_2_, p_77036_3_, p_77036_4_, p_77036_5_, p_77036_6_, scaleFactor, mainModel)))
+            ci.cancel();
+    }
+}
diff --git a/src/main/java/rosegoldaddons/utils/OpenSkyblockGui.java b/src/main/java/rosegoldaddons/utils/OpenSkyblockGui.java
new file mode 100644
index 0000000..6eed707
--- /dev/null
+++ b/src/main/java/rosegoldaddons/utils/OpenSkyblockGui.java
@@ -0,0 +1,154 @@
+package rosegoldaddons.utils;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.inventory.GuiChest;
+import net.minecraft.inventory.Container;
+import net.minecraft.inventory.ContainerChest;
+import net.minecraft.inventory.Slot;
+import net.minecraft.util.ChatComponentText;
+import net.minecraft.util.StringUtils;
+import net.minecraftforge.client.event.GuiScreenEvent;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import rosegoldaddons.commands.Backpack;
+import rosegoldaddons.commands.LobbySwap;
+
+import java.util.List;
+
+public class OpenSkyblockGui {
+    int windowId;
+    boolean openingWardrobe = false;
+    boolean lobbySwapping = false;
+    boolean openingBP = false;
+
+    @SubscribeEvent
+    public void guiDraw(GuiScreenEvent.BackgroundDrawnEvent event) {
+        if (!rosegoldaddons.commands.Rosedrobe.openWardrobe || openingWardrobe) return;
+        new Thread(() -> {
+            try {
+                openingWardrobe = true;
+                if (event.gui instanceof GuiChest) {
+                    Container container = ((GuiChest) event.gui).inventorySlots;
+                    if (container instanceof ContainerChest) {
+                        String chestName = ((ContainerChest) container).getLowerChestInventory().getDisplayName().getUnformattedText();
+                        List<Slot> invSlots = container.inventorySlots;
+                        if (chestName.contains("Pets")) {
+                            int i;
+                            for (i = 0; i < invSlots.size(); i++) {
+                                if (!invSlots.get(i).getHasStack()) continue;
+                                String slotName = StringUtils.stripControlCodes(invSlots.get(i).getStack().getDisplayName());
+                                //Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentText(slotName));
+                                if (slotName.equals("Go Back")) {
+                                    clickSlot(invSlots.get(i));
+                                }
+                            }
+                        } else if (chestName.contains("SkyBlock")) {
+                            int i;
+                            for (i = 0; i < invSlots.size(); i++) {
+                                if (!invSlots.get(i).getHasStack()) continue;
+                                if (StringUtils.stripControlCodes(invSlots.get(i).getStack().getDisplayName()).equals("Wardrobe")) {
+                                    clickSlot(invSlots.get(i));
+                                    if (rosegoldaddons.commands.Rosedrobe.slot == 0)
+                                        rosegoldaddons.commands.Rosedrobe.openWardrobe = false;
+                                }
+                            }
+                        } else if (chestName.contains("Wardrobe")) {
+                            if (rosegoldaddons.commands.Rosedrobe.slot != 0) {
+                                int i;
+                                for (i = 0; i < invSlots.size(); i++) {
+                                    if (!invSlots.get(i).getHasStack()) continue;
+                                    String slotName = "Slot " + rosegoldaddons.commands.Rosedrobe.slot + ":";
+                                    if (StringUtils.stripControlCodes(invSlots.get(i).getStack().getDisplayName()).contains(slotName)) {
+                                        clickSlot(invSlots.get(i));
+                                        Minecraft.getMinecraft().thePlayer.closeScreen();
+                                        rosegoldaddons.commands.Rosedrobe.openWardrobe = false;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                openingWardrobe = false;
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }).start();
+    }
+
+    @SubscribeEvent
+    public void guiDraw2(GuiScreenEvent.BackgroundDrawnEvent event) {
+        if (!LobbySwap.swapLobby || lobbySwapping) return;
+        new Thread(() -> {
+            try {
+                lobbySwapping = true;
+                if (event.gui instanceof GuiChest) {
+                    Container container = ((GuiChest) event.gui).inventorySlots;
+                    if (container instanceof ContainerChest) {
+                        String chestName = ((ContainerChest) container).getLowerChestInventory().getDisplayName().getUnformattedText();
+                        List<Slot> invSlots = container.inventorySlots;
+                        if (chestName.contains("SkyBlock")) {
+                            int i;
+                            for (i = 0; i < invSlots.size(); i++) {
+                                if (!invSlots.get(i).getHasStack()) continue;
+                                if (StringUtils.stripControlCodes(invSlots.get(i).getStack().getDisplayName()).equals("Enter the Crystal Hollows")) {
+                                    clickSlot(invSlots.get(i));
+                                }
+                            }
+                        } else if (chestName.contains("Enter the")) {
+                            int i;
+                            for (i = 0; i < invSlots.size(); i++) {
+                                if (!invSlots.get(i).getHasStack()) continue;
+                                if (StringUtils.stripControlCodes(invSlots.get(i).getStack().getDisplayName()).equals("Confirm")) {
+                                    clickSlot(invSlots.get(i));
+                                    LobbySwap.swapLobby = false;
+                                }
+                            }
+                            Thread.sleep(2000);
+                            Minecraft.getMinecraft().thePlayer.addChatMessage(new ChatComponentText(Minecraft.getMinecraft().theWorld.getWorldTime() + " ticks"));
+                        }
+                    }
+                }
+                lobbySwapping = false;
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }).start();
+    }
+
+    @SubscribeEvent
+    public void guiDraw3(GuiScreenEvent.BackgroundDrawnEvent event) {
+        if (!Backpack.openBP || openingBP) return;
+        new Thread(() -> {
+            try {
+                openingBP = true;
+                if (event.gui instanceof GuiChest) {
+                    Container container = ((GuiChest) event.gui).inventorySlots;
+                    if (container instanceof ContainerChest) {
+                        String chestName = ((ContainerChest) container).getLowerChestInventory().getDisplayName().getUnformattedText();
+                        List<Slot> invSlots = container.inventorySlots;
+                        if (chestName.contains("Storage")) {
+                            if (Backpack.bpSlot != 0) {
+                                int i;
+                                for (i = 0; i < invSlots.size(); i++) {
+                                    if (!invSlots.get(i).getHasStack()) continue;
+                                    String slotName = "Slot " + Backpack.bpSlot;
+                                    if (StringUtils.stripControlCodes(invSlots.get(i).getStack().getDisplayName()).contains(slotName)) {
+                                        clickSlot(invSlots.get(i));
+                                        Backpack.openBP = false;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                openingBP = false;
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }).start();
+    }
+
+    private void clickSlot(Slot slot) {
+        windowId = Minecraft.getMinecraft().thePlayer.openContainer.windowId;
+        Minecraft.getMinecraft().playerController.windowClick(windowId, slot.slotNumber, 0, 0, Minecraft.getMinecraft().thePlayer);
+    }
+}
diff --git a/src/main/java/rosegoldaddons/utils/OutlineUtils.java b/src/main/java/rosegoldaddons/utils/OutlineUtils.java
new file mode 100644
index 0000000..0b1bde2
--- /dev/null
+++ b/src/main/java/rosegoldaddons/utils/OutlineUtils.java
@@ -0,0 +1,152 @@
+package rosegoldaddons.utils;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.model.ModelBase;
+import net.minecraft.client.renderer.GlStateManager;
+import net.minecraft.client.renderer.OpenGlHelper;
+import net.minecraft.client.shader.Framebuffer;
+import net.minecraft.entity.EntityLivingBase;
+import org.lwjgl.opengl.EXTFramebufferObject;
+import org.lwjgl.opengl.EXTPackedDepthStencil;
+import rosegoldaddons.events.RenderLivingEntityEvent;
+
+import java.awt.*;
+
+import static org.lwjgl.opengl.GL11.*;
+
+public class OutlineUtils {
+
+    public static void outlineESP(EntityLivingBase entity, float p_77036_2_, float p_77036_3_, float p_77036_4_, float p_77036_5_, float p_77036_6_, float scaleFactor, ModelBase modelBase, Color color) {
+        Minecraft mc = Minecraft.getMinecraft();
+        boolean fancyGraphics = mc.gameSettings.fancyGraphics;
+        float gamma = mc.gameSettings.gammaSetting;
+        mc.gameSettings.fancyGraphics = false;
+        mc.gameSettings.gammaSetting = 100000F;
+
+        GlStateManager.resetColor();
+        setColor(color);
+        renderOne(2);
+        modelBase.render(entity, p_77036_2_, p_77036_3_, p_77036_4_, p_77036_5_, p_77036_6_, scaleFactor);
+        setColor(color);
+        renderTwo();
+        modelBase.render(entity, p_77036_2_, p_77036_3_, p_77036_4_, p_77036_5_, p_77036_6_, scaleFactor);
+        setColor(color);
+        renderThree();
+        modelBase.render(entity, p_77036_2_, p_77036_3_, p_77036_4_, p_77036_5_, p_77036_6_, scaleFactor);
+        setColor(color);
+        renderFour(color);
+        modelBase.render(entity, p_77036_2_, p_77036_3_, p_77036_4_, p_77036_5_, p_77036_6_, scaleFactor);
+        setColor(color);
+        renderFive();
+        setColor(Color.WHITE);
+
+        mc.gameSettings.fancyGraphics = fancyGraphics;
+        mc.gameSettings.gammaSetting = gamma;
+    }
+
+    public static void outlineESP(RenderLivingEntityEvent event, Color color) {
+        Minecraft mc = Minecraft.getMinecraft();
+        boolean fancyGraphics = mc.gameSettings.fancyGraphics;
+        float gamma = mc.gameSettings.gammaSetting;
+        mc.gameSettings.fancyGraphics = false;
+        mc.gameSettings.gammaSetting = 100000F;
+
+        GlStateManager.resetColor();
+        setColor(color);
+        renderOne(2);
+        event.modelBase.render(event.entity, event.p_77036_2_, event.p_77036_3_, event.p_77036_4_, event.p_77036_5_, event.p_77036_6_, event.scaleFactor);
+        setColor(color);
+        renderTwo();
+        event.modelBase.render(event.entity, event.p_77036_2_, event.p_77036_3_, event.p_77036_4_, event.p_77036_5_, event.p_77036_6_, event.scaleFactor);
+        setColor(color);
+        renderThree();
+        event.modelBase.render(event.entity, event.p_77036_2_, event.p_77036_3_, event.p_77036_4_, event.p_77036_5_, event.p_77036_6_, event.scaleFactor);
+        setColor(color);
+        renderFour(color);
+        event.modelBase.render(event.entity, event.p_77036_2_, event.p_77036_3_, event.p_77036_4_, event.p_77036_5_, event.p_77036_6_, event.scaleFactor);
+        setColor(color);
+        renderFive();
+        setColor(Color.WHITE);
+
+        mc.gameSettings.fancyGraphics = fancyGraphics;
+        mc.gameSettings.gammaSetting = gamma;
+    }
+
+    public static void renderOne(final float lineWidth) {
+        checkSetupFBO();
+        glPushAttrib(GL_ALL_ATTRIB_BITS);
+        glDisable(GL_ALPHA_TEST);
+        glDisable(GL_TEXTURE_2D);
+        glDisable(GL_LIGHTING);
+        glEnable(GL_BLEND);
+        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+        glLineWidth(lineWidth);
+        glEnable(GL_LINE_SMOOTH);
+        glEnable(GL_STENCIL_TEST);
+        glClear(GL_STENCIL_BUFFER_BIT);
+        glClearStencil(0xF);
+        glStencilFunc(GL_NEVER, 1, 0xF);
+        glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);
+        glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
+    }
+
+    public static void renderTwo() {
+        glStencilFunc(GL_NEVER, 0, 0xF);
+        glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);
+        glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+    }
+
+    public static void renderThree() {
+        glStencilFunc(GL_EQUAL, 1, 0xF);
+        glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
+        glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
+    }
+
+    public static void renderFour(final Color color) {
+        setColor(color);
+        glDepthMask(false);
+        glDisable(GL_DEPTH_TEST);
+        glEnable(GL_POLYGON_OFFSET_LINE);
+        glPolygonOffset(1.0F, -2000000F);
+        OpenGlHelper.setLightmapTextureCoords(OpenGlHelper.lightmapTexUnit, 240.0F, 240.0F);
+    }
+
+    public static void renderFive() {
+        glPolygonOffset(1.0F, 2000000F);
+        glDisable(GL_POLYGON_OFFSET_LINE);
+        glEnable(GL_DEPTH_TEST);
+        glDepthMask(true);
+        glDisable(GL_STENCIL_TEST);
+        glDisable(GL_LINE_SMOOTH);
+        glHint(GL_LINE_SMOOTH_HINT, GL_DONT_CARE);
+        glEnable(GL_BLEND);
+        glEnable(GL_LIGHTING);
+        glEnable(GL_TEXTURE_2D);
+        glEnable(GL_ALPHA_TEST);
+        glPopAttrib();
+    }
+
+    public static void setColor(final Color color) {
+        glColor4d(color.getRed() / 255F, color.getGreen() / 255F, color.getBlue() / 255F, color.getAlpha() / 255F);
+    }
+
+    public static void checkSetupFBO() {
+        final Framebuffer fbo = Minecraft.getMinecraft().getFramebuffer();
+        if (fbo != null) {
+            if (fbo.depthBuffer > -1) {
+                setupFBO(fbo);
+                fbo.depthBuffer = -1;
+            }
+        }
+    }
+
+    private static void setupFBO(final Framebuffer fbo) {
+        EXTFramebufferObject.glDeleteRenderbuffersEXT(fbo.depthBuffer);
+        final int stencil_depth_buffer_ID = EXTFramebufferObject.glGenRenderbuffersEXT();
+        EXTFramebufferObject.glBindRenderbufferEXT(EXTFramebufferObject.GL_RENDERBUFFER_EXT, stencil_depth_buffer_ID);
+        EXTFramebufferObject.glRenderbufferStorageEXT(EXTFramebufferObject.GL_RENDERBUFFER_EXT, EXTPackedDepthStencil.GL_DEPTH_STENCIL_EXT, Minecraft.getMinecraft().displayWidth, Minecraft.getMinecraft().displayHeight);
+        EXTFramebufferObject.glFramebufferRenderbufferEXT(EXTFramebufferObject.GL_FRAMEBUFFER_EXT, EXTFramebufferObject.GL_STENCIL_ATTACHMENT_EXT, EXTFramebufferObject.GL_RENDERBUFFER_EXT, stencil_depth_buffer_ID);
+        EXTFramebufferObject.glFramebufferRenderbufferEXT(EXTFramebufferObject.GL_FRAMEBUFFER_EXT, EXTFramebufferObject.GL_DEPTH_ATTACHMENT_EXT, EXTFramebufferObject.GL_RENDERBUFFER_EXT, stencil_depth_buffer_ID);
+    }
+
+}
diff --git a/src/main/java/rosegoldaddons/utils/RenderUtils.java b/src/main/java/rosegoldaddons/utils/RenderUtils.java
new file mode 100644
index 0000000..5d3e2f2
--- /dev/null
+++ b/src/main/java/rosegoldaddons/utils/RenderUtils.java
@@ -0,0 +1,682 @@
+package rosegoldaddons.utils;
+
+import net.minecraft.block.Block;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.ScaledResolution;
+import net.minecraft.client.renderer.GlStateManager;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.client.renderer.WorldRenderer;
+import net.minecraft.client.renderer.entity.RenderManager;
+import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.util.AxisAlignedBB;
+import net.minecraft.util.BlockPos;
+import net.minecraft.util.ResourceLocation;
+import org.lwjgl.opengl.GL11;
+import org.lwjgl.opengl.GL14;
+
+import java.awt.*;
+import java.util.HashMap;
+import java.util.Map;
+
+import static java.lang.Math.*;
+import static org.lwjgl.opengl.GL11.*;
+
+public class RenderUtils {
+
+    private static final Map<Integer, Boolean> glCapMap = new HashMap<>();
+    private static final int[] DISPLAY_LISTS_2D = new int[4];
+    private static final Minecraft mc = Minecraft.getMinecraft();
+
+    static {
+        for (int i = 0; i < DISPLAY_LISTS_2D.length; i++) {
+            DISPLAY_LISTS_2D[i] = glGenLists(1);
+        }
+
+        glNewList(DISPLAY_LISTS_2D[0], GL_COMPILE);
+
+        quickDrawRect(-7F, 2F, -4F, 3F);
+        quickDrawRect(4F, 2F, 7F, 3F);
+        quickDrawRect(-7F, 0.5F, -6F, 3F);
+        quickDrawRect(6F, 0.5F, 7F, 3F);
+
+        glEndList();
+
+        glNewList(DISPLAY_LISTS_2D[1], GL_COMPILE);
+
+        quickDrawRect(-7F, 3F, -4F, 3.3F);
+        quickDrawRect(4F, 3F, 7F, 3.3F);
+        quickDrawRect(-7.3F, 0.5F, -7F, 3.3F);
+        quickDrawRect(7F, 0.5F, 7.3F, 3.3F);
+
+        glEndList();
+
+        glNewList(DISPLAY_LISTS_2D[2], GL_COMPILE);
+
+        quickDrawRect(4F, -20F, 7F, -19F);
+        quickDrawRect(-7F, -20F, -4F, -19F);
+        quickDrawRect(6F, -20F, 7F, -17.5F);
+        quickDrawRect(-7F, -20F, -6F, -17.5F);
+
+        glEndList();
+
+        glNewList(DISPLAY_LISTS_2D[3], GL_COMPILE);
+
+        quickDrawRect(7F, -20F, 7.3F, -17.5F);
+        quickDrawRect(-7.3F, -20F, -7F, -17.5F);
+        quickDrawRect(4F, -20.3F, 7.3F, -20F);
+        quickDrawRect(-7.3F, -20.3F, -4F, -20F);
+
+        glEndList();
+    }
+
+    public static void drawBlockBox(final BlockPos blockPos, final Color color, final boolean outline, float partialTicks) {
+        final RenderManager renderManager = mc.getRenderManager();
+
+        final double x = blockPos.getX() - renderManager.viewerPosX;
+        final double y = blockPos.getY() - renderManager.viewerPosY;
+        final double z = blockPos.getZ() - renderManager.viewerPosZ;
+
+        AxisAlignedBB axisAlignedBB = new AxisAlignedBB(x, y, z, x + 1.0, y + 1.0, z + 1.0);
+        final Block block = mc.theWorld.getBlockState(blockPos).getBlock();
+
+        if (block != null) {
+            final EntityPlayer player = mc.thePlayer;
+
+            final double posX = player.lastTickPosX + (player.posX - player.lastTickPosX) * partialTicks;
+            final double posY = player.lastTickPosY + (player.posY - player.lastTickPosY) * partialTicks;
+            final double posZ = player.lastTickPosZ + (player.posZ - player.lastTickPosZ) * partialTicks;
+
+            block.setBlockBoundsBasedOnState(mc.theWorld, blockPos);
+
+            axisAlignedBB = block.getSelectedBoundingBox(mc.theWorld, blockPos)
+                    .expand(0.0020000000949949026D, 0.0020000000949949026D, 0.0020000000949949026D)
+                    .offset(-posX, -posY, -posZ);
+        }
+
+        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+        enableGlCap(GL_BLEND);
+        disableGlCap(GL_TEXTURE_2D, GL_DEPTH_TEST);
+        glDepthMask(false);
+
+        glColor(color.getRed(), color.getGreen(), color.getBlue(), color.getAlpha() != 255 ? color.getAlpha() : outline ? 26 : 35);
+        drawFilledBox(axisAlignedBB);
+
+        if (outline) {
+            glLineWidth(1F);
+            enableGlCap(GL_LINE_SMOOTH);
+            glColor(color);
+
+            drawSelectionBoundingBox(axisAlignedBB);
+        }
+
+        GL11.glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
+        glDepthMask(true);
+        resetCaps();
+    }
+
+    public static void drawSelectionBoundingBox(AxisAlignedBB boundingBox) {
+        Tessellator tessellator = Tessellator.getInstance();
+        WorldRenderer worldrenderer = tessellator.getWorldRenderer();
+
+        worldrenderer.begin(GL_LINE_STRIP, DefaultVertexFormats.POSITION);
+
+        // Lower Rectangle
+        worldrenderer.pos(boundingBox.minX, boundingBox.minY, boundingBox.minZ).endVertex();
+        worldrenderer.pos(boundingBox.minX, boundingBox.minY, boundingBox.maxZ).endVertex();
+        worldrenderer.pos(boundingBox.maxX, boundingBox.minY, boundingBox.maxZ).endVertex();
+        worldrenderer.pos(boundingBox.maxX, boundingBox.minY, boundingBox.minZ).endVertex();
+        worldrenderer.pos(boundingBox.minX, boundingBox.minY, boundingBox.minZ).endVertex();
+
+        // Upper Rectangle
+        worldrenderer.pos(boundingBox.minX, boundingBox.maxY, boundingBox.minZ).endVertex();
+        worldrenderer.pos(boundingBox.minX, boundingBox.maxY, boundingBox.maxZ).endVertex();
+        worldrenderer.pos(boundingBox.maxX, boundingBox.maxY, boundingBox.maxZ).endVertex();
+        worldrenderer.pos(boundingBox.maxX, boundingBox.maxY, boundingBox.minZ).endVertex();
+        worldrenderer.pos(boundingBox.minX, boundingBox.maxY, boundingBox.minZ).endVertex();
+
+        // Upper Rectangle
+        worldrenderer.pos(boundingBox.minX, boundingBox.maxY, boundingBox.maxZ).endVertex();
+        worldrenderer.pos(boundingBox.minX, boundingBox.minY, boundingBox.maxZ).endVertex();
+
+        worldrenderer.pos(boundingBox.maxX, boundingBox.minY, boundingBox.maxZ).endVertex();
+        worldrenderer.pos(boundingBox.maxX, boundingBox.maxY, boundingBox.maxZ).endVertex();
+
+        worldrenderer.pos(boundingBox.maxX, boundingBox.maxY, boundingBox.minZ).endVertex();
+        worldrenderer.pos(boundingBox.maxX, boundingBox.minY, boundingBox.minZ).endVertex();
+
+        tessellator.draw();
+    }
+
+    public static void drawEntityBox(final Entity entity, final Color color, final boolean outline, float partialTicks) {
+        final RenderManager renderManager = mc.getRenderManager();
+
+        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+        enableGlCap(GL_BLEND);
+        disableGlCap(GL_TEXTURE_2D, GL_DEPTH_TEST);
+        glDepthMask(false);
+
+        final double x = entity.lastTickPosX + (entity.posX - entity.lastTickPosX) * partialTicks
+                - renderManager.viewerPosX;
+        final double y = entity.lastTickPosY + (entity.posY - entity.lastTickPosY) * partialTicks
+                - renderManager.viewerPosY;
+        final double z = entity.lastTickPosZ + (entity.posZ - entity.lastTickPosZ) * partialTicks
+                - renderManager.viewerPosZ;
+
+        final AxisAlignedBB entityBox = entity.getEntityBoundingBox();
+        final AxisAlignedBB axisAlignedBB = new AxisAlignedBB(
+                entityBox.minX - entity.posX + x - 0.05D,
+                entityBox.minY - entity.posY + y,
+                entityBox.minZ - entity.posZ + z - 0.05D,
+                entityBox.maxX - entity.posX + x + 0.05D,
+                entityBox.maxY - entity.posY + y + 0.15D,
+                entityBox.maxZ - entity.posZ + z + 0.05D
+        );
+
+        if (outline) {
+            glLineWidth(1F);
+            enableGlCap(GL_LINE_SMOOTH);
+            glColor(color.getRed(), color.getGreen(), color.getBlue(), 95);
+            drawSelectionBoundingBox(axisAlignedBB);
+        }
+
+        glColor(color.getRed(), color.getGreen(), color.getBlue(), outline ? 26 : 35);
+        drawFilledBox(axisAlignedBB);
+        glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
+        glDepthMask(true);
+        resetCaps();
+    }
+
+    public static void drawAxisAlignedBB(final AxisAlignedBB axisAlignedBB, final Color color) {
+        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+        glEnable(GL_BLEND);
+        glLineWidth(2F);
+        glDisable(GL_TEXTURE_2D);
+        glDisable(GL_DEPTH_TEST);
+        glDepthMask(false);
+        glColor(color);
+        drawFilledBox(axisAlignedBB);
+        glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
+        glEnable(GL_TEXTURE_2D);
+        glEnable(GL_DEPTH_TEST);
+        glDepthMask(true);
+        glDisable(GL_BLEND);
+    }
+
+    public static void drawPlatform(final double y, final Color color, final double size) {
+        final RenderManager renderManager = mc.getRenderManager();
+        final double renderY = y - renderManager.viewerPosY;
+
+        drawAxisAlignedBB(new AxisAlignedBB(size, renderY + 0.02D, size, -size, renderY, -size), color);
+    }
+
+    public static void drawPlatform(final Entity entity, final Color color, float partialTicks) {
+        final RenderManager renderManager = mc.getRenderManager();
+
+        final double x = entity.lastTickPosX + (entity.posX - entity.lastTickPosX) * partialTicks
+                - renderManager.viewerPosX;
+        final double y = entity.lastTickPosY + (entity.posY - entity.lastTickPosY) * partialTicks
+                - renderManager.viewerPosY;
+        final double z = entity.lastTickPosZ + (entity.posZ - entity.lastTickPosZ) * partialTicks
+                - renderManager.viewerPosZ;
+
+        final AxisAlignedBB axisAlignedBB = entity.getEntityBoundingBox()
+                .offset(-entity.posX, -entity.posY, -entity.posZ)
+                .offset(x, y, z);
+
+        drawAxisAlignedBB(
+                new AxisAlignedBB(axisAlignedBB.minX, axisAlignedBB.maxY + 0.2, axisAlignedBB.minZ, axisAlignedBB.maxX, axisAlignedBB.maxY + 0.26, axisAlignedBB.maxZ),
+                color
+        );
+    }
+
+    public static void drawFilledBox(final AxisAlignedBB axisAlignedBB) {
+        final Tessellator tessellator = Tessellator.getInstance();
+        final WorldRenderer worldRenderer = tessellator.getWorldRenderer();
+
+        worldRenderer.begin(7, DefaultVertexFormats.POSITION);
+
+        worldRenderer.pos(axisAlignedBB.minX, axisAlignedBB.minY, axisAlignedBB.minZ).endVertex();
+        worldRenderer.pos(axisAlignedBB.minX, axisAlignedBB.maxY, axisAlignedBB.minZ).endVertex();
+        worldRenderer.pos(axisAlignedBB.maxX, axisAlignedBB.minY, axisAlignedBB.minZ).endVertex();
+        worldRenderer.pos(axisAlignedBB.maxX, axisAlignedBB.maxY, axisAlignedBB.minZ).endVertex();
+        worldRenderer.pos(axisAlignedBB.maxX, axisAlignedBB.minY, axisAlignedBB.maxZ).endVertex();
+        worldRenderer.pos(axisAlignedBB.maxX, axisAlignedBB.maxY, axisAlignedBB.maxZ).endVertex();
+        worldRenderer.pos(axisAlignedBB.minX, axisAlignedBB.minY, axisAlignedBB.maxZ).endVertex();
+        worldRenderer.pos(axisAlignedBB.minX, axisAlignedBB.maxY, axisAlignedBB.maxZ).endVertex();
+
+        worldRenderer.pos(axisAlignedBB.maxX, axisAlignedBB.maxY, axisAlignedBB.minZ).endVertex();
+        worldRenderer.pos(axisAlignedBB.maxX, axisAlignedBB.minY, axisAlignedBB.minZ).endVertex();
+        worldRenderer.pos(axisAlignedBB.minX, axisAlignedBB.maxY, axisAlignedBB.minZ).endVertex();
+        worldRenderer.pos(axisAlignedBB.minX, axisAlignedBB.minY, axisAlignedBB.minZ).endVertex();
+        worldRenderer.pos(axisAlignedBB.minX, axisAlignedBB.maxY, axisAlignedBB.maxZ).endVertex();
+        worldRenderer.pos(axisAlignedBB.minX, axisAlignedBB.minY, axisAlignedBB.maxZ).endVertex();
+        worldRenderer.pos(axisAlignedBB.maxX, axisAlignedBB.maxY, axisAlignedBB.maxZ).endVertex();
+        worldRenderer.pos(axisAlignedBB.maxX, axisAlignedBB.minY, axisAlignedBB.maxZ).endVertex();
+
+        worldRenderer.pos(axisAlignedBB.minX, axisAlignedBB.maxY, axisAlignedBB.minZ).endVertex();
+        worldRenderer.pos(axisAlignedBB.maxX, axisAlignedBB.maxY, axisAlignedBB.minZ).endVertex();
+        worldRenderer.pos(axisAlignedBB.maxX, axisAlignedBB.maxY, axisAlignedBB.maxZ).endVertex();
+        worldRenderer.pos(axisAlignedBB.minX, axisAlignedBB.maxY, axisAlignedBB.maxZ).endVertex();
+        worldRenderer.pos(axisAlignedBB.minX, axisAlignedBB.maxY, axisAlignedBB.minZ).endVertex();
+        worldRenderer.pos(axisAlignedBB.minX, axisAlignedBB.maxY, axisAlignedBB.maxZ).endVertex();
+        worldRenderer.pos(axisAlignedBB.maxX, axisAlignedBB.maxY, axisAlignedBB.maxZ).endVertex();
+        worldRenderer.pos(axisAlignedBB.maxX, axisAlignedBB.maxY, axisAlignedBB.minZ).endVertex();
+
+        worldRenderer.pos(axisAlignedBB.minX, axisAlignedBB.minY, axisAlignedBB.minZ).endVertex();
+        worldRenderer.pos(axisAlignedBB.maxX, axisAlignedBB.minY, axisAlignedBB.minZ).endVertex();
+        worldRenderer.pos(axisAlignedBB.maxX, axisAlignedBB.minY, axisAlignedBB.maxZ).endVertex();
+        worldRenderer.pos(axisAlignedBB.minX, axisAlignedBB.minY, axisAlignedBB.maxZ).endVertex();
+        worldRenderer.pos(axisAlignedBB.minX, axisAlignedBB.minY, axisAlignedBB.minZ).endVertex();
+        worldRenderer.pos(axisAlignedBB.minX, axisAlignedBB.minY, axisAlignedBB.maxZ).endVertex();
+        worldRenderer.pos(axisAlignedBB.maxX, axisAlignedBB.minY, axisAlignedBB.maxZ).endVertex();
+        worldRenderer.pos(axisAlignedBB.maxX, axisAlignedBB.minY, axisAlignedBB.minZ).endVertex();
+
+        worldRenderer.pos(axisAlignedBB.minX, axisAlignedBB.minY, axisAlignedBB.minZ).endVertex();
+        worldRenderer.pos(axisAlignedBB.minX, axisAlignedBB.maxY, axisAlignedBB.minZ).endVertex();
+        worldRenderer.pos(axisAlignedBB.minX, axisAlignedBB.minY, axisAlignedBB.maxZ).endVertex();
+        worldRenderer.pos(axisAlignedBB.minX, axisAlignedBB.maxY, axisAlignedBB.maxZ).endVertex();
+        worldRenderer.pos(axisAlignedBB.maxX, axisAlignedBB.minY, axisAlignedBB.maxZ).endVertex();
+        worldRenderer.pos(axisAlignedBB.maxX, axisAlignedBB.maxY, axisAlignedBB.maxZ).endVertex();
+        worldRenderer.pos(axisAlignedBB.maxX, axisAlignedBB.minY, axisAlignedBB.minZ).endVertex();
+        worldRenderer.pos(axisAlignedBB.maxX, axisAlignedBB.maxY, axisAlignedBB.minZ).endVertex();
+
+        worldRenderer.pos(axisAlignedBB.minX, axisAlignedBB.maxY, axisAlignedBB.maxZ).endVertex();
+        worldRenderer.pos(axisAlignedBB.minX, axisAlignedBB.minY, axisAlignedBB.maxZ).endVertex();
+        worldRenderer.pos(axisAlignedBB.minX, axisAlignedBB.maxY, axisAlignedBB.minZ).endVertex();
+        worldRenderer.pos(axisAlignedBB.minX, axisAlignedBB.minY, axisAlignedBB.minZ).endVertex();
+        worldRenderer.pos(axisAlignedBB.maxX, axisAlignedBB.maxY, axisAlignedBB.minZ).endVertex();
+        worldRenderer.pos(axisAlignedBB.maxX, axisAlignedBB.minY, axisAlignedBB.minZ).endVertex();
+        worldRenderer.pos(axisAlignedBB.maxX, axisAlignedBB.maxY, axisAlignedBB.maxZ).endVertex();
+        worldRenderer.pos(axisAlignedBB.maxX, axisAlignedBB.minY, axisAlignedBB.maxZ).endVertex();
+        tessellator.draw();
+    }
+
+    public static void quickDrawRect(final float x, final float y, final float x2, final float y2) {
+        glBegin(GL_QUADS);
+
+        glVertex2d(x2, y);
+        glVertex2d(x, y);
+        glVertex2d(x, y2);
+        glVertex2d(x2, y2);
+
+        glEnd();
+    }
+
+    public static void drawRect(final float x, final float y, final float x2, final float y2, final int color) {
+        glEnable(GL_BLEND);
+        glDisable(GL_TEXTURE_2D);
+        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+        glEnable(GL_LINE_SMOOTH);
+
+        glColor(color);
+        glBegin(GL_QUADS);
+
+        glVertex2f(x2, y);
+        glVertex2f(x, y);
+        glVertex2f(x, y2);
+        glVertex2f(x2, y2);
+        glEnd();
+
+        glEnable(GL_TEXTURE_2D);
+        glDisable(GL_BLEND);
+        glDisable(GL_LINE_SMOOTH);
+    }
+
+    public static void drawRect(final int x, final int y, final int x2, final int y2, final int color) {
+        glEnable(GL_BLEND);
+        glDisable(GL_TEXTURE_2D);
+        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+        glEnable(GL_LINE_SMOOTH);
+
+        glColor(color);
+        glBegin(GL_QUADS);
+
+        glVertex2i(x2, y);
+        glVertex2i(x, y);
+        glVertex2i(x, y2);
+        glVertex2i(x2, y2);
+        glEnd();
+
+        glEnable(GL_TEXTURE_2D);
+        glDisable(GL_BLEND);
+        glDisable(GL_LINE_SMOOTH);
+    }
+
+    /**
+     * Like {@link #drawRect(float, float, float, float, int)}, but without setup
+     */
+    public static void quickDrawRect(final float x, final float y, final float x2, final float y2, final int color) {
+        glColor(color);
+        glBegin(GL_QUADS);
+
+        glVertex2d(x2, y);
+        glVertex2d(x, y);
+        glVertex2d(x, y2);
+        glVertex2d(x2, y2);
+
+        glEnd();
+    }
+
+    public static void drawRect(final float x, final float y, final float x2, final float y2, final Color color) {
+        drawRect(x, y, x2, y2, color.getRGB());
+    }
+
+    public static void drawBorderedRect(final float x, final float y, final float x2, final float y2, final float width,
+                                        final int color1, final int color2) {
+        drawRect(x, y, x2, y2, color2);
+        drawBorder(x, y, x2, y2, width, color1);
+    }
+
+    public static void drawBorder(float x, float y, float x2, float y2, float width, int color1) {
+        glEnable(GL_BLEND);
+        glDisable(GL_TEXTURE_2D);
+        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+        glEnable(GL_LINE_SMOOTH);
+
+        glColor(color1);
+        glLineWidth(width);
+
+        glBegin(GL_LINE_LOOP);
+
+        glVertex2d(x2, y);
+        glVertex2d(x, y);
+        glVertex2d(x, y2);
+        glVertex2d(x2, y2);
+
+        glEnd();
+
+        glEnable(GL_TEXTURE_2D);
+        glDisable(GL_BLEND);
+        glDisable(GL_LINE_SMOOTH);
+    }
+
+    public static void quickDrawBorderedRect(final float x, final float y, final float x2, final float y2, final float width, final int color1, final int color2) {
+        quickDrawRect(x, y, x2, y2, color2);
+
+        glColor(color1);
+        glLineWidth(width);
+
+        glBegin(GL_LINE_LOOP);
+
+        glVertex2d(x2, y);
+        glVertex2d(x, y);
+        glVertex2d(x, y2);
+        glVertex2d(x2, y2);
+
+        glEnd();
+    }
+
+    public static void drawLoadingCircle(float x, float y) {
+        for (int i = 0; i < 4; i++) {
+            int rot = (int) ((System.nanoTime() / 5000000 * i) % 360);
+            drawCircle(x, y, i * 10, rot - 180, rot);
+        }
+    }
+
+    public static void drawCircle(float x, float y, float radius, int start, int end) {
+        GlStateManager.enableBlend();
+        GlStateManager.disableTexture2D();
+        GlStateManager.tryBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ZERO);
+        glColor(Color.WHITE);
+
+        glEnable(GL_LINE_SMOOTH);
+        glLineWidth(2F);
+        glBegin(GL_LINE_STRIP);
+        for (float i = end; i >= start; i -= (360 / 90.0f)) {
+            glVertex2f((float) (x + (cos(i * PI / 180) * (radius * 1.001F))), (float) (y + (sin(i * PI / 180) * (radius * 1.001F))));
+        }
+        glEnd();
+        glDisable(GL_LINE_SMOOTH);
+
+        GlStateManager.enableTexture2D();
+        GlStateManager.disableBlend();
+    }
+
+    public static void drawFilledCircle(final int xx, final int yy, final float radius, final Color color) {
+        int sections = 50;
+        double dAngle = 2 * Math.PI / sections;
+        float x, y;
+
+        glPushAttrib(GL_ENABLE_BIT);
+
+        glEnable(GL_BLEND);
+        glDisable(GL_TEXTURE_2D);
+        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+        glEnable(GL_LINE_SMOOTH);
+        glBegin(GL_TRIANGLE_FAN);
+
+        for (int i = 0; i < sections; i++) {
+            x = (float) (radius * Math.sin((i * dAngle)));
+            y = (float) (radius * Math.cos((i * dAngle)));
+
+            glColor4f(color.getRed() / 255F, color.getGreen() / 255F, color.getBlue() / 255F, color.getAlpha() / 255F);
+            glVertex2f(xx + x, yy + y);
+        }
+
+        glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
+
+        glEnd();
+
+        glPopAttrib();
+    }
+
+    public static void drawImage(ResourceLocation image, int x, int y, int width, int height) {
+        glDisable(GL_DEPTH_TEST);
+        glEnable(GL_BLEND);
+        glDepthMask(false);
+        GL14.glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ZERO);
+        glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
+        mc.getTextureManager().bindTexture(image);
+        drawModalRectWithCustomSizedTexture(x, y, 0, 0, width, height, width, height);
+        glDepthMask(true);
+        glDisable(GL_BLEND);
+        glEnable(GL_DEPTH_TEST);
+    }
+
+    /**
+     * Draws a textured rectangle at z = 0. Args: x, y, u, v, width, height, textureWidth, textureHeight
+     */
+    public static void drawModalRectWithCustomSizedTexture(float x, float y, float u, float v, float width, float height, float textureWidth, float textureHeight) {
+        float f = 1.0F / textureWidth;
+        float f1 = 1.0F / textureHeight;
+        Tessellator tessellator = Tessellator.getInstance();
+        WorldRenderer worldrenderer = tessellator.getWorldRenderer();
+        worldrenderer.begin(7, DefaultVertexFormats.POSITION);
+        worldrenderer.pos(x, y + height, 0.0D).tex(u * f, (v + height) * f1).endVertex();
+        worldrenderer.pos(x + width, y + height, 0.0D).tex((u + width) * f, (v + height) * f1).endVertex();
+        worldrenderer.pos(x + width, y, 0.0D).tex((u + width) * f, v * f1).endVertex();
+        worldrenderer.pos(x, y, 0.0D).tex(u * f, v * f1).endVertex();
+        tessellator.draw();
+    }
+
+    public static void glColor(final int red, final int green, final int blue, final int alpha) {
+        GL11.glColor4f(red / 255F, green / 255F, blue / 255F, alpha / 255F);
+    }
+
+    public static void glColor(final Color color) {
+        glColor(color.getRed(), color.getGreen(), color.getBlue(), color.getAlpha());
+    }
+
+    private static void glColor(final int hex) {
+        glColor(hex >> 16 & 0xFF, hex >> 8 & 0xFF, hex & 0xFF, hex >> 24 & 0xFF);
+    }
+
+    public static void draw2D(final EntityLivingBase entity, final double posX, final double posY, final double posZ, final int color, final int backgroundColor) {
+        GL11.glPushMatrix();
+        GL11.glTranslated(posX, posY, posZ);
+        GL11.glRotated(-mc.getRenderManager().viewerPosY, 0F, 1F, 0F);
+        GL11.glScaled(-0.1D, -0.1D, 0.1D);
+
+        glDisable(GL_DEPTH_TEST);
+        glEnable(GL_BLEND);
+        glDisable(GL_TEXTURE_2D);
+        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+        GL11.glDepthMask(true);
+
+        glColor(color);
+
+        glCallList(DISPLAY_LISTS_2D[0]);
+
+        glColor(backgroundColor);
+
+        glCallList(DISPLAY_LISTS_2D[1]);
+
+        GL11.glTranslated(0, 21 + -(entity.getEntityBoundingBox().maxY - entity.getEntityBoundingBox().minY) * 12, 0);
+
+        glColor(color);
+        glCallList(DISPLAY_LISTS_2D[2]);
+
+        glColor(backgroundColor);
+        glCallList(DISPLAY_LISTS_2D[3]);
+
+        // Stop render
+        glEnable(GL_DEPTH_TEST);
+        glEnable(GL_TEXTURE_2D);
+        glDisable(GL_BLEND);
+
+        GL11.glPopMatrix();
+    }
+
+    public static void draw2D(final BlockPos blockPos, final int color, final int backgroundColor) {
+        final RenderManager renderManager = mc.getRenderManager();
+
+        final double posX = (blockPos.getX() + 0.5) - renderManager.viewerPosX;
+        final double posY = blockPos.getY() - renderManager.viewerPosY;
+        final double posZ = (blockPos.getZ() + 0.5) - renderManager.viewerPosZ;
+
+        GL11.glPushMatrix();
+        GL11.glTranslated(posX, posY, posZ);
+        GL11.glRotated(-mc.getRenderManager().playerViewY, 0F, 1F, 0F);
+        GL11.glScaled(-0.1D, -0.1D, 0.1D);
+
+        glDisable(GL_DEPTH_TEST);
+        glEnable(GL_BLEND);
+        glDisable(GL_TEXTURE_2D);
+        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+        GL11.glDepthMask(true);
+
+        glColor(color);
+
+        glCallList(DISPLAY_LISTS_2D[0]);
+
+        glColor(backgroundColor);
+
+        glCallList(DISPLAY_LISTS_2D[1]);
+
+        GL11.glTranslated(0, 9, 0);
+
+        glColor(color);
+
+        glCallList(DISPLAY_LISTS_2D[2]);
+
+        glColor(backgroundColor);
+
+        glCallList(DISPLAY_LISTS_2D[3]);
+
+        // Stop render
+        glEnable(GL_DEPTH_TEST);
+        glEnable(GL_TEXTURE_2D);
+        glDisable(GL_BLEND);
+
+        GL11.glPopMatrix();
+    }
+
+    public static void renderNameTag(final String string, final double x, final double y, final double z) {
+        final RenderManager renderManager = mc.getRenderManager();
+
+        glPushMatrix();
+        glTranslated(x - renderManager.viewerPosX, y - renderManager.viewerPosY, z - renderManager.viewerPosZ);
+        glNormal3f(0F, 1F, 0F);
+        glRotatef(-mc.getRenderManager().playerViewY, 0F, 1F, 0F);
+        glRotatef(mc.getRenderManager().playerViewX, 1F, 0F, 0F);
+        glScalef(-0.05F, -0.05F, 0.05F);
+        setGlCap(GL_LIGHTING, false);
+        setGlCap(GL_DEPTH_TEST, false);
+        setGlCap(GL_BLEND, true);
+        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+        final int width = mc.fontRendererObj.getStringWidth(string) / 2;
+
+        drawRect(-width - 1, -1, width + 1, mc.fontRendererObj.FONT_HEIGHT, Integer.MIN_VALUE);
+        mc.fontRendererObj.drawString(string, -width, 1.5F, Color.WHITE.getRGB(), true);
+
+        resetCaps();
+        glColor4f(1F, 1F, 1F, 1F);
+        glPopMatrix();
+    }
+
+    public static void drawLine(final double x, final double y, final double x1, final double y1, final float width) {
+        glDisable(GL_TEXTURE_2D);
+        glLineWidth(width);
+        glBegin(GL_LINES);
+        glVertex2d(x, y);
+        glVertex2d(x1, y1);
+        glEnd();
+        glEnable(GL_TEXTURE_2D);
+    }
+
+    public static void makeScissorBox(final float x, final float y, final float x2, final float y2) {
+        final ScaledResolution scaledResolution = new ScaledResolution(mc);
+        final int factor = scaledResolution.getScaleFactor();
+        glScissor((int) (x * factor), (int) ((scaledResolution.getScaledHeight() - y2) * factor), (int) ((x2 - x) * factor), (int) ((y2 - y) * factor));
+    }
+
+    /**
+     * GL CAP MANAGER
+     * <p>
+     * TODO: Remove gl cap manager and replace by something better
+     */
+
+    public static void resetCaps() {
+        glCapMap.forEach(RenderUtils::setGlState);
+    }
+
+    public static void enableGlCap(final int cap) {
+        setGlCap(cap, true);
+    }
+
+    public static void enableGlCap(final int... caps) {
+        for (final int cap : caps)
+            setGlCap(cap, true);
+    }
+
+    public static void disableGlCap(final int cap) {
+        setGlCap(cap, true);
+    }
+
+    public static void disableGlCap(final int... caps) {
+        for (final int cap : caps)
+            setGlCap(cap, false);
+    }
+
+    public static void setGlCap(final int cap, final boolean state) {
+        glCapMap.put(cap, glGetBoolean(cap));
+        setGlState(cap, state);
+    }
+
+    public static void setGlState(final int cap, final boolean state) {
+        if (state)
+            glEnable(cap);
+        else
+            glDisable(cap);
+    }
+
+    public static void drawScaledCustomSizeModalRect(int x, int y, float u, float v, int uWidth, int vHeight, int width, int height, float tileWidth, float tileHeight) {
+        float f = 1.0F / tileWidth;
+        float f1 = 1.0F / tileHeight;
+        Tessellator tessellator = Tessellator.getInstance();
+        WorldRenderer worldrenderer = tessellator.getWorldRenderer();
+        worldrenderer.begin(7, DefaultVertexFormats.POSITION);
+        worldrenderer.pos(x, y + height, 0.0D).tex(u * f, (v + (float) vHeight) * f1).endVertex();
+        worldrenderer.pos(x + width, y + height, 0.0D).tex((u + (float) uWidth) * f, (v + (float) vHeight) * f1).endVertex();
+        worldrenderer.pos(x + width, y, 0.0D).tex((u + (float) uWidth) * f, v * f1).endVertex();
+        worldrenderer.pos(x, y, 0.0D).tex(u * f, v * f1).endVertex();
+        tessellator.draw();
+    }
+
+}
\ No newline at end of file
diff --git a/src/main/java/rosegoldaddons/utils/RotationUtils.java b/src/main/java/rosegoldaddons/utils/RotationUtils.java
new file mode 100644
index 0000000..fb4152a
--- /dev/null
+++ b/src/main/java/rosegoldaddons/utils/RotationUtils.java
@@ -0,0 +1,110 @@
+package rosegoldaddons.utils;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.settings.KeyBinding;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.monster.EntityCreeper;
+import net.minecraft.util.ChatComponentText;
+import net.minecraft.util.MathHelper;
+import net.minecraft.util.Vec3;
+import rosegoldaddons.Main;
+
+import java.security.Key;
+
+public class RotationUtils {
+    static boolean working = false;
+    static boolean snek = false;
+    static boolean antiafking = false;
+
+    public static void antiAfk() {
+        if(snek || Minecraft.getMinecraft().currentScreen != null) return;
+        KeyBinding right = Minecraft.getMinecraft().gameSettings.keyBindRight;
+        KeyBinding left = Minecraft.getMinecraft().gameSettings.keyBindLeft;
+        new Thread(() -> {
+            try {
+                KeyBinding.setKeyBindState(right.getKeyCode(), true);
+                Thread.sleep(50);
+                KeyBinding.setKeyBindState(right.getKeyCode(), false);
+                Thread.sleep(200);
+                KeyBinding.setKeyBindState(left.getKeyCode(), true);
+                Thread.sleep(50);
+                KeyBinding.setKeyBindState(left.getKeyCode(), false);
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }).start();
+    }
+
+    public static void shootEman() {
+        if(snek || Minecraft.getMinecraft().currentScreen != null) return;
+        new Thread(() -> {
+            try {
+                snek = true;
+                KeyBinding.setKeyBindState(Minecraft.getMinecraft().gameSettings.keyBindSneak.getKeyCode(), true);
+                Thread.sleep(100);
+                KeyBinding.setKeyBindState(Minecraft.getMinecraft().gameSettings.keyBindSneak.getKeyCode(), false);
+                Thread.sleep(100);
+                KeyBinding.setKeyBindState(Minecraft.getMinecraft().gameSettings.keyBindSneak.getKeyCode(), true);
+                Thread.sleep(100);
+                KeyBinding.setKeyBindState(Minecraft.getMinecraft().gameSettings.keyBindSneak.getKeyCode(), false);
+                snek = false;
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }).start();
+    }
+
+    public static void facePos(Vec3 vector) {
+        if(working || Minecraft.getMinecraft().currentScreen != null) return;
+        new Thread(() -> {
+            try {
+                working = true;
+                double diffX = vector.xCoord - (Minecraft.getMinecraft()).thePlayer.posX;
+                double diffY = vector.yCoord - (Minecraft.getMinecraft()).thePlayer.posY;
+                double diffZ = vector.zCoord - (Minecraft.getMinecraft()).thePlayer.posZ;
+                double dist = Math.sqrt(diffX * diffX + diffZ * diffZ);
+
+                float pitch = (float) -Math.atan2(dist, diffY);
+                float yaw = (float) Math.atan2(diffZ, diffX);
+                pitch = (float) wrapAngleTo180((pitch * 180F / Math.PI + 90)*-1 - Minecraft.getMinecraft().thePlayer.rotationPitch);
+                yaw = (float) wrapAngleTo180((yaw * 180 / Math.PI) - 90 - Minecraft.getMinecraft().thePlayer.rotationYaw);
+
+                for(int i = 0; i < Main.configFile.smoothLookVelocity; i++) {
+                    Minecraft.getMinecraft().thePlayer.rotationYaw += yaw/Main.configFile.smoothLookVelocity;
+                    Minecraft.getMinecraft().thePlayer.rotationPitch += pitch/Main.configFile.smoothLookVelocity;
+                    Thread.sleep(1);
+                }
+                working = false;
+                if(Main.endermanMacro) {
+                    shootEman();
+                }
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }).start();
+    }
+
+    public static void faceEntity(Entity en) {
+        if(en instanceof EntityCreeper) {
+            facePos(new Vec3(en.posX, en.posY-1.5, en.posZ));
+        } else {
+            facePos(new Vec3(en.posX, en.posY, en.posZ));
+        }
+    }
+
+    public static void faceEntity2(Entity en) {
+        facePos(new Vec3(en.posX, en.posY + en.getEyeHeight() - en.height / 1.5D, en.posZ));
+    }
+
+    private static double wrapAngleTo180(double angle) {
+        angle %= 360;
+        while (angle >= 180) {
+            angle -= 360;
+        }
+        while (angle < -180) {
+            angle += 360;
+        }
+        return angle;
+    }
+
+}
diff --git a/src/main/resources/mcmod.info b/src/main/resources/mcmod.info
new file mode 100644
index 0000000..bce7aad
--- /dev/null
+++ b/src/main/resources/mcmod.info
@@ -0,0 +1,18 @@
+[
+  {
+    "modid": "RoseGoldAddons",
+    "name": "RoseGold Addons",
+    "description": "RoseGold's QOL Modifications",
+    "version": "${version}",
+    "mcversion": "${mcversion}",
+    "url": "",
+    "updateUrl": "",
+    "authorList": [
+      ""
+    ],
+    "credits": "",
+    "logoFile": "",
+    "screenshots": [],
+    "dependencies": []
+  }
+]
diff --git a/src/main/resources/mixins.rosegoldaddons.json b/src/main/resources/mixins.rosegoldaddons.json
new file mode 100644
index 0000000..b58372e
--- /dev/null
+++ b/src/main/resources/mixins.rosegoldaddons.json
@@ -0,0 +1,12 @@
+{
+  "minVersion": "0.6",
+  "compatibilityLevel": "JAVA_8",
+  "package": "rosegoldaddons.mixins",
+  "refmap": "mixins.rosegoldaddons.refmap.json",
+  "mixins": [
+    "MixinNetworkManager"
+  ],
+  "client": [
+    "MixinRendererLivingEntity"
+  ]
+}