Input:
import java.lang.reflect.Method;
import java.util.Iterator;
import enviromine.client.gui.hud.items.*;
import org.apache.logging.log4j.Level;
import cpw.mods.fml.client.registry.ClientRegistry;
import cpw.mods.fml.client.registry.RenderingRegistry;
import cpw.mods.fml.common.FMLCommonHandler;
import cpw.mods.fml.common.Loader;
import cpw.mods.fml.common.event.FMLInitializationEvent;
import cpw.mods.fml.common.event.FMLPostInitializationEvent;
import cpw.mods.fml.common.event.FMLPreInitializationEvent;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
import enviromine.EntityPhysicsBlock;
import enviromine.blocks.tiles.TileEntityDavyLamp;
import enviromine.blocks.tiles.TileEntityElevator;
import enviromine.blocks.tiles.TileEntityEsky;
import enviromine.blocks.tiles.TileEntityFreezer;
import enviromine.client.gui.Gui_EventManager;
import enviromine.client.gui.hud.HUDRegistry;
import enviromine.client.gui.menu.EM_Gui_Menu;
import enviromine.client.renderer.RenderPlayerEM;
import enviromine.client.renderer.itemInventory.ArmoredCamelPackRenderer;
import enviromine.client.renderer.tileentity.RenderGasHandler;
import enviromine.client.renderer.tileentity.RenderSpecialHandler;
import enviromine.client.renderer.tileentity.TileEntityDavyLampRenderer;
import enviromine.client.renderer.tileentity.TileEntityElevatorRenderer;
import enviromine.client.renderer.tileentity.TileEntityEskyRenderer;
import enviromine.client.renderer.tileentity.TileEntityFreezerRenderer;
import enviromine.core.EM_ConfigHandler.EnumLogVerbosity;
import enviromine.core.EM_Settings;
import enviromine.core.EnviroMine;
import enviromine.handlers.ObjectHandler;
import enviromine.handlers.keybinds.EnviroKeybinds;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.GuiMainMenu;
import net.minecraft.client.renderer.entity.RenderFallingBlock;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.Item;
import net.minecraft.item.ItemArmor;
import net.minecraft.item.ItemStack;
import net.minecraft.util.StatCollector;
import net.minecraftforge.client.IItemRenderer;
import net.minecraftforge.client.IItemRenderer.ItemRenderType;
import net.minecraftforge.client.MinecraftForgeClient;
import net.minecraftforge.common.MinecraftForge;

Context:
src/main/java/enviromine/core/proxies/EM_ClientProxy.java
package enviromine.core.proxies;

public class EM_ClientProxy extends EM_CommonProxy
{

	@Override
	public boolean isClient()
	{
		return true;
	}

	@Override
	public boolean isOpenToLAN()
	{
		if (Minecraft.getMinecraft().isIntegratedServerRunning())
		{
			return Minecraft.getMinecraft().getIntegratedServer().getPublic();
		} else
		{
			return false;
		}
	}

	@Override
	public void registerTickHandlers()
	{
		super.registerTickHandlers();
	}

	@Override
	public void registerEventHandlers()
	{
		super.registerEventHandlers();
		//MinecraftForge.EVENT_BUS.register(new EM_GuiEnviroMeters(Minecraft.getMinecraft(), Minecraft.getMinecraft().getResourceManager()));
		MinecraftForge.EVENT_BUS.register(new ObjectHandler());
		MinecraftForge.EVENT_BUS.register(new Gui_EventManager());
		FMLCommonHandler.instance().bus().register(new EnviroKeybinds());
	}

	@Override
	public void preInit(FMLPreInitializationEvent event)
	{
		super.preInit(event);
	}

	@Override
	public void init(FMLInitializationEvent event)
	{
		super.init(event);
		EnviroKeybinds.Init();

		initRenderers();
		registerHudItems();

	}

	@SideOnly(Side.CLIENT)
	public static void initRenderers()
	{
		ObjectHandler.renderGasID = RenderingRegistry.getNextAvailableRenderId();
		ObjectHandler.renderSpecialID = RenderingRegistry.getNextAvailableRenderId();
		RenderingRegistry.registerBlockHandler(ObjectHandler.renderGasID, new RenderGasHandler());
		RenderingRegistry.registerBlockHandler(ObjectHandler.renderSpecialID, new RenderSpecialHandler());

		RenderingRegistry.registerEntityRenderingHandler(EntityPhysicsBlock.class, new RenderFallingBlock());

		armoredCamelRenderers();

		ClientRegistry.bindTileEntitySpecialRenderer(TileEntityElevator.class, new TileEntityElevatorRenderer());

src/main/java/enviromine/client/renderer/tileentity/RenderSpecialHandler.java
@SideOnly(Side.CLIENT)
public class RenderSpecialHandler implements ISimpleBlockRenderingHandler
{
	static HashMap<Block, TileEntity> blockToTile = new HashMap<Block, TileEntity>();

	@Override
	public void renderInventoryBlock(Block block, int metadata, int modelId, RenderBlocks renderer)
	{
		if(blockToTile.containsKey(block))
		{
            GL11.glRotatef(90.0F, 0.0F, 1.0F, 0.0F);
            GL11.glTranslatef(-0.5F, -0.5F, -0.5F);
            if(!blockToTile.get(block).hasWorldObj())
            {
            	blockToTile.get(block).setWorldObj(renderer.minecraftRB.theWorld);
            }

            if(blockToTile.get(block).blockType == null)
            {
            	blockToTile.get(block).blockType = block;
            }
            blockToTile.get(block).blockMetadata = metadata;
			TileEntityRendererDispatcher.instance.renderTileEntityAt(blockToTile.get(block), 0.0D, 0.0D, 0.0D, 0.0F);
            GL11.glEnable(GL12.GL_RESCALE_NORMAL);
		}
	}

	@Override
	public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block block, int modelId, RenderBlocks renderer)
	{
		return false;
	}

	@Override
	public boolean shouldRender3DInInventory(int modelId)
	{
		return true;
	}

	@Override
	public int getRenderId()
	{
		return ObjectHandler.renderSpecialID;
	}

	{
		blockToTile.put(ObjectHandler.esky, new TileEntityEsky());
		blockToTile.put(ObjectHandler.freezer, new TileEntityFreezer());
		blockToTile.put(ObjectHandler.elevator, new TileEntityElevator());
	}
}

src/main/java/enviromine/client/gui/menu/EM_Gui_Menu.java
@SideOnly(Side.CLIENT)
public class EM_Gui_Menu extends GuiScreen implements GuiYesNoCallback
{

	private GuiScreen parentGuiScreen = null;

	public EM_Gui_Menu()
	{

	}

	public EM_Gui_Menu(GuiScreen par1GuiScreen)
	{
		this.parentGuiScreen = par1GuiScreen;
	}

	@SuppressWarnings("unchecked")
	@Override
	public void initGui()
	{
		GuiButtonExt changeProfile =  new GuiButtonExt(205, this.width / 2 - 90, this.height / 6 + 86, 180, 20, I18n.format("editor.enviromine.changeprofile"));
//		GuiButtonExt serverSettings = new GuiButtonExt(103, this.width / 2 - 90, this.height / 6 + 122 - 6, 180, 20, "(Coming Soon)"+ StatCollector.translateToLocal("options.enviromine.configSettings"));
		GuiButtonExt customEditor =  new GuiButtonExt(104, this.width / 2 - 90, this.height / 6 + 108, 180, 20, StatCollector.translateToLocal("options.enviromine.customEditor"));

//		serverSettings.enabled = false;
		customEditor.enabled = Minecraft.getMinecraft().isIntegratedServerRunning();
		changeProfile.enabled = Minecraft.getMinecraft().isIntegratedServerRunning();

//		serverSettings.visible = true;

		// There will be no new posts.
		//String newPost = UpdateNotification.isNewPost() ? " " + StatCollector.translateToLocal("news.enviromine.newpost") : "";

    	this.buttonList.add(changeProfile);
/*    	if(!EM_Settings.voxelMenuExists) this.buttonList.add(new EM_Button(105, this.width / 2 - 90, this.height / 6 + 4, 180, 20, StatCollector.translateToLocal("options.enviromine.newsPage"), newPost));
    	else this.buttonList.add(new GuiButtonExt(105, this.width / 2 - 90, this.height / 6 + 4, 180, 20, StatCollector.translateToLocal("options.enviromine.newsPage")+" " +newPost));*/
    	//this.buttonList.add(new GuiButtonExt(105, this.width / 2 - 90, this.height / 6 + 4, 180, 20, StatCollector.translateToLocal("options.enviromine.newsPage")));

		this.buttonList.add(new GuiButtonExt(102, this.width / 2 - 90, this.height / 6 + 12, 180, 20, StatCollector.translateToLocal("options.enviromine.guiSounds")));
    	this.buttonList.add(new GuiButtonExt(101, this.width / 2 - 90, this.height / 6 + 34, 180, 20, StatCollector.translateToLocal("options.enviromine.guiOptions")));
//		this.buttonList.add(serverSettings);
		this.buttonList.add(customEditor);
		this.buttonList.add(new GuiButtonExt(200, this.width / 2 - 100, this.height / 6 + 160, StatCollector.translateToLocal("gui.done")));

//		this.buttonList.add(new GuiButtonExt(300, 30 , this.height -55 , 75, 20, StatCollector.translateToLocal("options.enviromine.supportUs")));
//		this.buttonList.add(new GuiButtonExt(301, 30, this.height -30 , 75,20, StatCollector.translateToLocal("options.enviromine.website")));

	}

	@Override
	public boolean doesGuiPauseGame()
	{
		return true;
	}

//	private String ourwebsite = "https://enviromine.wordpress.com/";
//	private String supportPage = "https://enviromine.wordpress.com/support-us/";

	/* Send player to URL from this menu
	 * (non-Javadoc)
	 * @see net.minecraft.client.gui.GuiScreen#confirmClicked(boolean, int)
	 */
	@Override
	public void confirmClicked(boolean p_73878_1_, int p_73878_2_)
	{
//		String url = "";
//		boolean go = false;
//
//		if(p_73878_1_) // if true
//		{
//			if(p_73878_2_ == 1)
//			{
//				url = ourwebsite;
//				go = true;
//			}
//
//			if(p_73878_2_ == 2)
//			{
//				url = supportPage;
//				go = true;
//			}
//
//			if(Desktop.isDesktopSupported() && go)
//			{
//				try
//				{
//					Desktop.getDesktop().browse(new URI(url));
//				}catch (Exception e) {
//					EnviroMine.logger.log(Level.WARN, "(EM_Gui_Menu) Failed to open Default Browser to: " + url);
//				}
//			}
//
//		}

		this.mc.displayGuiScreen(this);
	}

	/**
	 * Fired when a control is clicked. This is the equivalent of ActionListener.actionPerformed(ActionEvent e).
	 */
	@Override
	protected void actionPerformed(GuiButton par1GuiButton)
	{

		if(par1GuiButton.id == 205)
		{
			this.mc.displayGuiScreen(new ProfileMenu(this));
		}
		else if (par1GuiButton.id == 100)
		{
			this.mc.displayGuiScreen(new EM_Gui_General(this));
		}
		else if (par1GuiButton.id == 101)
		{
			this.mc.displayGuiScreen(new EM_Gui_GuiSettings(this));
		}
		else if (par1GuiButton.id == 102)
		{
			this.mc.displayGuiScreen(new EM_Gui_SoundSettings(this));
		}
		else if (par1GuiButton.id == 103)
		{
			return; // Server settings. Coming soon...
		}
		else if (par1GuiButton.id == 104)
		{
			this.mc.displayGuiScreen(new EM_ConfigMenu(this)); // In game editor
		}
//		else if (par1GuiButton.id == 105)
//		{
//			this.mc.displayGuiScreen(new NewsPage(this, 150));
//		}
//		else if(par1GuiButton.id == 301)
//		{
//			this.mc.displayGuiScreen(new GuiYesNo(this, StatCollector.translateToLocal("options.enviromine.website"), StatCollector.translateToLocal("options.enviromine.website.YesNo"), 1));
//		}
//		else if(par1GuiButton.id == 300)
//		{
//			this.mc.displayGuiScreen(new GuiYesNo(this, StatCollector.translateToLocal("options.enviromine.supportUs"), StatCollector.translateToLocal("options.enviromine.website.YesNo"), 2));
//		}
		else if (par1GuiButton.id == 200)
		{
			this.mc.displayGuiScreen(parentGuiScreen);
		}

	}

	@Override
	public void drawScreen(int par1, int par2, float par3)
	{
		this.drawDefaultBackground();

//		if(!EnviroMine.proxy.isClient() && MinecraftServer.getServer().getConfigurationManager().func_152607_e(mc.thePlayer.getGameProfile()) || EnviroMine.proxy.isClient() )
//		{
//			this.drawString(this.fontRendererObj, StatCollector.translateToLocal("options.enviromine.adminOptions.title") + " ", this.width / 2 -30, this.height / 6 + 84, 16777215);
//		}
		this.drawCenteredString(this.fontRendererObj, StatCollector.translateToLocal("options.enviromine.guiMainmenu.title"), this.width / 2, 30, 16777215);
        this.drawCenteredString(this.fontRendererObj, I18n.format("editor.enviromine.currentProfile") +": "+ ChatFormatting.AQUA+EM_ConfigHandler.getProfileName()+ChatFormatting.RESET, this.width / 2, this.height / 6 + 74, 16777215);
		super.drawScreen(par1, par2, par3);
	}
}

src/main/java/enviromine/client/renderer/tileentity/TileEntityEskyRenderer.java
@SideOnly(Side.CLIENT)
public class TileEntityEskyRenderer extends TileEntitySpecialRenderer
{
    private static final ResourceLocation field_147520_b = new ResourceLocation("enviromine", "textures/models/blocks/esky_model.png");
    private ModelChest field_147521_c = new ModelChest();

    public void renderTileEntityAt(TileEntityEsky p_147500_1_, double p_147500_2_, double p_147500_4_, double p_147500_6_, float p_147500_8_)
    {
        int i = 0;

        if (p_147500_1_.hasWorldObj())
        {
            i = p_147500_1_.getBlockMetadata();
        }

        this.bindTexture(field_147520_b);
        GL11.glPushMatrix();
        GL11.glEnable(GL12.GL_RESCALE_NORMAL);
        GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
        GL11.glTranslatef((float)p_147500_2_, (float)p_147500_4_ + 1.0F, (float)p_147500_6_ + 1.0F);
        GL11.glScalef(1.0F, -1.0F, -1.0F);
        GL11.glTranslatef(0.5F, 0.5F, 0.5F);
        short short1 = 0;

        if (i == 2)
        {
            short1 = 180;
        }

        if (i == 3)
        {
            short1 = 0;
        }

        if (i == 4)
        {
            short1 = 90;
        }

        if (i == 5)
        {
            short1 = -90;
        }

        GL11.glRotatef((float)short1, 0.0F, 1.0F, 0.0F);
        GL11.glTranslatef(-0.5F, -0.5F, -0.5F);
        float f1 = p_147500_1_.field_145975_i + (p_147500_1_.field_145972_a - p_147500_1_.field_145975_i) * p_147500_8_;
        f1 = 1.0F - f1;
        f1 = 1.0F - f1 * f1 * f1;
        this.field_147521_c.chestLid.rotateAngleX = -(f1 * (float)Math.PI / 2.0F);
        this.field_147521_c.renderAll();
        GL11.glDisable(GL12.GL_RESCALE_NORMAL);
        GL11.glPopMatrix();
        GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
    }

    @Override
    public void renderTileEntityAt(TileEntity p_147500_1_, double p_147500_2_, double p_147500_4_, double p_147500_6_, float p_147500_8_)
    {
        this.renderTileEntityAt((TileEntityEsky)p_147500_1_, p_147500_2_, p_147500_4_, p_147500_6_, p_147500_8_);
    }
}

src/main/java/enviromine/core/EM_Settings.java
public class EM_Settings
{
	public static final UUID FROST1_UUID = UUID.fromString("B0C5F86A-78F3-417C-8B5A-527B90A1E919");
	public static final UUID FROST2_UUID = UUID.fromString("5C4111A7-A66C-40FB-9FAD-1C6ADAEE7E27");
	public static final UUID FROST3_UUID = UUID.fromString("721E793E-2203-4F6F-883F-6F44D7DDCCE1");
	public static final UUID HEAT1_UUID = UUID.fromString("CA6E2CFA-4C53-4CD2-AAD3-3D6177A4F126");
	public static final UUID DEHY1_UUID = UUID.fromString("38909A39-E1A1-4E93-9016-B2CCBE83D13D");

	public static File worldDir = null;

	//Mod Data
	public static final String VERSION = "@VERSION@";
	public static final String MOD_ID = "enviromine";
	public static final String MOD_NAME = "EnviroMine";
	public static final String MOD_NAME_COLORIZED = EnumChatFormatting.AQUA + MOD_NAME + EnumChatFormatting.RESET;
	public static final String Channel = "EM_CH";
	public static final String Proxy = "enviromine.core.proxies";
	public static final String URL = "https://modrinth.com/mod/enviromine-for-galaxy-odyssey";
	public static final String VERSION_CHECKER_URL = "https://gitgud.io/AstroTibs/enviromine-for-galaxy-odyssey/-/raw/1.7.10/CURRENT_VERSION";
	public static final String GUI_FACTORY = MOD_ID+".client.gui.menu.config.EnviroMineGuiFactory";

	public static boolean versionChecker;

	public static int loggerVerbosity;

    public static boolean DeathFromHeartAttack;

    public static int HeartAttackTimeToDie;
    public static int HbmGasMaskBreakMultiplier;

    public static int EnviromineGasMaskBreakMultiplier;
    public static int HbmGasMaskBreakChanceNumber;

    public static boolean hardcoregases = false;

	public static boolean enablePhysics = false;
	public static boolean enableLandslide = true;
	public static boolean waterCollapse = true; // Added out of necessity/annoyance -- AstroTibs

	public static float blockTempDropoffPower = 0.75F;
	public static int scanRadius = 6;
	public static float auraRadius = 0.5F;

	@ShouldOverride
	public static boolean enableAirQ = true;
	@ShouldOverride
	public static boolean enableHydrate = true;
	@ShouldOverride
	public static boolean enableSanity = true;
	@ShouldOverride
	public static boolean enableBodyTemp = true;

	public static boolean trackNonPlayer = false;

	public static boolean spreadIce = false;

	public static boolean useFarenheit = false;
	public static String heatBarPos;
	public static String waterBarPos;
	public static String sanityBarPos;
	public static String oxygenBarPos;

	public static int dirtBottleID = 5001;
	public static int saltBottleID = 5002;
	public static int coldBottleID = 5003;
	public static int camelPackID = 5004;

	public static final String GAS_MASK_FILL_TAG_KEY = "gasMaskFill";
	public static final String GAS_MASK_MAX_TAG_KEY = "gasMaskMax";
	public static final String CAMEL_PACK_FILL_TAG_KEY = "camelPackFill";
	public static final String CAMEL_PACK_MAX_TAG_KEY = "camelPackMax";
	public static final String IS_CAMEL_PACK_TAG_KEY = "isCamelPack";
	public static int gasMaskMax = 1000;
	public static int filterRestore = 500;
	public static int camelPackMax = 100;
	public static float gasMaskUpdateRestoreFraction = 1F;

	/*
	public static int gasMaskID = 5005;
	public static int airFilterID = 5006;
	public static int hardHatID = 5007;
	public static int rottenFoodID = 5008;

	public static int blockElevatorTopID = 501;
	public static int blockElevatorBottomID = 502;
	public static int gasBlockID = 503;
	public static int fireGasBlockID = 504;
	*/

	public static int hypothermiaPotionID = 27;
	public static int heatstrokePotionID = 28;
	public static int frostBitePotionID = 29;
	public static int dehydratePotionID = 30;
	public static int insanityPotionID = 31;

	public static boolean enableHypothermiaGlobal = true;
	public static boolean enableHeatstrokeGlobal = true;
	public static boolean enableFrostbiteGlobal = true;
	public static boolean frostbitePermanent = true;

	//Gases
	public static boolean renderGases = false;
	public static int gasTickRate = 32; //GasFires are 4x faster than this
	public static int gasPassLimit = -1;
	public static boolean gasWaterLike = true;
	public static boolean slowGases = true; // Normal gases use random ticks to move
	public static boolean noGases = false;

	//World Gen
	public static boolean shaftGen = true;
	public static boolean gasGen = true;
	public static boolean oldMineGen = true;

	//Properties
	//@ShouldOverride("enviromine.network.packet.encoders.ArmorPropsEncoder")
	@ShouldOverride({String.class, ArmorProperties.class})
	public static HashMap<String,ArmorProperties> armorProperties = new HashMap<String,ArmorProperties>();
	//@ShouldOverride("enviromine.network.packet.encoders.BlocksPropsEncoder")
	@ShouldOverride({String.class, BlockProperties.class})
	public static HashMap<String,BlockProperties> blockProperties = new HashMap<String,BlockProperties>();
	@ShouldOverride({Integer.class, EntityProperties.class})
	public static HashMap<Integer,EntityProperties> livingProperties = new HashMap<Integer,EntityProperties>();
	@ShouldOverride({String.class, ItemProperties.class})
	public static HashMap<String,ItemProperties> itemProperties = new HashMap<String,ItemProperties>();
	@ShouldOverride({Integer.class, BiomeProperties.class})
	public static HashMap<Integer,BiomeProperties> biomeProperties = new HashMap<Integer,BiomeProperties>();
	@ShouldOverride({Integer.class, DimensionProperties.class})
	public static HashMap<Integer,DimensionProperties> dimensionProperties = new HashMap<Integer,DimensionProperties>();

	public static HashMap<String,StabilityType> stabilityTypes = new HashMap<String,StabilityType>();

	@ShouldOverride({String.class, RotProperties.class})
	public static HashMap<String,RotProperties> rotProperties = new HashMap<String,RotProperties>();

	public static boolean streamsDrink = true;
	public static boolean witcheryVampireImmunities = true;
	public static boolean witcheryWerewolfImmunities = true;
	public static boolean matterOverdriveAndroidImmunities = true;

	public static int updateCap = 128;
	public static boolean stoneCracks = true;
	public static String defaultStability = "loose";

	public static double sanityMult = 1.0D;
	public static double hydrationMult = 1.0D;
	public static double tempMult = 1.0D;
	public static double airMult = 1.0D;

	//public static boolean updateCheck = true;
	//public static boolean useDefaultConfig = true;
	public static boolean genConfigs = false;
	public static boolean genDefaults = false;

	public static int physInterval = 6;
	public static int worldDelay = 1000;
	public static int chunkDelay = 1000;
	public static int entityFailsafe = 1;
	public static boolean villageAssist = true;

	public static boolean minimalHud;
	public static boolean limitCauldron;
	public static boolean allowTinting = true;
	public static boolean torchesBurn = true;
	public static boolean torchesGoOut = true;
	public static boolean genFlammableCoal = true; // In case you don't want burny-coal
	public static boolean randomizeInsanityPitch = true;
	public static boolean catchFireAtHighTemps = true;

	public static int caveDimID = -3;
	public static int caveBiomeID = 23;
	public static boolean disableCaves = false;
	public static int limitElevatorY = 10;
	public static boolean caveOreEvent = true;
	public static boolean caveLava = false;
	public static int caveRavineRarity = 30;
	public static int caveTunnelRarity = 7;
	public static int caveDungeons = 8;
	public static int caveLiquidY = 32;
	public static boolean caveFlood = true;
	public static boolean caveRespawn = false;
	public static boolean enforceWeights = false;
	public static ArrayList<CaveGenProperties> caveGenProperties = new ArrayList<CaveGenProperties>();
	public static HashMap<Integer, CaveSpawnProperties> caveSpawnProperties = new HashMap<Integer, CaveSpawnProperties>();

	public static boolean foodSpoiling = true;
	public static int foodRotTime = 7;

	/** Whether or not this overridden with server settings */
	public static boolean isOverridden = false;
	public static boolean enableConfigOverride = false;
	public static boolean profileOverride = false;
	public static String profileSelected = "default";

	public static boolean enableQuakes = true;
	public static boolean quakePhysics = true;
	public static int quakeRarity = 100;

	public static boolean finiteWater = false;
	public static float thingChance = 0.000001F;
	public static boolean noNausea = false;
	public static boolean keepStatus = false;
	public static boolean renderGear = true;
	public static String[] cauldronHeatingBlocks = new String[]{ // Added on request - AstroTibs
			"minecraft:fire",
			"minecraft:lava",
			"minecraft:flowing_lava",
			"campfirebackport:campfire",
			"campfirebackport:soul_campfire",
			"CaveBiomes:stone_lavacrust",
			"demonmobs:hellfire",
			"etfuturum:magma",
			"infernomobs:purelava",
			"infernomobs:scorchfire",
			"netherlicious:FoxFire",
			"netherlicious:MagmaBlock",
			"netherlicious:SoulFire",
			"uptodate:magma_block",
	};
	public static String[] notWaterBlocks = new String[]{ // Added on request - AstroTibs
			"minecraft:fire",
			"minecraft:lava",
			"minecraft:flowing_lava",
			"campfirebackport:campfire",
			"campfirebackport:soul_campfire",
			"CaveBiomes:stone_lavacrust",
			"demonmobs:hellfire",
			"etfuturum:magma",
			"infernomobs:purelava",
			"infernomobs:scorchfire",
			"netherlicious:FoxFire",
			"netherlicious:MagmaBlock",
			"netherlicious:SoulFire",
			"uptodate:magma_block",
	};

	public static boolean voxelMenuExists = false;

	/**
	 * Tells the server that this field should be sent to the client to overwrite<br>
	 * Usage:<br>
	 * <tt>@ShouldOverride</tt> - for ints/booleans/floats/Strings<br>
	 * <tt>@ShouldOverride(Class[] value)</tt> - for ArrayList or HashMap types
	 * */
	@Target(ElementType.FIELD)
	@Retention(RetentionPolicy.RUNTIME)
	public @interface ShouldOverride
	{
		Class<?>[] value() default {};
	}
}

src/main/java/enviromine/blocks/tiles/TileEntityElevator.java
public class TileEntityElevator extends TileEntity
{
}

src/main/java/enviromine/client/renderer/RenderPlayerEM.java
@SideOnly(Side.CLIENT)
public class RenderPlayerEM extends RenderPlayer {

	public RenderPlayerEM()
	{
		super();

		this.mainModel = new ModelPlayerEM(0.0F);
		this.modelBipedMain = (ModelPlayerEM) this.mainModel;
		this.modelArmorChestplate = new ModelPlayerEM(1.0F);
		this.modelArmor = new ModelPlayerEM(0.5F);

	}

	@Override
	protected void renderModel(EntityLivingBase par1EntityLivingBase, float par2, float par3, float par4, float par5, float par6, float par7)
	{
		super.renderModel(par1EntityLivingBase, par2, par3, par4, par5, par6, par7);

	}

	/*
	@Override
	protected void rotateCorpse(AbstractClientPlayer par1AbstractClientPlayer,	float par2, float par3, float par4)
	{
		if (par1AbstractClientPlayer.isEntityAlive() && par1AbstractClientPlayer.isPlayerSleeping())
		{
			RotatePlayerEvent event = new RotatePlayerEvent(par1AbstractClientPlayer);
			MinecraftForge.EVENT_BUS.post(event);
			if (event.shouldRotate == null || event.shouldRotate)
			{
				GL11.glRotatef(	par1AbstractClientPlayer.getBedOrientationInDegrees(),	0.0F, 1.0F, 0.0F);
			}
		} else
		{
			super.rotateCorpse(par1AbstractClientPlayer, par2, par3, par4);
		}
	}

	public static class RotatePlayerEvent extends PlayerEvent
	{
		public Boolean shouldRotate = null;

		public RotatePlayerEvent(AbstractClientPlayer player)
		{
			super(player);
		}
	}
*/
}

src/main/java/enviromine/client/renderer/tileentity/TileEntityElevatorRenderer.java
public class TileEntityElevatorRenderer extends TileEntitySpecialRenderer
{
	IModelCustom modelTop;
	IModelCustom modelBottom;
	ResourceLocation mainTexture;
	ResourceLocation recallTexture;

	public TileEntityElevatorRenderer()
	{
		modelTop = AdvancedModelLoader.loadModel(new ResourceLocation("enviromine", "models/topblockelevator.obj"));
		modelBottom = AdvancedModelLoader.loadModel(new ResourceLocation("enviromine", "models/bottomblockelevator.obj"));
		mainTexture = new ResourceLocation("enviromine", "textures/models/blocks/elevator_model.png");
		recallTexture = new ResourceLocation("enviromine", "textures/models/blocks/recall_model.png");
	}

	@Override
	public void renderTileEntityAt(TileEntity tileentity, double x, double y, double z, float f)
	{
		GL11.glPushMatrix();
        GL11.glTranslated(x, y, z);
        if(tileentity.getBlockMetadata() >= 2)
        {
        	Minecraft.getMinecraft().renderEngine.bindTexture(recallTexture);
        } else
        {
        	Minecraft.getMinecraft().renderEngine.bindTexture(mainTexture);
        }
        if(tileentity.getBlockMetadata()%2 == 0)
        {
        	modelTop.renderAll();
        } else
        {
        	modelBottom.renderAll();
        }
        GL11.glPopMatrix();
	}
}

src/main/java/enviromine/blocks/tiles/TileEntityDavyLamp.java
public class TileEntityDavyLamp extends TileEntity
{
	public TileEntityDavyLamp()
	{
	}
}

src/main/java/enviromine/client/renderer/tileentity/TileEntityDavyLampRenderer.java
public class TileEntityDavyLampRenderer extends TileEntitySpecialRenderer
{
	IModelCustom model;
	ResourceLocation texOff;
	ResourceLocation[] texLit;
	ResourceLocation[] texGas;

	public TileEntityDavyLampRenderer()
	{
		model = AdvancedModelLoader.loadModel(new ResourceLocation("enviromine", "models/davy_lamp.obj"));
		texOff = new ResourceLocation("enviromine", "textures/models/blocks/davy_lamp_model_off.png");
		texLit = new ResourceLocation[]{new ResourceLocation("enviromine", "textures/models/blocks/davy_lamp_model_lit_0.png"), new ResourceLocation("enviromine", "textures/models/blocks/davy_lamp_model_lit_1.png")};
		texGas = new ResourceLocation[]{new ResourceLocation("enviromine", "textures/models/blocks/davy_lamp_model_gas_0.png"), new ResourceLocation("enviromine", "textures/models/blocks/davy_lamp_model_gas_1.png")};
	}

	@Override
	public void renderTileEntityAt(TileEntity tileEntity, double x, double y, double z, float f)
	{
		int pass = (int)(tileEntity.getWorldObj().getTotalWorldTime()/2%2);
		GL11.glPushMatrix();
        GL11.glTranslated(x, y, z);
        if(tileEntity.getBlockMetadata() == 1)
        {
        	Minecraft.getMinecraft().renderEngine.bindTexture(texLit[pass]);
        } else if(tileEntity.getBlockMetadata() == 2)
        {
        	Minecraft.getMinecraft().renderEngine.bindTexture(texGas[pass]);
        } else
        {
        	Minecraft.getMinecraft().renderEngine.bindTexture(texOff);
        }
        model.renderAll();
        GL11.glPopMatrix();
	}
}

src/main/java/enviromine/client/gui/Gui_EventManager.java
@SideOnly(Side.CLIENT)
public class Gui_EventManager
{

	int width, height;

	//Render HUD
	//Render Player

	// Button Functions
	GuiButton enviromine;

	// Captures the initiation of vanilla menus to render new buttons
	@SuppressWarnings("unchecked")
	@SubscribeEvent
	public void renderevent(InitGuiEvent.Post event)
	{
		width = event.gui.width;
		height = event.gui.height;

		if(event.gui instanceof GuiIngameMenu && !EM_Settings.voxelMenuExists)
		{
			// There will be no new posts.
			//String newPost = UpdateNotification.isNewPost() ? " " + StatCollector.translateToLocal("news.enviromine.newpost") : "";

			try
			{
				byte b0 = -16;
				enviromine = new GuiButton(1348, width / 2 - 100, height / 4 + 24 + b0, StatCollector.translateToLocal("options.enviromine.menu.title"));
				//enviromine = new EM_Button(1348, width / 2 - 100, height / 4 + 24 + b0, StatCollector.translateToLocal("options.enviromine.menu.title") , newPost);
				event.buttonList.set(1, new GuiButton(4, width / 2 - 100, height / 4 + 0 + b0, I18n.format("menu.returnToGame", new Object[0])));
				event.buttonList.add(enviromine);
			} catch(Exception e)
			{
				//enviromine = new GuiButton(1348, width - 175, height - 30, 160, 20, StatCollector.translateToLocal("options.enviromine.menu.title") + newPost);
				enviromine = new GuiButton(1348, width - 175, height - 30, 160, 20, StatCollector.translateToLocal("options.enviromine.menu.title"));
				if (EM_Settings.loggerVerbosity >= EnumLogVerbosity.NORMAL.getLevel()) EnviroMine.logger.log(Level.ERROR, "Error shifting Minecrafts Menu to add in new button: " + e);
				event.buttonList.add(enviromine);
			}
		}
	}

	// Used to capture when an Enviromine button is hit in a vanilla menu
	@SubscribeEvent
	public void action(ActionPerformedEvent.Post event)
	{
		if(event.gui instanceof GuiIngameMenu)
		{
			if(event.button.id == enviromine.id)
			{
				Minecraft.getMinecraft().displayGuiScreen(new EM_Gui_Menu(event.gui));
			}

		}
	}

	public static int scaleTranslateX, scaleTranslateY;

	private Minecraft mc = Minecraft.getMinecraft();

	public static final ResourceLocation guiResource = new ResourceLocation("enviromine", "textures/gui/status_Gui.png");
	public static final ResourceLocation blurOverlayResource = new ResourceLocation("enviromine", "textures/misc/blur.png");

	public static EnviroDataTracker tracker = null;

	/**
	 * All Enviromine Gui and Hud Items will render here
	 * @param event
	 */
	@SubscribeEvent
	@SideOnly(Side.CLIENT)
	public void onGuiRender(RenderGameOverlayEvent.Post event)
	{
		if(event.type != ElementType.HELMET || event.isCancelable())
		{
			return;
		}

		mc.thePlayer.yOffset = 1.62F;
		if(ClientQuake.GetQuakeShake(mc.theWorld, mc.thePlayer) > 0)
		{
			if(mc.thePlayer == null || mc.thePlayer.isPlayerSleeping() || !mc.thePlayer.onGround || (mc.currentScreen != null && mc.currentScreen.doesGuiPauseGame()))
			{
			} else
			{
				float shakeMult = ClientQuake.GetQuakeShake(mc.theWorld, mc.thePlayer);

				double shakeSpeed = 2D * shakeMult;
				float offsetY = 0.2F * shakeMult;

				double shake = (int)(mc.theWorld.getTotalWorldTime() % 24000L) * shakeSpeed;

				mc.thePlayer.yOffset -= (Math.sin(shake) * (offsetY / 2F)) + (offsetY / 2F);
				mc.thePlayer.cameraPitch = (float)(Math.sin(shake) * offsetY / 4F);
				mc.thePlayer.cameraYaw = (float)(Math.sin(shake) * offsetY / 4F);
			}
		}

		HUDRegistry.checkForResize();

		if(tracker == null)
		{
			if(!(EM_Settings.enableAirQ == false && EM_Settings.enableBodyTemp == false && EM_Settings.enableHydrate == false && EM_Settings.enableSanity == false))
			{
				//Minecraft.getMinecraft().fontRenderer.drawStringWithShadow("NO ENVIRONMENT DATA", xPos, (height - yPos) - 8, 16777215);
				tracker = EM_StatusManager.lookupTrackerFromUsername(this.mc.thePlayer.getCommandSenderName());
			}
		} else if(tracker.isDisabled || !EM_StatusManager.trackerList.containsValue(tracker))
		{
			tracker = null;
		} else
		{

			HudItem.blinkTick++;

			// Render GasMask Overlays
			if(UI_Settings.overlay)
			{
				GasMaskHud.renderGasMask(mc);
			}

			// Render Hud Items
			GL11.glPushMatrix();
			GL11.glDisable(GL11.GL_LIGHTING);
	        GL11.glColor4f(1F, 1F, 1F, 1F);

			for(HudItem huditem : HUDRegistry.getActiveHudItemList())
			{

				if(mc.playerController.isInCreativeMode() && !huditem.isRenderedInCreative())
				{
					continue;
				}

				if(mc.thePlayer.ridingEntity instanceof EntityLivingBase)
				{
					if(huditem.shouldDrawOnMount())
					{
						if(UI_Settings.overlay)
						{
							RenderAssist.bindTexture(huditem.getResource("TintOverlay"));
							huditem.renderScreenOverlay(HUDRegistry.screenWidth, HUDRegistry.screenHeight);
						}

						RenderAssist.bindTexture(huditem.getResource(""));

						//float transx = (float)(huditem.posX - (huditem.posX * UI_Settings.guiScale));
						//float transy = (float)(huditem.posY - (huditem.posY * UI_Settings.guiScale));

						//GL11.glTranslated(transx, transy, 0);

						//GL11.glScalef((float)UI_Settings.guiScale, (float)UI_Settings.guiScale, (float)UI_Settings.guiScale);

						huditem.fixBounds();
						huditem.render();

					}
				} else
				{
					if(huditem.shouldDrawAsPlayer())
					{
						if(UI_Settings.overlay)
						{
							RenderAssist.bindTexture(huditem.getResource("TintOverlay"));
							huditem.renderScreenOverlay(HUDRegistry.screenWidth, HUDRegistry.screenHeight);
						}

						RenderAssist.bindTexture(huditem.getResource(""));

						//float transx = (float)(huditem.posX - (huditem.posX * UI_Settings.guiScale));
						//float transy = (float)(huditem.posY - (huditem.posY * UI_Settings.guiScale));

						//GL11.glTranslated(transx, transy, 0);

						//GL11.glScalef((float)UI_Settings.guiScale, (float)UI_Settings.guiScale, (float)UI_Settings.guiScale);

						huditem.fixBounds();
						huditem.render();

						//GL11.glTranslated(0, 0, 0);

					}
				}

			}
			Debug_Info.ShowDebugText(event, mc);
			GL11.glPopMatrix();
		}

	}

	//TODO Was used for Debugging Gui
	/*@SubscribeEvent
	public void onGuiOpen(GuiOpenEvent event)
	{
		if(event == null) return;
		if(event.gui == null) return;
		System.out.println(event.gui.getClass().getSimpleName().toString());
		if(event.gui instanceof GuiConfig)
		{
			GuiConfig guiConfig = (GuiConfig) event.gui;

			System.out.println("configID:"+guiConfig.configID +" modID:"+ guiConfig.modID);

			Iterator<IConfigElement> elements = guiConfig.configElements.iterator();

			while(elements.hasNext())
			{
				IConfigElement element = elements.next();

				System.out.println("element name:"+ element.getName() +" Type:"+ element.getType() + " QNamed:"+element.getQualifiedName());

			}

		}
	}*/

}

src/main/java/enviromine/client/renderer/tileentity/RenderGasHandler.java
@SideOnly(Side.CLIENT)
public class RenderGasHandler implements ISimpleBlockRenderingHandler
{
	private IIcon icon;
	private Tessellator tessellator;
	private int verts;

	@Override
	public void renderInventoryBlock(Block block, int metadata, int modelID, RenderBlocks renderer)
	{
		Tessellator tessellator = Tessellator.instance;

		float red = 1.0F;
		float green = 1.0F;
		float blue = 1.0F;

		if(renderer.useInventoryTint)
		{
			int var6 = block.getRenderColor(metadata);

			red = (float)(var6 >> 16 & 255) / 255.0F;
			green = (float)(var6 >> 8 & 255) / 255.0F;
			blue = (float)(var6 & 255) / 255.0F;
		}

		renderer.setRenderBoundsFromBlock(block);
		GL11.glRotatef(90.0F, 0.0F, 1.0F, 0.0F);
		GL11.glTranslatef(-0.5F, -0.5F, -0.5F);
		GL11.glColor4f(red, green, blue, 1.0F);

		tessellator.startDrawingQuads();
		tessellator.setNormal(0.0F, -1.0F, 0.0F);
		renderer.renderFaceYNeg(block, 0.0D, 0.0D, 0.0D, renderer.getBlockIconFromSideAndMetadata(block, 0, metadata));
		tessellator.draw();

		tessellator.startDrawingQuads();
		tessellator.setNormal(0.0F, 1.0F, 0.0F);
		renderer.renderFaceYPos(block, 0.0D, 0.0D, 0.0D, renderer.getBlockIconFromSideAndMetadata(block, 1, metadata));
		tessellator.draw();

		tessellator.startDrawingQuads();
		tessellator.setNormal(0.0F, 0.0F, -1.0F);
		renderer.renderFaceZNeg(block, 0.0D, 0.0D, 0.0D, renderer.getBlockIconFromSideAndMetadata(block, 2, metadata));
		tessellator.draw();
		tessellator.startDrawingQuads();
		tessellator.setNormal(0.0F, 0.0F, 1.0F);
		renderer.renderFaceZPos(block, 0.0D, 0.0D, 0.0D, renderer.getBlockIconFromSideAndMetadata(block, 3, metadata));
		tessellator.draw();
		tessellator.startDrawingQuads();
		tessellator.setNormal(-1.0F, 0.0F, 0.0F);
		renderer.renderFaceXNeg(block, 0.0D, 0.0D, 0.0D, renderer.getBlockIconFromSideAndMetadata(block, 4, metadata));
		tessellator.draw();
		tessellator.startDrawingQuads();
		tessellator.setNormal(1.0F, 0.0F, 0.0F);
		renderer.renderFaceXPos(block, 0.0D, 0.0D, 0.0D, renderer.getBlockIconFromSideAndMetadata(block, 5, metadata));
		tessellator.draw();

		GL11.glTranslatef(0.5F, 0.5F, 0.5F);
	}

	@Override
	public boolean renderWorldBlock(IBlockAccess blockAccess, int i, int j, int k, Block oBlock, int modelId, RenderBlocks renderer)
	{
        if (!hardcoregases) {
            BlockGas block = (BlockGas) oBlock;

            Block sideBlock;
            float sideAlpha;

            if (!(blockAccess.getBlock(i, j, k) instanceof BlockGas)) {
                if (EM_Settings.loggerVerbosity >= EnumLogVerbosity.ALL.getLevel())
                    EnviroMine.logger.log(Level.ERROR, "Trying to render gas without block at position!");
                return false;
            } else if (blockAccess.getTileEntity(i, j, k) == null) {
                if (EM_Settings.loggerVerbosity >= EnumLogVerbosity.ALL.getLevel())
                    EnviroMine.logger.log(Level.ERROR, "Trying to render gas without tile at position!");
                return false;
            }

            icon = renderer.hasOverrideBlockTexture() ? renderer.overrideBlockTexture : renderer.getBlockIcon(block);
            int brightness = block.getMixedBrightnessForBlock(blockAccess, i, j, k);
            int color = block.colorMultiplier(blockAccess, i, j, k);

            float red = (float) ((color >> 16) & 0xFF) / 255.0F;
            float green = (float) ((color >> 8) & 0xFF) / 255.0F;
            float blue = (float) (color & 0xFF) / 255.0F;
            float alpha = block.getOpacity(blockAccess, i, j, k);

            if (alpha <= 0.1F) {
                return false;
            }

            double minX = 0D;
            double maxX = 1.0D;

            double minY = block.getMinY(blockAccess, i, j, k);
            double maxY = block.getMaxY(blockAccess, i, j, k);

            double minZ = 0D;
            double maxZ = 1.0D;

            double sideMinY;
            double sideMaxY;

            verts = 0;
            tessellator = Tessellator.instance;

            tessellator.setBrightness(brightness);
            tessellator.addTranslation((float) i, (float) j, (float) k);

            tessellator.setColorRGBA_F(red * 0.9F, green * 0.9F, blue * 0.9F, alpha * 0.9F);
            if (block.shouldSideBeRendered(blockAccess, i, j, k, 2)) {
                sideBlock = blockAccess.getBlock(i, j, k - 1);
                sideAlpha = sideBlock instanceof BlockGas ? ((BlockGas) sideBlock).getOpacity(blockAccess, i, j, k - 1) : 0F;

                if (sideAlpha > 0.1F) {
                    sideMinY = ((BlockGas) sideBlock).getMinY(blockAccess, i, j, k - 1);
                    sideMaxY = ((BlockGas) sideBlock).getMaxY(blockAccess, i, j, k - 1);

                    if ((minY <= sideMinY & minY <= sideMaxY & maxY <= sideMinY & maxY <= sideMinY) | (minY >= sideMinY & minY >= sideMaxY & maxY >= sideMinY & maxY >= sideMinY)) {
                        vertexAutoMap(minX, minY, minZ, maxX, minY);
                        vertexAutoMap(minX, maxY, minZ, maxX, maxY);
                        vertexAutoMap(maxX, maxY, minZ, minX, maxY);
                        vertexAutoMap(maxX, minY, minZ, minX, minY);
                    } else {
                        if (minY < sideMinY) {
                            vertexAutoMap(minX, minY, minZ, maxX, minY);
                            vertexAutoMap(minX, sideMinY, minZ, maxX, sideMinY);
                            vertexAutoMap(maxX, sideMinY, minZ, minX, sideMinY);
                            vertexAutoMap(maxX, minY, minZ, minX, minY);
                        }

                        if (maxY > sideMaxY) {
                            vertexAutoMap(minX, sideMaxY, minZ, maxX, sideMaxY);
                            vertexAutoMap(minX, maxY, minZ, maxX, maxY);
                            vertexAutoMap(maxX, maxY, minZ, minX, maxY);
                            vertexAutoMap(maxX, sideMaxY, minZ, minX, sideMaxY);
                        }
                    }
                } else {
                    vertexAutoMap(minX, minY, minZ, maxX, minY);
                    vertexAutoMap(minX, maxY, minZ, maxX, maxY);
                    vertexAutoMap(maxX, maxY, minZ, minX, maxY);
                    vertexAutoMap(maxX, minY, minZ, minX, minY);
                }

            }

            if (block.shouldSideBeRendered(blockAccess, i, j, k, 3)) {
                sideBlock = blockAccess.getBlock(i, j, k + 1);
                sideAlpha = sideBlock instanceof BlockGas ? ((BlockGas) sideBlock).getOpacity(blockAccess, i, j, k + 1) : 0F;

                if (sideAlpha > 0.1F) {
                    sideMinY = ((BlockGas) sideBlock).getMinY(blockAccess, i, j, k + 1);
                    sideMaxY = ((BlockGas) sideBlock).getMaxY(blockAccess, i, j, k + 1);

                    if ((minY <= sideMinY & minY <= sideMaxY & maxY <= sideMinY & maxY <= sideMinY) | (minY >= sideMinY & minY >= sideMaxY & maxY >= sideMinY & maxY >= sideMinY)) {
                        vertexAutoMap(maxX, minY, maxZ, maxX, minY);
                        vertexAutoMap(maxX, maxY, maxZ, maxX, maxY);
                        vertexAutoMap(minX, maxY, maxZ, minX, maxY);
                        vertexAutoMap(minX, minY, maxZ, minX, minY);
                    } else {
                        if (minY < sideMinY) {
                            vertexAutoMap(maxX, minY, maxZ, maxX, minY);
                            vertexAutoMap(maxX, sideMinY, maxZ, maxX, sideMinY);
                            vertexAutoMap(minX, sideMinY, maxZ, minX, sideMinY);
                            vertexAutoMap(minX, minY, maxZ, minX, minY);
                        }

                        if (maxY > sideMaxY) {
                            vertexAutoMap(maxX, sideMaxY, maxZ, maxX, sideMaxY);
                            vertexAutoMap(maxX, maxY, maxZ, maxX, maxY);
                            vertexAutoMap(minX, maxY, maxZ, minX, maxY);
                            vertexAutoMap(minX, sideMaxY, maxZ, minX, sideMaxY);
                        }
                    }
                } else {
                    vertexAutoMap(maxX, minY, maxZ, maxX, minY);
                    vertexAutoMap(maxX, maxY, maxZ, maxX, maxY);
                    vertexAutoMap(minX, maxY, maxZ, minX, maxY);
                    vertexAutoMap(minX, minY, maxZ, minX, minY);
                }
            }

            if (block.shouldSideBeRendered(blockAccess, i, j, k, 4)) {
                sideBlock = blockAccess.getBlock(i - 1, j, k);
                sideAlpha = sideBlock instanceof BlockGas ? ((BlockGas) sideBlock).getOpacity(blockAccess, i - 1, j, k) : 0F;

                if (sideAlpha > 0.1F) {
                    sideMinY = ((BlockGas) sideBlock).getMinY(blockAccess, i - 1, j, k);
                    sideMaxY = ((BlockGas) sideBlock).getMaxY(blockAccess, i - 1, j, k);

                    if ((minY <= sideMinY & minY <= sideMaxY & maxY <= sideMinY & maxY <= sideMinY) | (minY >= sideMinY & minY >= sideMaxY & maxY >= sideMinY & maxY >= sideMinY)) {
                        vertexAutoMap(minX, minY, maxZ, minZ, maxY);
                        vertexAutoMap(minX, maxY, maxZ, minZ, minY);
                        vertexAutoMap(minX, maxY, minZ, maxZ, minY);
                        vertexAutoMap(minX, minY, minZ, maxZ, maxY);
                    } else {
                        if (minY < sideMinY) {
                            vertexAutoMap(minX, minY, maxZ, minZ, sideMinY);
                            vertexAutoMap(minX, sideMinY, maxZ, minZ, minY);
                            vertexAutoMap(minX, sideMinY, minZ, maxZ, minY);
                            vertexAutoMap(minX, minY, minZ, maxZ, sideMinY);
                        }

                        if (maxY > sideMaxY) {
                            vertexAutoMap(minX, sideMaxY, maxZ, minZ, maxY);
                            vertexAutoMap(minX, maxY, maxZ, minZ, sideMaxY);
                            vertexAutoMap(minX, maxY, minZ, maxZ, sideMaxY);
                            vertexAutoMap(minX, sideMaxY, minZ, maxZ, maxY);
                        }
                    }
                } else {
                    vertexAutoMap(minX, minY, maxZ, minZ, maxY);
                    vertexAutoMap(minX, maxY, maxZ, minZ, minY);
                    vertexAutoMap(minX, maxY, minZ, maxZ, minY);
                    vertexAutoMap(minX, minY, minZ, maxZ, maxY);
                }
            }

            if (block.shouldSideBeRendered(blockAccess, i, j, k, 5)) {
                sideBlock = blockAccess.getBlock(i + 1, j, k);
                sideAlpha = sideBlock instanceof BlockGas ? ((BlockGas) sideBlock).getOpacity(blockAccess, i + 1, j, k) : 0F;

                if (sideAlpha > 0.1F) {
                    sideMinY = ((BlockGas) sideBlock).getMinY(blockAccess, i + 1, j, k);
                    sideMaxY = ((BlockGas) sideBlock).getMaxY(blockAccess, i + 1, j, k);

                    if ((minY <= sideMinY & minY <= sideMaxY & maxY <= sideMinY & maxY <= sideMinY) | (minY >= sideMinY & minY >= sideMaxY & maxY >= sideMinY & maxY >= sideMinY)) {
                        vertexAutoMap(maxX, minY, minZ, minZ, maxY);
                        vertexAutoMap(maxX, maxY, minZ, minZ, minY);
                        vertexAutoMap(maxX, maxY, maxZ, maxZ, minY);
                        vertexAutoMap(maxX, minY, maxZ, maxZ, maxY);
                    } else {
                        if (minY < sideMinY) {
                            vertexAutoMap(maxX, minY, minZ, minZ, sideMinY);
                            vertexAutoMap(maxX, sideMinY, minZ, minZ, minY);
                            vertexAutoMap(maxX, sideMinY, maxZ, maxZ, minY);
                            vertexAutoMap(maxX, minY, maxZ, maxZ, sideMinY);
                        }

                        if (maxY > sideMaxY) {
                            vertexAutoMap(maxX, sideMaxY, minZ, minZ, maxY);
                            vertexAutoMap(maxX, maxY, minZ, minZ, sideMaxY);
                            vertexAutoMap(maxX, maxY, maxZ, maxZ, sideMaxY);
                            vertexAutoMap(maxX, sideMaxY, maxZ, maxZ, maxY);
                        }
                    }
                } else {
                    vertexAutoMap(maxX, minY, minZ, minZ, maxY);
                    vertexAutoMap(maxX, maxY, minZ, minZ, minY);
                    vertexAutoMap(maxX, maxY, maxZ, maxZ, minY);
                    vertexAutoMap(maxX, minY, maxZ, maxZ, maxY);
                }
            }

            tessellator.setColorRGBA_F(red * 0.8F, green * 0.8F, blue * 0.8F, alpha * 0.9F);
            if (block.shouldSideBeRendered(blockAccess, i, j, k, 0)) {
                vertexAutoMap(maxX, minY, minZ, maxX, maxZ);
                vertexAutoMap(maxX, minY, maxZ, maxX, minZ);
                vertexAutoMap(minX, minY, maxZ, minX, minZ);
                vertexAutoMap(minX, minY, minZ, minX, maxZ);
            }

            tessellator.setColorRGBA_F(red, green, blue, alpha * 0.9F);
            if (block.shouldSideBeRendered(blockAccess, i, j, k, 1)) {
                vertexAutoMap(maxX, maxY, maxZ, maxX, maxZ);
                vertexAutoMap(maxX, maxY, minZ, maxX, minZ);
                vertexAutoMap(minX, maxY, minZ, minX, minZ);
                vertexAutoMap(minX, maxY, maxZ, minX, maxZ);
            }

            tessellator.addTranslation((float) -i, (float) -j, (float) -k);
        }
            if (verts <= 0) {
                return false;
            } else {
                return true;
            }
	}

	private void vertexAutoMap(double x, double y, double z, double u, double v)
	{
		tessellator.addVertexWithUV(x, y, z, icon.getInterpolatedU(u * 16.0D), icon.getInterpolatedV(v * 16.0D));
		verts += 1;
	}

	@Override
	public boolean shouldRender3DInInventory(int i)
	{
		return true;
	}

	@Override
	public int getRenderId()
	{
		return ObjectHandler.renderGasID;
	}

}

src/main/java/enviromine/blocks/tiles/TileEntityEsky.java
public class TileEntityEsky extends TileEntity implements IInventory
{
	int tick = 0;
	int interval = 30;
	ItemStack[] items = new ItemStack[27];
	long lastCheck = -1;

    public float field_145972_a;
    public float field_145975_i;
    public int numPlayersUsing;
    private int field_145974_k;

	public TileEntityEsky()
	{
	}

	/**
	 * Automatically adjust the use-by date on food items stored within the chest so they rot at half speed
	 */
	@Override
	public void updateEntity()
	{
		super.updateEntity();

		// Chest Code

        if (++this.field_145974_k % 20 * 4 == 0)
        {
            this.worldObj.addBlockEvent(this.xCoord, this.yCoord, this.zCoord, Blocks.ender_chest, 1, this.numPlayersUsing);
        }

        this.field_145975_i = this.field_145972_a;
        float f = 0.1F;
        double d1;

        if (this.numPlayersUsing > 0 && this.field_145972_a == 0.0F)
        {
            double d0 = (double)this.xCoord + 0.5D;
            d1 = (double)this.zCoord + 0.5D;
            //this.worldObj.playSoundEffect(d0, (double)this.yCoord + 0.5D, d1, "random.chestopen", 0.5F, this.worldObj.rand.nextFloat() * 0.1F + 0.9F);
            this.worldObj.playSoundEffect(d0, (double)this.yCoord + 0.5D, d1, "enviromine:eskyopen", 0.5F, this.worldObj.rand.nextFloat() * 0.1F + 0.9F);
        }

        if (this.numPlayersUsing == 0 && this.field_145972_a > 0.0F || this.numPlayersUsing > 0 && this.field_145972_a < 1.0F)
        {
            float f2 = this.field_145972_a;

            if (this.numPlayersUsing > 0)
            {
                this.field_145972_a += f;
            }
            else
            {
                this.field_145972_a -= f;
            }

            if (this.field_145972_a > 1.0F)
            {
                this.field_145972_a = 1.0F;
            }

            float f1 = 0.5F;

            if (this.field_145972_a < f1 && f2 >= f1)
            {
                d1 = (double)this.xCoord + 0.5D;
                double d2 = (double)this.zCoord + 0.5D;
                //this.worldObj.playSoundEffect(d1, (double)this.yCoord + 0.5D, d2, "random.chestclosed", 0.5F, this.worldObj.rand.nextFloat() * 0.1F + 0.9F);
                this.worldObj.playSoundEffect(d1, (double)this.yCoord + 0.5D, d2, "enviromine:eskyclose", 0.5F, this.worldObj.rand.nextFloat() * 0.1F + 0.9F);
            }

            if (this.field_145972_a < 0.0F)
            {
                this.field_145972_a = 0.0F;
            }
        }

        // Esky Code

		if(this.getWorldObj() == null)
		{
			return;
		}

		if(lastCheck <= -1)
		{
			lastCheck = worldObj.getTotalWorldTime();
		}

		if(tick >= interval && !this.worldObj.isRemote)
		{
			tick = 0;

			long time = worldObj.getTotalWorldTime() - lastCheck;
			lastCheck = worldObj.getTotalWorldTime();

			for(int i = 0; i < this.getSizeInventory(); i++)
			{
				ItemStack stack = this.getStackInSlot(i);

				if(stack == null)
				{
					continue;
				}

				RotProperties rotProps = null;
				long rotTime = (long)(EM_Settings.foodRotTime * 24000L);

				if(EM_Settings.rotProperties.containsKey("" + Item.itemRegistry.getNameForObject(stack.getItem())))
				{
					rotProps = EM_Settings.rotProperties.get("" + Item.itemRegistry.getNameForObject(stack.getItem()));
					rotTime = (long)(rotProps.days * 24000L);
				} else if(EM_Settings.rotProperties.containsKey("" + Item.itemRegistry.getNameForObject(stack.getItem()) + "," + stack.getItemDamage()))
				{
					rotProps = EM_Settings.rotProperties.get("" + Item.itemRegistry.getNameForObject(stack.getItem()) + "," + stack.getItemDamage());
					rotTime = (long)(rotProps.days * 24000L);
				}

				if(!EM_Settings.foodSpoiling || (rotProps == null && !(stack.getItem() instanceof ItemFood)) || rotTime < 0)
				{
					if(stack.getTagCompound() != null)
					{
						if(stack.getTagCompound().hasKey("EM_ROT_DATE"))
						{
							stack.getTagCompound().removeTag("EM_ROT_DATE");
						}
						if(stack.getTagCompound().hasKey("EM_ROT_TIME"))
						{
							stack.getTagCompound().removeTag("EM_ROT_TIME");
						}
					}
				} else
				{
					if(stack.getTagCompound() == null)
					{
						stack.setTagCompound(new NBTTagCompound());
					}
					NBTTagCompound tags = stack.getTagCompound();

					if(tags.hasKey("EM_ROT_DATE"))
					{
						tags.setLong("EM_ROT_DATE", tags.getLong("EM_ROT_DATE") + time/2);
						tags.setLong("EM_ROT_TIME", tags.getLong("EM_ROT_TIME") + time/2);
					}
				}
			}

			this.markDirty();
		} else
		{
			tick++;
		}
	}

	@Override
	public int getSizeInventory()
	{
		return 27;
	}

	@Override
	public ItemStack getStackInSlot(int slot)
	{
		return items[slot];
	}

	@Override
	public ItemStack decrStackSize(int p_70298_1_, int p_70298_2_)
	{
        if (this.items[p_70298_1_] != null)
        {
            ItemStack itemstack;

            if (this.items[p_70298_1_].stackSize <= p_70298_2_)
            {
                itemstack = this.items[p_70298_1_];
                this.items[p_70298_1_] = null;
                this.markDirty();
                return itemstack;
            }
            else
            {
                itemstack = this.items[p_70298_1_].splitStack(p_70298_2_);

                if (this.items[p_70298_1_].stackSize == 0)
                {
                    this.items[p_70298_1_] = null;
                }

                this.markDirty();
                return itemstack;
            }
        }
        else
        {
            return null;
        }
	}

	@Override
	public ItemStack getStackInSlotOnClosing(int p_70304_1_)
	{
        if (this.items[p_70304_1_] != null)
        {
            ItemStack itemstack = this.items[p_70304_1_];
            this.items[p_70304_1_] = null;
            return itemstack;
        }
        else
        {
            return null;
        }
	}

	@Override
	public void setInventorySlotContents(int slot, ItemStack stack)
	{
        this.items[slot] = stack;

        if (stack != null && stack.stackSize > this.getInventoryStackLimit())
        {
            stack.stackSize = this.getInventoryStackLimit();
        }

        this.markDirty();
	}

	@Override
	public String getInventoryName()
	{
        return "container.enviromine.esky";
	}

	@Override
	public boolean hasCustomInventoryName()
	{
		return false;
	}

	@Override
	public int getInventoryStackLimit()
	{
		return 64;
	}

	@Override
	public void markDirty()
	{
	}

	@Override
	public boolean isUseableByPlayer(EntityPlayer player)
	{
        return this.worldObj.getTileEntity(this.xCoord, this.yCoord, this.zCoord) != this ? false : player.getDistanceSq((double)this.xCoord + 0.5D, (double)this.yCoord + 0.5D, (double)this.zCoord + 0.5D) <= 64.0D;
	}

    /**
     * Called when a client event is received with the event number and argument, see World.sendClientEvent
     */
	@Override
    public boolean receiveClientEvent(int p_145842_1_, int p_145842_2_)
    {
        if (p_145842_1_ == 1)
        {
            this.numPlayersUsing = p_145842_2_;
            return true;
        }
        else
        {
            return super.receiveClientEvent(p_145842_1_, p_145842_2_);
        }
    }

	@Override
	public void openInventory()
	{
        if (this.numPlayersUsing < 0)
        {
            this.numPlayersUsing = 0;
        }

        ++this.numPlayersUsing;
        this.worldObj.addBlockEvent(this.xCoord, this.yCoord, this.zCoord, this.getBlockType(), 1, this.numPlayersUsing);
        this.worldObj.notifyBlocksOfNeighborChange(this.xCoord, this.yCoord, this.zCoord, this.getBlockType());
        this.worldObj.notifyBlocksOfNeighborChange(this.xCoord, this.yCoord - 1, this.zCoord, this.getBlockType());
	}

	@Override
	public void closeInventory()
	{
        if (this.getBlockType() instanceof BlockEsky)
        {
            --this.numPlayersUsing;
            this.worldObj.addBlockEvent(this.xCoord, this.yCoord, this.zCoord, this.getBlockType(), 1, this.numPlayersUsing);
            this.worldObj.notifyBlocksOfNeighborChange(this.xCoord, this.yCoord, this.zCoord, this.getBlockType());
            this.worldObj.notifyBlocksOfNeighborChange(this.xCoord, this.yCoord - 1, this.zCoord, this.getBlockType());
        }
	}

	@Override
	public boolean isItemValidForSlot(int slot, ItemStack stack)
	{
		return true;
	}

	@Override
	public void readFromNBT(NBTTagCompound tags)
	{
        super.readFromNBT(tags);

        if(tags.hasKey("RotCheck"))
        {
        	this.lastCheck = tags.getLong("RotCheck");
        } else
        {
        	this.lastCheck = -1;
        }

        NBTTagList nbttaglist = tags.getTagList("Items", 10);
        this.items = new ItemStack[this.getSizeInventory()];

        for (int i = 0; i < nbttaglist.tagCount(); ++i)
        {
            NBTTagCompound nbttagcompound1 = nbttaglist.getCompoundTagAt(i);
            int j = nbttagcompound1.getByte("Slot") & 255;

            if (j >= 0 && j < this.items.length)
            {
                this.items[j] = ItemStack.loadItemStackFromNBT(nbttagcompound1);
            }
        }
	}

	@Override
	public void writeToNBT(NBTTagCompound tags)
	{
		super.writeToNBT(tags);
        NBTTagList nbttaglist = new NBTTagList();

        for (int i = 0; i < this.items.length; ++i)
        {
            if (this.items[i] != null)
            {
                NBTTagCompound nbttagcompound1 = new NBTTagCompound();
                nbttagcompound1.setByte("Slot", (byte)i);
                this.items[i].writeToNBT(nbttagcompound1);
                nbttaglist.appendTag(nbttagcompound1);
            }
        }

        tags.setTag("Items", nbttaglist);
        tags.setLong("RotCheck", this.lastCheck);
	}

}

src/main/java/enviromine/EntityPhysicsBlock.java
public class EntityPhysicsBlock extends EntityFallingBlock implements IEntityAdditionalSpawnData
{

	public boolean isAnvil2 = true;
	public boolean isBreakingAnvil2;
	public int fallHurtMax2;
	public float fallHurtAmount2;
	public boolean isLandSlide = false;
	public boolean earthquake = false;

	public int fallTime = 0;

	public Block block;
	public int meta;

	public EntityPhysicsBlock(World world)
	{
		super(world);
		this.isAnvil2 = true;
		this.fallHurtMax2 = 40;
		this.fallHurtAmount2 = 2.0F;

		if(EM_Settings.entityFailsafe > 0 && !world.isRemote)
		{
			@SuppressWarnings("unchecked")
			List<EntityPhysicsBlock> entityList = this.worldObj.getEntitiesWithinAABB(EntityPhysicsBlock.class, this.boundingBox.expand(8F, 8F, 8F));

			if(entityList.size() >= 1024)
			{
				if(EM_Settings.entityFailsafe == 1)
				{
					if (EM_Settings.loggerVerbosity >= EnumLogVerbosity.NORMAL.getLevel())
					{
						EnviroMine.logger.log(Level.WARN, "Entity fail safe activated! Canceling new entities!");
						EnviroMine.logger.log(Level.WARN, "Location: " + this.posX + "," + this.posY + "," + this.posZ);
						EnviroMine.logger.log(Level.WARN, "No.: " + entityList.size());
					}
					EM_PhysManager.physSchedule.clear();
					this.setDead();
					return;
				} else if(EM_Settings.entityFailsafe >= 2)
				{
					if (EM_Settings.loggerVerbosity >= EnumLogVerbosity.NORMAL.getLevel())
					{
						EnviroMine.logger.log(Level.ERROR, "Entity fail safe activated! Deleting excess entities!");
						EnviroMine.logger.log(Level.ERROR, "Location: " + this.posX + "," + this.posY + "," + this.posZ);
						EnviroMine.logger.log(Level.ERROR, "No.: " + entityList.size());
					}
					Iterator<EntityPhysicsBlock> iterator = entityList.iterator();

					while(iterator.hasNext())
					{
						EntityPhysicsBlock oldPhysBlock = iterator.next();
						if(!oldPhysBlock.isDead)
						{
							oldPhysBlock.setDead();
						}
					}
					this.setDead();

					EM_PhysManager.physSchedule.clear();
					return;
				}
			}
		}
	}

	public EntityPhysicsBlock(World world, double x, double y, double z, Block block, int meta, boolean update)
	{
		super(world, x, y, z, flowerID(block), meta);
		this.isAnvil2 = true;
		this.fallHurtMax2 = 40;
		this.fallHurtAmount2 = 2.0F;
		this.block = block;
		this.meta = meta;

		if(EM_Settings.entityFailsafe > 0 && !world.isRemote)
		{
			@SuppressWarnings("unchecked")
			List<EntityPhysicsBlock> entityList = this.worldObj.getEntitiesWithinAABB(EntityPhysicsBlock.class, this.boundingBox.expand(8F, 8F, 8F));

			if(entityList.size() >= 512)
			{
				if(EM_Settings.entityFailsafe == 1)
				{
					if (EM_Settings.loggerVerbosity >= EnumLogVerbosity.NORMAL.getLevel())
					{
						EnviroMine.logger.log(Level.WARN, "Entity fail safe activated: Level 1");
						EnviroMine.logger.log(Level.WARN, "Location: " + this.posX + "," + this.posY + "," + this.posZ);
						EnviroMine.logger.log(Level.WARN, "No.: " + entityList.size());
					}
					EM_PhysManager.physSchedule.clear();
					this.setDead();
					return;
				} else if(EM_Settings.entityFailsafe >= 2)
				{
					if (EM_Settings.loggerVerbosity >= EnumLogVerbosity.NORMAL.getLevel())
					{
						EnviroMine.logger.log(Level.ERROR, "Entity fail safe activated: Level 2");
						EnviroMine.logger.log(Level.ERROR, "Location: " + this.posX + "," + this.posY + "," + this.posZ);
						EnviroMine.logger.log(Level.ERROR, "No.: " + entityList.size());
					}
					Iterator<EntityPhysicsBlock> iterator = entityList.iterator();

					while(iterator.hasNext())
					{
						EntityPhysicsBlock oldPhysBlock = iterator.next();
						if(!oldPhysBlock.isDead)
						{
							oldPhysBlock.setDead();
						}
					}
					this.setDead();

					EM_PhysManager.physSchedule.clear();
					return;
				}
			}
		}

		EM_PhysManager.usedSlidePositions.add("" + MathHelper.floor_double(this.posX) + "," + MathHelper.floor_double(this.posZ));

		if(update)
		{
			EM_PhysManager.schedulePhysUpdate(world, (int)Math.floor(x), (int)Math.floor(y), (int)Math.floor(z), false, earthquake? "Quake" : "Collapse");
		}
	}

	public static Block flowerID(Block block)
	{
		if(block instanceof BlockFlower)
		{
			return Blocks.air;
		} else
		{
			return block;
		}
	}

	@Override
	/**
	 * Returns true if other Entities should be prevented from moving through this Entity.
	 */
	public boolean canBeCollidedWith()
	{
		return false;
	}

	@SuppressWarnings("rawtypes")
	@Override
	public void onUpdate()
	{
		if(this.block == null || this.block == Blocks.air)
		{
			this.setDead();
		} else
		{
			this.prevPosX = this.posX;
			this.prevPosY = this.posY;
			this.prevPosZ = this.posZ;
			++this.fallTime;
			this.motionY -= 0.03999999910593033D;
			this.moveEntity(this.motionX, this.motionY, this.motionZ);
			this.motionX *= 0.9800000190734863D;
			this.motionY *= 0.9800000190734863D;
			this.motionZ *= 0.9800000190734863D;

			if(!this.worldObj.isRemote)
			{
				int i = MathHelper.floor_double(this.posX);
				int j = MathHelper.floor_double(this.posY);
				int k = MathHelper.floor_double(this.posZ);

				if(this.fallTime == 1)
				{
					if(this.worldObj.getBlock(i, j, k) != this.block && !isLandSlide)
					{
						this.setDead();
						return;
					}

					@SuppressWarnings("unchecked")
					List<Entity> before = ((List<Entity>)this.worldObj.getEntitiesWithinAABB(EntityItem.class, this.boundingBox.expand(1, 1, 1)));
					this.worldObj.setBlockToAir(i, j, k);
					@SuppressWarnings("unchecked")
					List<Entity> after = ((List<Entity>)this.worldObj.getEntitiesWithinAABB(EntityItem.class, this.boundingBox.expand(1, 1, 1)));

					for (Entity e : before) {
						after.remove(e);
					}

					for (Entity e : after) {
						e.setDead();
					}
				}

				try
				{
			        AxisAlignedBB axisalignedbb = block.getCollisionBoundingBoxFromPool(this.worldObj, i, j - 1, k);
			        if(axisalignedbb != null)
			        {
			        	List fallingBlocks = this.worldObj.getEntitiesWithinAABB(EntityPhysicsBlock.class, axisalignedbb);

			        	fallingBlocks.remove(this);

				        if(fallingBlocks.size() >= 1 && isLandSlide)
				        {
				        	this.motionY = 0;
				        	this.setPosition(i + 0.5D, j + 0.5D, k + 0.5D);
				        }
			        }
				} catch(NullPointerException e)
				{
				}

				if(earthquake)
				{
					for(int jj = j; j >= MathHelper.ceiling_double_int(motionY); j --)
					{
						if(jj <= 5)
						{
							this.setDead();
							return;
						} else if(this.worldObj.getBlock(i, jj, k).getMaterial() == Material.lava)
						{
							this.setDead();
							return;
						} else if(this.worldObj.getBlock(i, jj, k).getMaterial() == Material.water)
						{
							this.setDead();
							return;
						} else if(this.worldObj.getBlock(i, jj, k) == Blocks.obsidian || this.worldObj.getBlock(i, jj, k) == Blocks.cobblestone)
						{
							if(this.worldObj.getBlock(i, jj - 1, k).getMaterial() == Material.lava)
							{
								this.setDead();
								return;
							}
						}
					}
				}

				if(this.onGround)
				{
					this.motionX *= 0.699999988079071D;
					this.motionZ *= 0.699999988079071D;
					this.motionY *= -0.5D;

					if(this.worldObj.getBlock(i, j, k) != Blocks.piston_extension)
					{
						this.setDead();

						if(!this.worldObj.canPlaceEntityOnSide(Blocks.anvil, i, j, k, true, 1, (Entity)null, (ItemStack)null) && !EM_PhysManager.blockNotSolid(this.worldObj, i, j, k, false))
						{
							j += 1;
						}

						if((this.block == Blocks.snow_layer && this.worldObj.getBlock(i, j, k) == Blocks.snow_layer && this.worldObj.getBlockMetadata(i, j, k) < 15) || (!this.isBreakingAnvil2 && this.worldObj.canPlaceEntityOnSide(Blocks.anvil, i, j, k, true, 1, (Entity)null, (ItemStack)null) && !BlockFalling.func_149831_e(this.worldObj, i, j - 1, k) && this.worldObj.setBlock(i, j, k, this.block, this.meta, 3)))
						{
							if(this.block == Blocks.snow_layer && this.worldObj.getBlock(i, j, k) == Blocks.snow_layer && this.worldObj.getBlockMetadata(i, j, k) < 15)
							{
								if(this.worldObj.getBlockMetadata(i, j, k) >= 14)
								{
									this.worldObj.setBlock(i, j, k, Blocks.snow);
								} else
								{
									this.worldObj.setBlockMetadataWithNotify(i, j, k, this.worldObj.getBlockMetadata(i, j, k) + 1, 3);
								}
							} else if(meta != this.worldObj.getBlockMetadata(i, j, k))
							{
								this.worldObj.setBlockMetadataWithNotify(i, j, k, meta, 2);
							}

							EM_PhysManager.schedulePhysUpdate(this.worldObj, i, j, k, true, earthquake? "Quake" : "Collapse");

							/*if(block instanceof BlockFalling)
							{
								((BlockFalling)block).func_149828_a(this.worldObj, i, j, k, this.meta);
							}*/

							Block bSurface = null;
							if(this.worldObj.getBlock(i, j - 1, k) != Blocks.air && this.worldObj.getBlock(i, j - 1, k).getMaterial() != Material.air)
							{
								bSurface = this.worldObj.getBlock(i, j -1 , k);
								this.worldObj.playSoundEffect((double)((float)i + 0.5F), (double)((float)j + 0.5F), (double)((float)k + 0.5F), bSurface.stepSound.func_150496_b(), (bSurface.stepSound.getVolume() + 1.0F) / 2.0F, bSurface.stepSound.getPitch() * 0.5F);
							}

							if(bSurface == null || bSurface != this.block)
							{
								this.worldObj.playSoundEffect((double)((float)i + 0.5F), (double)((float)j + 0.5F), (double)((float)k + 0.5F), this.block.stepSound.func_150496_b(), (this.block.stepSound.getVolume() + 1.0F) / 2.0F, this.block.stepSound.getPitch() * 0.5F);
							}

							if(this.field_145810_d != null && block instanceof ITileEntityProvider)
							{
								TileEntity tileentity = this.worldObj.getTileEntity(i, j, k);

								if(tileentity != null)
								{
									NBTTagCompound nbttagcompound = new NBTTagCompound();
									tileentity.writeToNBT(nbttagcompound);
									Iterator iterator = this.field_145810_d.func_150296_c().iterator();

                                    while (iterator.hasNext())
                                    {
                                        String s = (String)iterator.next();
                                        NBTBase nbtbase = this.field_145810_d.getTag(s);

                                        if (!s.equals("x") && !s.equals("y") && !s.equals("z"))
                                        {
                                            nbttagcompound.setTag(s, nbtbase.copy());
                                        }
                                    }

                                    tileentity.readFromNBT(nbttagcompound);
                                    tileentity.markDirty();
								}
							}
						} else if(this.field_145813_c && !this.isBreakingAnvil2 && !earthquake)
						{
							this.entityDropItem(new ItemStack(this.block, 1, this.block.damageDropped(this.meta)), 0.0F);
						}
					}
				} else if(this.fallTime > 100 && !this.worldObj.isRemote && (j < 1 || j > 256) || this.fallTime > 600)
				{
					if(this.field_145813_c && !earthquake)
					{
						this.entityDropItem(new ItemStack(this.block, 1, this.block.damageDropped(this.meta)), 0.0F);
					}

					this.setDead();
				}
			}
		}
	}

	@SuppressWarnings({"unchecked", "rawtypes"})
	@Override
	protected void fall(float par1)
	{
		if(this.isAnvil2)
		{
			int i = MathHelper.ceiling_float_int(par1 - 1.0F);

			if(isLandSlide)
			{
				i = 2;
			}

			if(i > 0)
			{
				ArrayList arraylist = new ArrayList(this.worldObj.getEntitiesWithinAABBExcludingEntity(this, this.boundingBox));

				DamageSource damagesource;

				if(isLandSlide)
				{
					if(this.block.getMaterial() == Material.snow)
					{
						damagesource = EnviroDamageSource.avalanche;
					} else
					{
						damagesource = EnviroDamageSource.landslide;
					}
				} else
				{
					damagesource = this.block == Blocks.anvil ? DamageSource.anvil : DamageSource.fallingBlock;
				}

				Iterator iterator = arraylist.iterator();

				while(iterator.hasNext())
				{
					Entity entity = (Entity)iterator.next();
					entity.attackEntityFrom(damagesource, (float)Math.min(MathHelper.floor_float((float)i * this.fallHurtAmount2), this.fallHurtMax2));
				}

				if(this.block == Blocks.anvil && (double)this.rand.nextFloat() < 0.05000000074505806D + (double)i * 0.05D)
				{
					int j = this.meta >> 2;
					int k = this.meta & 3;
					++j;

					if(j > 2)
					{
						this.isBreakingAnvil2 = true;
					} else
					{
						this.meta = k | j << 2;
					}
				}
			}
		}
	}

    /**
     * (abstract) Protected helper method to write subclass entity data to NBT.
     */
	@Override
    protected void writeEntityToNBT(NBTTagCompound par1NBTTagCompound)
    {
    	super.writeEntityToNBT(par1NBTTagCompound);
    	par1NBTTagCompound.setByte("Tile", (byte)Block.getIdFromBlock(this.block));
    	par1NBTTagCompound.setInteger("TileID", Block.getIdFromBlock(this.block));
    	par1NBTTagCompound.setByte("Data", (byte)this.meta);
        par1NBTTagCompound.setBoolean("HurtEntities2", this.isAnvil2);
        par1NBTTagCompound.setFloat("FallHurtAmount2", this.fallHurtAmount2);
        par1NBTTagCompound.setInteger("FallHurtMax2", this.fallHurtMax2);
        par1NBTTagCompound.setBoolean("Landslide", this.isLandSlide);
    }

    /**
     * (abstract) Protected helper method to read subclass entity data from NBT.
     */
    @Override
    protected void readEntityFromNBT(NBTTagCompound par1NBTTagCompound)
    {
    	super.readEntityFromNBT(par1NBTTagCompound);

        if (par1NBTTagCompound.hasKey("TileID", 99))
        {
            this.block = Block.getBlockById(par1NBTTagCompound.getInteger("TileID"));
        }
        else
        {
            this.block = Block.getBlockById(par1NBTTagCompound.getByte("Tile") & 255);
        }

        this.meta = par1NBTTagCompound.getByte("Data") & 255;

        if (par1NBTTagCompound.hasKey("HurtEntities2"))
        {
            this.isAnvil2 = par1NBTTagCompound.getBoolean("HurtEntities2");
            this.fallHurtAmount2 = par1NBTTagCompound.getFloat("FallHurtAmount2");
            this.fallHurtMax2 = par1NBTTagCompound.getInteger("FallHurtMax2");
        }
        else if (this.block == Blocks.anvil)
        {
            this.isAnvil2 = true;
        }
        this.isLandSlide = par1NBTTagCompound.getBoolean("Landslide");
    }

	@Override
	public void writeSpawnData(ByteBuf buffer)
	{
		NBTTagCompound tags = new NBTTagCompound();
		this.writeEntityToNBT(tags);

		ByteBufUtils.writeTag(buffer, tags);
	}

	@Override
	public void readSpawnData(ByteBuf additionalData)
	{
		NBTTagCompound tags = ByteBufUtils.readTag(additionalData);
		this.readEntityFromNBT(tags);
	}
}

Answer: ClientRegistry.bindTileEntitySpecialRenderer(TileEntityDavyLamp.class, new TileEntityDavyLampRenderer());

<think>
The EM_ClientProxy.initRenderers() method registers renderers for various tile entities. After binding the TileEntityElevator renderer, the next logical registration is for the TileEntityEsky renderer, using the same ClientRegistry.bindTileEntitySpecialRenderer pattern.
</think>
ClientRegistry.bindTileEntitySpecialRenderer(TileEntityEsky.class, new TileEntityEskyRenderer());