    001    package net.minecraft.client;
    002
    003    import cpw.mods.fml.common.Side;
    004    import cpw.mods.fml.common.asm.SideOnly;
    005    import java.awt.BorderLayout;
    006    import java.awt.Canvas;
    007    import java.awt.Color;
    008    import java.awt.Component;
    009    import java.awt.Dimension;
    010    import java.awt.Frame;
    011    import java.awt.Graphics;
    012    import java.io.File;
    013    import java.io.IOException;
    014    import java.nio.ByteBuffer;
    015    import java.text.DecimalFormat;
    016    import java.util.HashMap;
    017    import java.util.List;
    018
    019    import javax.swing.JPanel;
    020
    021    import net.minecraft.src.AchievementList;
    022    import net.minecraft.src.AnvilSaveConverter;
    023    import net.minecraft.src.AxisAlignedBB;
    024    import net.minecraft.src.Block;
    025    import net.minecraft.src.CallableClientMemoryStats;
    026    import net.minecraft.src.CallableClientProfiler;
    027    import net.minecraft.src.CallableGLInfo;
    028    import net.minecraft.src.CallableLWJGLVersion;
    029    import net.minecraft.src.CallableModded;
    030    import net.minecraft.src.CallableTexturePack;
    031    import net.minecraft.src.CallableType2;
    032    import net.minecraft.src.ColorizerFoliage;
    033    import net.minecraft.src.ColorizerGrass;
    034    import net.minecraft.src.ColorizerWater;
    035    import net.minecraft.src.CrashReport;
    036    import net.minecraft.src.EffectRenderer;
    037    import net.minecraft.src.EntityBoat;
    038    import net.minecraft.src.EntityClientPlayerMP;
    039    import net.minecraft.src.EntityItemFrame;
    040    import net.minecraft.src.EntityList;
    041    import net.minecraft.src.EntityLiving;
    042    import net.minecraft.src.EntityMinecart;
    043    import net.minecraft.src.EntityPainting;
    044    import net.minecraft.src.EntityRenderer;
    045    import net.minecraft.src.EnumMovingObjectType;
    046    import net.minecraft.src.EnumOS;
    047    import net.minecraft.src.EnumOSHelper;
    048    import net.minecraft.src.EnumOptions;
    049    import net.minecraft.src.FontRenderer;
    050    import net.minecraft.src.GLAllocation;
    051    import net.minecraft.src.GameSettings;
    052    import net.minecraft.src.GameWindowListener;
    053    import net.minecraft.src.GuiAchievement;
    054    import net.minecraft.src.GuiChat;
    055    import net.minecraft.src.GuiConnecting;
    056    import net.minecraft.src.GuiErrorScreen;
    057    import net.minecraft.src.GuiGameOver;
    058    import net.minecraft.src.GuiIngame;
    059    import net.minecraft.src.GuiIngameMenu;
    060    import net.minecraft.src.GuiInventory;
    061    import net.minecraft.src.GuiMainMenu;
    062    import net.minecraft.src.GuiMemoryErrorScreen;
    063    import net.minecraft.src.GuiScreen;
    064    import net.minecraft.src.GuiSleepMP;
    065    import net.minecraft.src.HttpUtil;
    066    import net.minecraft.src.INetworkManager;
    067    import net.minecraft.src.IPlayerUsage;
    068    import net.minecraft.src.ISaveFormat;
    069    import net.minecraft.src.ISaveHandler;
    070    import net.minecraft.src.IntegratedServer;
    071    import net.minecraft.src.Item;
    072    import net.minecraft.src.ItemRenderer;
    073    import net.minecraft.src.ItemStack;
    074    import net.minecraft.src.KeyBinding;
    075    import net.minecraft.src.LoadingScreenRenderer;
    076    import net.minecraft.src.MathHelper;
    077    import net.minecraft.src.MemoryConnection;
    078    import net.minecraft.src.MinecraftError;
    079    import net.minecraft.src.MinecraftFakeLauncher;
    080    import net.minecraft.src.MouseHelper;
    081    import net.minecraft.src.MovementInputFromOptions;
    082    import net.minecraft.src.MovingObjectPosition;
    083    import net.minecraft.src.NetClientHandler;
    084    import net.minecraft.src.OpenGlHelper;
    085    import net.minecraft.src.Packet3Chat;
    086    import net.minecraft.src.PlayerControllerMP;
    087    import net.minecraft.src.PlayerUsageSnooper;
    088    import net.minecraft.src.Profiler;
    089    import net.minecraft.src.ProfilerResult;
    090    import net.minecraft.src.RenderBlocks;
    091    import net.minecraft.src.RenderEngine;
    092    import net.minecraft.src.RenderGlobal;
    093    import net.minecraft.src.RenderManager;
    094    import net.minecraft.src.ReportedException;
    095    import net.minecraft.src.ScaledResolution;
    096    import net.minecraft.src.ScreenShotHelper;
    097    import net.minecraft.src.ServerData;
    098    import net.minecraft.src.Session;
    099    import net.minecraft.src.SoundManager;
    100    import net.minecraft.src.StatCollector;
    101    import net.minecraft.src.StatFileWriter;
    102    import net.minecraft.src.StatList;
    103    import net.minecraft.src.StatStringFormatKeyInv;
    104    import net.minecraft.src.StringTranslate;
    105    import net.minecraft.src.Tessellator;
    106    import net.minecraft.src.TextureCompassFX;
    107    import net.minecraft.src.TextureFlamesFX;
    108    import net.minecraft.src.TextureLavaFX;
    109    import net.minecraft.src.TextureLavaFlowFX;
    110    import net.minecraft.src.TexturePackList;
    111    import net.minecraft.src.TexturePortalFX;
    112    import net.minecraft.src.TextureWatchFX;
    113    import net.minecraft.src.TextureWaterFX;
    114    import net.minecraft.src.TextureWaterFlowFX;
    115    import net.minecraft.src.ThreadClientSleep;
    116    import net.minecraft.src.ThreadDownloadResources;
    117    import net.minecraft.src.ThreadShutdown;
    118    import net.minecraft.src.Timer;
    119    import net.minecraft.src.WorldClient;
    120    import net.minecraft.src.WorldInfo;
    121    import net.minecraft.src.WorldRenderer;
    122    import net.minecraft.src.WorldSettings;
    123    import net.minecraftforge.common.ForgeHooks;
    124    import net.minecraftforge.event.ForgeEventFactory;
    125    import net.minecraftforge.event.entity.player.PlayerInteractEvent.Action;
    126
    127    import org.lwjgl.LWJGLException;
    128    import org.lwjgl.Sys;
    129    import org.lwjgl.input.Keyboard;
    130    import org.lwjgl.input.Mouse;
    131    import org.lwjgl.opengl.ContextCapabilities;
    132    import org.lwjgl.opengl.Display;
    133    import org.lwjgl.opengl.DisplayMode;
    134    import org.lwjgl.opengl.GL11;
    135    import org.lwjgl.opengl.GL20;
    136    import org.lwjgl.opengl.GLContext;
    137    import org.lwjgl.opengl.PixelFormat;
    138    import org.lwjgl.util.glu.GLU;
    139
    140    import cpw.mods.fml.client.FMLClientHandler;
    141    import cpw.mods.fml.common.FMLCommonHandler;
    142    import cpw.mods.fml.common.Side;
    143    import cpw.mods.fml.relauncher.ArgsWrapper;
    144    import cpw.mods.fml.relauncher.FMLRelauncher;
    145
    146    @SideOnly(Side.CLIENT)
    147    public abstract class Minecraft implements Runnable, IPlayerUsage
    148    {
    149        /** A 10MiB preallocation to ensure the heap is reasonably sized. */
    150        public static byte[] memoryReserve = new byte[10485760];
    151        private ServerData currentServerData;
    152
    153        /**
    154         * Set to 'this' in Minecraft constructor; used by some settings get methods
    155         */
    156        private static Minecraft theMinecraft;
    157        public PlayerControllerMP playerController;
    158        private boolean fullscreen = false;
    159        private boolean hasCrashed = false;
    160
    161        /** Instance of CrashReport. */
    162        private CrashReport crashReporter;
    163        public int displayWidth;
    164        public int displayHeight;
    165        private Timer timer = new Timer(20.0F);
    166
    167        /** Instance of PlayerUsageSnooper. */
    168        private PlayerUsageSnooper usageSnooper = new PlayerUsageSnooper("client", this);
    169        public WorldClient theWorld;
    170        public RenderGlobal renderGlobal;
    171        public EntityClientPlayerMP thePlayer;
    172
    173        /**
    174         * The Entity from which the renderer determines the render viewpoint. Currently is always the parent Minecraft
    175         * class's 'thePlayer' instance. Modification of its location, rotation, or other settings at render time will
    176         * modify the camera likewise, with the caveat of triggering chunk rebuilds as it moves, making it unsuitable for
    177         * changing the viewpoint mid-render.
    178         */
    179        public EntityLiving renderViewEntity;
    180        public EffectRenderer effectRenderer;
    181        public Session session = null;
    182        public String minecraftUri;
    183        public Canvas mcCanvas;
    184
    185        /** a boolean to hide a Quit button from the main menu */
    186        public boolean hideQuitButton = false;
    187        public volatile boolean isGamePaused = false;
    188
    189        /** The RenderEngine instance used by Minecraft */
    190        public RenderEngine renderEngine;
    191
    192        /** The font renderer used for displaying and measuring text. */
    193        public FontRenderer fontRenderer;
    194        public FontRenderer standardGalacticFontRenderer;
    195
    196        /** The GuiScreen that's being displayed at the moment. */
    197        public GuiScreen currentScreen = null;
    198        public LoadingScreenRenderer loadingScreen;
    199        public EntityRenderer entityRenderer;
    200
    201        /** Reference to the download resources thread. */
    202        private ThreadDownloadResources downloadResourcesThread;
    203
    204        /** Mouse left click counter */
    205        private int leftClickCounter = 0;
    206
    207        /** Display width */
    208        private int tempDisplayWidth;
    209
    210        /** Display height */
    211        private int tempDisplayHeight;
    212
    213        /** Instance of IntegratedServer. */
    214        private IntegratedServer theIntegratedServer;
    215
    216        /** Gui achievement */
    217        public GuiAchievement guiAchievement = new GuiAchievement(this);
    218        public GuiIngame ingameGUI;
    219
    220        /** Skip render world */
    221        public boolean skipRenderWorld = false;
    222
    223        /** The ray trace hit that the mouse is over. */
    224        public MovingObjectPosition objectMouseOver = null;
    225
    226        /** The game settings that currently hold effect. */
    227        public GameSettings gameSettings;
    228        protected MinecraftApplet mcApplet;
    229        public SoundManager sndManager = new SoundManager();
    230
    231        /** Mouse helper instance. */
    232        public MouseHelper mouseHelper;
    233
    234        /** The TexturePackLister used by this instance of Minecraft... */
    235        public TexturePackList texturePackList;
    236        public File mcDataDir;
    237        private ISaveFormat saveLoader;
    238
    239        /**
    240         * This is set to fpsCounter every debug screen update, and is shown on the debug screen. It's also sent as part of
    241         * the usage snooping.
    242         */
    243        private static int debugFPS;
    244
    245        /**
    246         * When you place a block, it's set to 6, decremented once per tick, when it's 0, you can place another block.
    247         */
    248        private int rightClickDelayTimer = 0;
    249
    250        /**
    251         * Checked in Minecraft's while(running) loop, if true it's set to false and the textures refreshed.
    252         */
    253        private boolean refreshTexturePacksScheduled;
    254
    255        /** Stat file writer */
    256        public StatFileWriter statFileWriter;
    257        private String serverName;
    258        private int serverPort;
    259        private TextureWaterFX textureWaterFX = new TextureWaterFX();
    260        private TextureLavaFX textureLavaFX = new TextureLavaFX();
    261
    262        /**
    263         * Makes sure it doesn't keep taking screenshots when both buttons are down.
    264         */
    265        boolean isTakingScreenshot = false;
    266
    267        /**
    268         * Does the actual gameplay have focus. If so then mouse and keys will effect the player instead of menus.
    269         */
    270        public boolean inGameHasFocus = false;
    271        long systemTime = getSystemTime();
    272
    273        /** Join player counter */
    274        private int joinPlayerCounter = 0;
    275        private boolean isDemo;
    276        private INetworkManager myNetworkManager;
    277        private boolean integratedServerIsRunning;
    278
    279        /** The profiler instance */
    280        public final Profiler mcProfiler = new Profiler();
    281        private long field_83002_am = -1L;
    282
    283        /** The working dir (OS specific) for minecraft */
    284        private static File minecraftDir = null;
    285
    286        /**
    287         * Set to true to keep the game loop running. Set to false by shutdown() to allow the game loop to exit cleanly.
    288         */
    289        public volatile boolean running = true;
    290
    291        /** String that shows the debug information */
    292        public String debug = "";
    293
    294        /** Approximate time (in ms) of last update to debug string */
    295        long debugUpdateTime = getSystemTime();
    296
    297        /** holds the current fps */
    298        int fpsCounter = 0;
    299        long prevFrameTime = -1L;
    300
    301        /** Profiler currently displayed in the debug screen pie chart */
    302        private String debugProfilerName = "root";
    303
    304        public Minecraft(Canvas par1Canvas, MinecraftApplet par2MinecraftApplet, int par3, int par4, boolean par5)
    305        {
    306            StatList.func_75919_a();
    307            this.tempDisplayHeight = par4;
    308            this.fullscreen = par5;
    309            this.mcApplet = par2MinecraftApplet;
    310            Packet3Chat.maxChatLength = 32767;
    311            this.startTimerHackThread();
    312            this.mcCanvas = par1Canvas;
    313            this.displayWidth = par3;
    314            this.displayHeight = par4;
    315            this.fullscreen = par5;
    316            theMinecraft = this;
    317        }
    318
    319        private void startTimerHackThread()
    320        {
    321            ThreadClientSleep var1 = new ThreadClientSleep(this, "Timer hack thread");
    322            var1.setDaemon(true);
    323            var1.start();
    324        }
    325
    326        public void crashed(CrashReport par1CrashReport)
    327        {
    328            this.hasCrashed = true;
    329            this.crashReporter = par1CrashReport;
    330        }
    331
    332        /**
    333         * Wrapper around displayCrashReportInternal
    334         */
    335        public void displayCrashReport(CrashReport par1CrashReport)
    336        {
    337            this.hasCrashed = true;
    338            this.displayCrashReportInternal(par1CrashReport);
    339        }
    340
    341        public abstract void displayCrashReportInternal(CrashReport var1);
    342
    343        public void setServer(String par1Str, int par2)
    344        {
    345            this.serverName = par1Str;
    346            this.serverPort = par2;
    347        }
    348
    349        /**
    350         * Starts the game: initializes the canvas, the title, the settings, etcetera.
    351         */
    352        public void startGame() throws LWJGLException
    353        {
    354            if (this.mcCanvas != null)
    355            {
    356                Graphics var1 = this.mcCanvas.getGraphics();
    357
    358                if (var1 != null)
    359                {
    360                    var1.setColor(Color.BLACK);
    361                    var1.fillRect(0, 0, this.displayWidth, this.displayHeight);
    362                    var1.dispose();
    363                }
    364
    365                Display.setParent(this.mcCanvas);
    366            }
    367            else if (this.fullscreen)
    368            {
    369                Display.setFullscreen(true);
    370                this.displayWidth = Display.getDisplayMode().getWidth();
    371                this.displayHeight = Display.getDisplayMode().getHeight();
    372
    373                if (this.displayWidth <= 0)
    374                {
    375                    this.displayWidth = 1;
    376                }
    377
    378                if (this.displayHeight <= 0)
    379                {
    380                    this.displayHeight = 1;
    381                }
    382            }
    383            else
    384            {
    385                Display.setDisplayMode(new DisplayMode(this.displayWidth, this.displayHeight));
    386            }
    387
    388            Display.setTitle("Minecraft Minecraft 1.4.2");
    389            System.out.println("LWJGL Version: " + Sys.getVersion());
    390
    391            try
    392            {
    393                Display.create((new PixelFormat()).withDepthBits(24));
    394            }
    395            catch (LWJGLException var5)
    396            {
    397                var5.printStackTrace();
    398
    399                try
    400                {
    401                    Thread.sleep(1000L);
    402                }
    403                catch (InterruptedException var4)
    404                {
    405                    ;
    406                }
    407
    408                Display.create();
    409            }
    410
    411            OpenGlHelper.initializeTextures();
    412            this.mcDataDir = getMinecraftDir();
    413            this.saveLoader = new AnvilSaveConverter(new File(this.mcDataDir, "saves"));
    414            this.gameSettings = new GameSettings(this, this.mcDataDir);
    415            this.texturePackList = new TexturePackList(this.mcDataDir, this);
    416            this.renderEngine = new RenderEngine(this.texturePackList, this.gameSettings);
    417            this.loadScreen();
    418            this.fontRenderer = new FontRenderer(this.gameSettings, "/font/default.png", this.renderEngine, false);
    419            this.standardGalacticFontRenderer = new FontRenderer(this.gameSettings, "/font/alternate.png", this.renderEngine, false);
    420            FMLClientHandler.instance().beginMinecraftLoading(this);
    421            if (this.gameSettings.language != null)
    422            {
    423                StringTranslate.getInstance().setLanguage(this.gameSettings.language);
    424                this.fontRenderer.setUnicodeFlag(StringTranslate.getInstance().isUnicode());
    425                this.fontRenderer.setBidiFlag(StringTranslate.isBidirectional(this.gameSettings.language));
    426            }
    427
    428            ColorizerWater.setWaterBiomeColorizer(this.renderEngine.getTextureContents("/misc/watercolor.png"));
    429            ColorizerGrass.setGrassBiomeColorizer(this.renderEngine.getTextureContents("/misc/grasscolor.png"));
    430            ColorizerFoliage.getFoilageBiomeColorizer(this.renderEngine.getTextureContents("/misc/foliagecolor.png"));
    431            this.entityRenderer = new EntityRenderer(this);
    432            RenderManager.instance.itemRenderer = new ItemRenderer(this);
    433            this.statFileWriter = new StatFileWriter(this.session, this.mcDataDir);
    434            AchievementList.openInventory.setStatStringFormatter(new StatStringFormatKeyInv(this));
    435            this.loadScreen();
    436            Mouse.create();
    437            this.mouseHelper = new MouseHelper(this.mcCanvas);
    438            this.checkGLError("Pre startup");
    439            GL11.glEnable(GL11.GL_TEXTURE_2D);
    440            GL11.glShadeModel(GL11.GL_SMOOTH);
    441            GL11.glClearDepth(1.0D);
    442            GL11.glEnable(GL11.GL_DEPTH_TEST);
    443            GL11.glDepthFunc(GL11.GL_LEQUAL);
    444            GL11.glEnable(GL11.GL_ALPHA_TEST);
    445            GL11.glAlphaFunc(GL11.GL_GREATER, 0.1F);
    446            GL11.glCullFace(GL11.GL_BACK);
    447            GL11.glMatrixMode(GL11.GL_PROJECTION);
    448            GL11.glLoadIdentity();
    449            GL11.glMatrixMode(GL11.GL_MODELVIEW);
    450            this.checkGLError("Startup");
    451            this.sndManager.loadSoundSettings(this.gameSettings);
    452            this.renderEngine.registerTextureFX(this.textureLavaFX);
    453            this.renderEngine.registerTextureFX(this.textureWaterFX);
    454            this.renderEngine.registerTextureFX(new TexturePortalFX());
    455            this.renderEngine.registerTextureFX(new TextureCompassFX(this));
    456            this.renderEngine.registerTextureFX(new TextureWatchFX(this));
    457            this.renderEngine.registerTextureFX(new TextureWaterFlowFX());
    458            this.renderEngine.registerTextureFX(new TextureLavaFlowFX());
    459            this.renderEngine.registerTextureFX(new TextureFlamesFX(0));
    460            this.renderEngine.registerTextureFX(new TextureFlamesFX(1));
    461            this.renderGlobal = new RenderGlobal(this, this.renderEngine);
    462            GL11.glViewport(0, 0, this.displayWidth, this.displayHeight);
    463            this.effectRenderer = new EffectRenderer(this.theWorld, this.renderEngine);
    464
    465            FMLClientHandler.instance().finishMinecraftLoading();
    466
    467            try
    468            {
    469                this.downloadResourcesThread = new ThreadDownloadResources(this.mcDataDir, this);
    470                this.downloadResourcesThread.start();
    471            }
    472            catch (Exception var3)
    473            {
    474                ;
    475            }
    476
    477            this.checkGLError("Post startup");
    478            this.ingameGUI = new GuiIngame(this);
    479
    480            if (this.serverName != null)
    481            {
    482                this.displayGuiScreen(new GuiConnecting(this, this.serverName, this.serverPort));
    483            }
    484            else
    485            {
    486                this.displayGuiScreen(new GuiMainMenu());
    487            }
    488
    489            this.loadingScreen = new LoadingScreenRenderer(this);
    490
    491            if (this.gameSettings.fullScreen && !this.fullscreen)
    492            {
    493                this.toggleFullscreen();
    494            }
    495            FMLClientHandler.instance().onInitializationComplete();
    496        }
    497
    498        /**
    499         * Displays a new screen.
    500         */
    501        private void loadScreen() throws LWJGLException
    502        {
    503            ScaledResolution var1 = new ScaledResolution(this.gameSettings, this.displayWidth, this.displayHeight);
    504            GL11.glClear(16640);
    505            GL11.glMatrixMode(GL11.GL_PROJECTION);
    506            GL11.glLoadIdentity();
    507            GL11.glOrtho(0.0D, var1.getScaledWidth_double(), var1.getScaledHeight_double(), 0.0D, 1000.0D, 3000.0D);
    508            GL11.glMatrixMode(GL11.GL_MODELVIEW);
    509            GL11.glLoadIdentity();
    510            GL11.glTranslatef(0.0F, 0.0F, -2000.0F);
    511            GL11.glViewport(0, 0, this.displayWidth, this.displayHeight);
    512            GL11.glClearColor(0.0F, 0.0F, 0.0F, 0.0F);
    513            GL11.glDisable(GL11.GL_LIGHTING);
    514            GL11.glEnable(GL11.GL_TEXTURE_2D);
    515            GL11.glDisable(GL11.GL_FOG);
    516            Tessellator var2 = Tessellator.instance;
    517            GL11.glBindTexture(GL11.GL_TEXTURE_2D, this.renderEngine.getTexture("/title/mojang.png"));
    518            var2.startDrawingQuads();
    519            var2.setColorOpaque_I(16777215);
    520            var2.addVertexWithUV(0.0D, (double)this.displayHeight, 0.0D, 0.0D, 0.0D);
    521            var2.addVertexWithUV((double)this.displayWidth, (double)this.displayHeight, 0.0D, 0.0D, 0.0D);
    522            var2.addVertexWithUV((double)this.displayWidth, 0.0D, 0.0D, 0.0D, 0.0D);
    523            var2.addVertexWithUV(0.0D, 0.0D, 0.0D, 0.0D, 0.0D);
    524            var2.draw();
    525            GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
    526            var2.setColorOpaque_I(16777215);
    527            short var3 = 256;
    528            short var4 = 256;
    529            this.scaledTessellator((var1.getScaledWidth() - var3) / 2, (var1.getScaledHeight() - var4) / 2, 0, 0, var3, var4);
    530            GL11.glDisable(GL11.GL_LIGHTING);
    531            GL11.glDisable(GL11.GL_FOG);
    532            GL11.glEnable(GL11.GL_ALPHA_TEST);
    533            GL11.glAlphaFunc(GL11.GL_GREATER, 0.1F);
    534            Display.swapBuffers();
    535        }
    536
    537        /**
    538         * Loads Tessellator with a scaled resolution
    539         */
    540        public void scaledTessellator(int par1, int par2, int par3, int par4, int par5, int par6)
    541        {
    542            float var7 = 0.00390625F;
    543            float var8 = 0.00390625F;
    544            Tessellator var9 = Tessellator.instance;
    545            var9.startDrawingQuads();
    546            var9.addVertexWithUV((double)(par1 + 0), (double)(par2 + par6), 0.0D, (double)((float)(par3 + 0) * var7), (double)((float)(par4 + par6) * var8));
    547            var9.addVertexWithUV((double)(par1 + par5), (double)(par2 + par6), 0.0D, (double)((float)(par3 + par5) * var7), (double)((float)(par4 + par6) * var8));
    548            var9.addVertexWithUV((double)(par1 + par5), (double)(par2 + 0), 0.0D, (double)((float)(par3 + par5) * var7), (double)((float)(par4 + 0) * var8));
    549            var9.addVertexWithUV((double)(par1 + 0), (double)(par2 + 0), 0.0D, (double)((float)(par3 + 0) * var7), (double)((float)(par4 + 0) * var8));
    550            var9.draw();
    551        }
    552
    553        /**
    554         * gets the working dir (OS specific) for minecraft
    555         */
    556        public static File getMinecraftDir()
    557        {
    558            if (minecraftDir == null)
    559            {
    560                minecraftDir = getAppDir("minecraft");
    561            }
    562
    563            return minecraftDir;
    564        }
    565
    566        /**
    567         * gets the working dir (OS specific) for the specific application (which is always minecraft)
    568         */
    569        public static File getAppDir(String par0Str)
    570        {
    571            String var1 = System.getProperty("user.home", ".");
    572            File var2;
    573
    574            switch (EnumOSHelper.enumOSMappingHelperArray[getOs().ordinal()])
    575            {
    576                case 1:
    577                case 2:
    578                    var2 = new File(var1, '.' + par0Str + '/');
    579                    break;
    580                case 3:
    581                    String var3 = System.getenv("APPDATA");
    582
    583                    if (var3 != null)
    584                    {
    585                        var2 = new File(var3, "." + par0Str + '/');
    586                    }
    587                    else
    588                    {
    589                        var2 = new File(var1, '.' + par0Str + '/');
    590                    }
    591
    592                    break;
    593                case 4:
    594                    var2 = new File(var1, "Library/Application Support/" + par0Str);
    595                    break;
    596                default:
    597                    var2 = new File(var1, par0Str + '/');
    598            }
    599
    600            if (!var2.exists() && !var2.mkdirs())
    601            {
    602                throw new RuntimeException("The working directory could not be created: " + var2);
    603            }
    604            else
    605            {
    606                return var2;
    607            }
    608        }
    609
    610        public static EnumOS getOs()
    611        {
    612            String var0 = System.getProperty("os.name").toLowerCase();
    613            return var0.contains("win") ? EnumOS.WINDOWS : (var0.contains("mac") ? EnumOS.MACOS : (var0.contains("solaris") ? EnumOS.SOLARIS : (var0.contains("sunos") ? EnumOS.SOLARIS : (var0.contains("linux") ? EnumOS.LINUX : (var0.contains("unix") ? EnumOS.LINUX : EnumOS.UNKNOWN)))));
    614        }
    615
    616        /**
    617         * Returns the save loader that is currently being used
    618         */
    619        public ISaveFormat getSaveLoader()
    620        {
    621            return this.saveLoader;
    622        }
    623
    624        /**
    625         * Sets the argument GuiScreen as the main (topmost visible) screen.
    626         */
    627        public void displayGuiScreen(GuiScreen par1GuiScreen)
    628        {
    629            if (!(this.currentScreen instanceof GuiErrorScreen))
    630            {
    631                if (this.currentScreen != null)
    632                {
    633                    this.currentScreen.onGuiClosed();
    634                }
    635
    636                this.statFileWriter.syncStats();
    637
    638                if (par1GuiScreen == null && this.theWorld == null)
    639                {
    640                    par1GuiScreen = new GuiMainMenu();
    641                }
    642                else if (par1GuiScreen == null && this.thePlayer.getHealth() <= 0)
    643                {
    644                    par1GuiScreen = new GuiGameOver();
    645                }
    646
    647                if (par1GuiScreen instanceof GuiMainMenu)
    648                {
    649                    this.gameSettings.showDebugInfo = false;
    650                    this.ingameGUI.getChatGUI().func_73761_a();
    651                }
    652
    653                this.currentScreen = (GuiScreen)par1GuiScreen;
    654
    655                if (par1GuiScreen != null)
    656                {
    657                    this.setIngameNotInFocus();
    658                    ScaledResolution var2 = new ScaledResolution(this.gameSettings, this.displayWidth, this.displayHeight);
    659                    int var3 = var2.getScaledWidth();
    660                    int var4 = var2.getScaledHeight();
    661                    ((GuiScreen)par1GuiScreen).setWorldAndResolution(this, var3, var4);
    662                    this.skipRenderWorld = false;
    663                }
    664                else
    665                {
    666                    this.setIngameFocus();
    667                }
    668            }
    669        }
    670
    671        /**
    672         * Checks for an OpenGL error. If there is one, prints the error ID and error string.
    673         */
    674        private void checkGLError(String par1Str)
    675        {
    676            int var2 = GL11.glGetError();
    677
    678            if (var2 != 0)
    679            {
    680                String var3 = GLU.gluErrorString(var2);
    681                System.out.println("########## GL ERROR ##########");
    682                System.out.println("@ " + par1Str);
    683                System.out.println(var2 + ": " + var3);
    684            }
    685        }
    686
    687        /**
    688         * Shuts down the minecraft applet by stopping the resource downloads, and clearing up GL stuff; called when the
    689         * application (or web page) is exited.
    690         */
    691        public void shutdownMinecraftApplet()
    692        {
    693            try
    694            {
    695                this.statFileWriter.syncStats();
    696
    697                try
    698                {
    699                    if (this.downloadResourcesThread != null)
    700                    {
    701                        this.downloadResourcesThread.closeMinecraft();
    702                    }
    703                }
    704                catch (Exception var9)
    705                {
    706                    ;
    707                }
    708
    709                System.out.println("Stopping!");
    710
    711                try
    712                {
    713                    this.loadWorld((WorldClient)null);
    714                }
    715                catch (Throwable var8)
    716                {
    717                    ;
    718                }
    719
    720                try
    721                {
    722                    GLAllocation.deleteTexturesAndDisplayLists();
    723                }
    724                catch (Throwable var7)
    725                {
    726                    ;
    727                }
    728
    729                this.sndManager.closeMinecraft();
    730                Mouse.destroy();
    731                Keyboard.destroy();
    732            }
    733            finally
    734            {
    735                Display.destroy();
    736
    737                if (!this.hasCrashed)
    738                {
    739                    System.exit(0);
    740                }
    741            }
    742
    743            System.gc();
    744        }
    745
    746        public void run()
    747        {
    748            this.running = true;
    749
    750            try
    751            {
    752                this.startGame();
    753            }
    754            catch (Exception var11)
    755            {
    756                var11.printStackTrace();
    757                this.displayCrashReport(this.addGraphicsAndWorldToCrashReport(new CrashReport("Failed to start game", var11)));
    758                return;
    759            }
    760
    761            try
    762            {
    763                while (this.running)
    764                {
    765                    if (this.hasCrashed && this.crashReporter != null)
    766                    {
    767                        this.displayCrashReport(this.crashReporter);
    768                        return;
    769                    }
    770
    771                    if (this.refreshTexturePacksScheduled)
    772                    {
    773                        this.refreshTexturePacksScheduled = false;
    774                        this.renderEngine.refreshTextures();
    775                    }
    776
    777                    try
    778                    {
    779                        this.runGameLoop();
    780                    }
    781                    catch (OutOfMemoryError var10)
    782                    {
    783                        this.freeMemory();
    784                        this.displayGuiScreen(new GuiMemoryErrorScreen());
    785                        System.gc();
    786                    }
    787                }
    788            }
    789            catch (MinecraftError var12)
    790            {
    791                ;
    792            }
    793            catch (ReportedException var13)
    794            {
    795                this.addGraphicsAndWorldToCrashReport(var13.getTheReportedExceptionCrashReport());
    796                this.freeMemory();
    797                var13.printStackTrace();
    798                this.displayCrashReport(var13.getTheReportedExceptionCrashReport());
    799            }
    800            catch (Throwable var14)
    801            {
    802                CrashReport var2 = this.addGraphicsAndWorldToCrashReport(new CrashReport("Unexpected error", var14));
    803                this.freeMemory();
    804                var14.printStackTrace();
    805                this.displayCrashReport(var2);
    806            }
    807            finally
    808            {
    809                this.shutdownMinecraftApplet();
    810            }
    811        }
    812
    813        /**
    814         * Called repeatedly from run()
    815         */
    816        private void runGameLoop()
    817        {
    818            if (this.mcApplet != null && !this.mcApplet.isActive())
    819            {
    820                this.running = false;
    821            }
    822            else
    823            {
    824                AxisAlignedBB.getAABBPool().cleanPool();
    825
    826                if (this.theWorld != null)
    827                {
    828                    this.theWorld.getWorldVec3Pool().clear();
    829                }
    830
    831                this.mcProfiler.startSection("root");
    832
    833                if (this.mcCanvas == null && Display.isCloseRequested())
    834                {
    835                    this.shutdown();
    836                }
    837
    838                if (this.isGamePaused && this.theWorld != null)
    839                {
    840                    float var1 = this.timer.renderPartialTicks;
    841                    this.timer.updateTimer();
    842                    this.timer.renderPartialTicks = var1;
    843                }
    844                else
    845                {
    846                    this.timer.updateTimer();
    847                }
    848
    849                long var6 = System.nanoTime();
    850                this.mcProfiler.startSection("tick");
    851
    852                for (int var3 = 0; var3 < this.timer.elapsedTicks; ++var3)
    853                {
    854                    this.runTick();
    855                }
    856
    857                this.mcProfiler.endStartSection("preRenderErrors");
    858                long var7 = System.nanoTime() - var6;
    859                this.checkGLError("Pre render");
    860                RenderBlocks.fancyGrass = this.gameSettings.fancyGraphics;
    861                this.mcProfiler.endStartSection("sound");
    862                this.sndManager.setListener(this.thePlayer, this.timer.renderPartialTicks);
    863                this.mcProfiler.endSection();
    864                this.mcProfiler.startSection("render");
    865                this.mcProfiler.startSection("display");
    866                GL11.glEnable(GL11.GL_TEXTURE_2D);
    867
    868                if (!Keyboard.isKeyDown(65))
    869                {
    870                    Display.update();
    871                }
    872
    873                if (this.thePlayer != null && this.thePlayer.isEntityInsideOpaqueBlock())
    874                {
    875                    this.gameSettings.thirdPersonView = 0;
    876                }
    877
    878                this.mcProfiler.endSection();
    879
    880                if (!this.skipRenderWorld)
    881                {
    882                    FMLCommonHandler.instance().onRenderTickStart(this.timer.renderPartialTicks);
    883                    this.mcProfiler.endStartSection("gameRenderer");
    884                    this.entityRenderer.updateCameraAndRender(this.timer.renderPartialTicks);
    885                    this.mcProfiler.endSection();
    886                    FMLCommonHandler.instance().onRenderTickEnd(this.timer.renderPartialTicks);
    887                }
    888
    889                GL11.glFlush();
    890                this.mcProfiler.endSection();
    891
    892                if (!Display.isActive() && this.fullscreen)
    893                {
    894                    this.toggleFullscreen();
    895                }
    896
    897                if (this.gameSettings.showDebugInfo && this.gameSettings.showDebugProfilerChart)
    898                {
    899                    if (!this.mcProfiler.profilingEnabled)
    900                    {
    901                        this.mcProfiler.clearProfiling();
    902                    }
    903
    904                    this.mcProfiler.profilingEnabled = true;
    905                    this.displayDebugInfo(var7);
    906                }
    907                else
    908                {
    909                    this.mcProfiler.profilingEnabled = false;
    910                    this.prevFrameTime = System.nanoTime();
    911                }
    912
    913                this.guiAchievement.updateAchievementWindow();
    914                this.mcProfiler.startSection("root");
    915                Thread.yield();
    916
    917                if (Keyboard.isKeyDown(65))
    918                {
    919                    Display.update();
    920                }
    921
    922                this.screenshotListener();
    923
    924                if (this.mcCanvas != null && !this.fullscreen && (this.mcCanvas.getWidth() != this.displayWidth || this.mcCanvas.getHeight() != this.displayHeight))
    925                {
    926                    this.displayWidth = this.mcCanvas.getWidth();
    927                    this.displayHeight = this.mcCanvas.getHeight();
    928
    929                    if (this.displayWidth <= 0)
    930                    {
    931                        this.displayWidth = 1;
    932                    }
    933
    934                    if (this.displayHeight <= 0)
    935                    {
    936                        this.displayHeight = 1;
    937                    }
    938
    939                    this.resize(this.displayWidth, this.displayHeight);
    940                }
    941
    942                this.checkGLError("Post render");
    943                ++this.fpsCounter;
    944                boolean var5 = this.isGamePaused;
    945                this.isGamePaused = this.isSingleplayer() && this.currentScreen != null && this.currentScreen.doesGuiPauseGame() && !this.theIntegratedServer.getPublic();
    946
    947                if (this.isIntegratedServerRunning() && this.thePlayer != null && this.thePlayer.sendQueue != null && this.isGamePaused != var5)
    948                {
    949                    ((MemoryConnection)this.thePlayer.sendQueue.getNetManager()).setGamePaused(this.isGamePaused);
    950                }
    951
    952                while (getSystemTime() >= this.debugUpdateTime + 1000L)
    953                {
    954                    debugFPS = this.fpsCounter;
    955                    this.debug = debugFPS + " fps, " + WorldRenderer.chunksUpdated + " chunk updates";
    956                    WorldRenderer.chunksUpdated = 0;
    957                    this.debugUpdateTime += 1000L;
    958                    this.fpsCounter = 0;
    959                    this.usageSnooper.addMemoryStatsToSnooper();
    960
    961                    if (!this.usageSnooper.isSnooperRunning())
    962                    {
    963                        this.usageSnooper.startSnooper();
    964                    }
    965                }
    966
    967                this.mcProfiler.endSection();
    968
    969                if (this.gameSettings.limitFramerate > 0)
    970                {
    971                    EntityRenderer var10000 = this.entityRenderer;
    972                    Display.sync(EntityRenderer.func_78465_a(this.gameSettings.limitFramerate));
    973                }
    974            }
    975        }
    976
    977        public void freeMemory()
    978        {
    979            try
    980            {
    981                memoryReserve = new byte[0];
    982                this.renderGlobal.func_72728_f();
    983            }
    984            catch (Throwable var4)
    985            {
    986                ;
    987            }
    988
    989            try
    990            {
    991                System.gc();
    992                AxisAlignedBB.getAABBPool().clearPool();
    993                this.theWorld.getWorldVec3Pool().clearAndFreeCache();
    994            }
    995            catch (Throwable var3)
    996            {
    997                ;
    998            }
    999
    1000            try
    1001            {
    1002                System.gc();
    1003                this.loadWorld((WorldClient)null);
    1004            }
    1005            catch (Throwable var2)
    1006            {
    1007                ;
    1008            }
    1009
    1010            System.gc();
    1011        }
    1012
    1013        /**
    1014         * checks if keys are down
    1015         */
    1016        private void screenshotListener()
    1017        {
    1018            if (Keyboard.isKeyDown(60))
    1019            {
    1020                if (!this.isTakingScreenshot)
    1021                {
    1022                    this.isTakingScreenshot = true;
    1023                    this.ingameGUI.getChatGUI().printChatMessage(ScreenShotHelper.saveScreenshot(minecraftDir, this.displayWidth, this.displayHeight));
    1024                }
    1025            }
    1026            else
    1027            {
    1028                this.isTakingScreenshot = false;
    1029            }
    1030        }
    1031
    1032        /**
    1033         * Update debugProfilerName in response to number keys in debug screen
    1034         */
    1035        private void updateDebugProfilerName(int par1)
    1036        {
    1037            List var2 = this.mcProfiler.getProfilingData(this.debugProfilerName);
    1038
    1039            if (var2 != null && !var2.isEmpty())
    1040            {
    1041                ProfilerResult var3 = (ProfilerResult)var2.remove(0);
    1042
    1043                if (par1 == 0)
    1044                {
    1045                    if (var3.field_76331_c.length() > 0)
    1046                    {
    1047                        int var4 = this.debugProfilerName.lastIndexOf(".");
    1048
    1049                        if (var4 >= 0)
    1050                        {
    1051                            this.debugProfilerName = this.debugProfilerName.substring(0, var4);
    1052                        }
    1053                    }
    1054                }
    1055                else
    1056                {
    1057                    --par1;
    1058
    1059                    if (par1 < var2.size() && !((ProfilerResult)var2.get(par1)).field_76331_c.equals("unspecified"))
    1060                    {
    1061                        if (this.debugProfilerName.length() > 0)
    1062                        {
    1063                            this.debugProfilerName = this.debugProfilerName + ".";
    1064                        }
    1065
    1066                        this.debugProfilerName = this.debugProfilerName + ((ProfilerResult)var2.get(par1)).field_76331_c;
    1067                    }
    1068                }
    1069            }
    1070        }
    1071
    1072        private void displayDebugInfo(long par1)
    1073        {
    1074            if (this.mcProfiler.profilingEnabled)
    1075            {
    1076                List var3 = this.mcProfiler.getProfilingData(this.debugProfilerName);
    1077                ProfilerResult var4 = (ProfilerResult)var3.remove(0);
    1078                GL11.glClear(256);
    1079                GL11.glMatrixMode(GL11.GL_PROJECTION);
    1080                GL11.glEnable(GL11.GL_COLOR_MATERIAL);
    1081                GL11.glLoadIdentity();
    1082                GL11.glOrtho(0.0D, (double)this.displayWidth, (double)this.displayHeight, 0.0D, 1000.0D, 3000.0D);
    1083                GL11.glMatrixMode(GL11.GL_MODELVIEW);
    1084                GL11.glLoadIdentity();
    1085                GL11.glTranslatef(0.0F, 0.0F, -2000.0F);
    1086                GL11.glLineWidth(1.0F);
    1087                GL11.glDisable(GL11.GL_TEXTURE_2D);
    1088                Tessellator var5 = Tessellator.instance;
    1089                short var6 = 160;
    1090                int var7 = this.displayWidth - var6 - 10;
    1091                int var8 = this.displayHeight - var6 * 2;
    1092                GL11.glEnable(GL11.GL_BLEND);
    1093                var5.startDrawingQuads();
    1094                var5.setColorRGBA_I(0, 200);
    1095                var5.addVertex((double)((float)var7 - (float)var6 * 1.1F), (double)((float)var8 - (float)var6 * 0.6F - 16.0F), 0.0D);
    1096                var5.addVertex((double)((float)var7 - (float)var6 * 1.1F), (double)(var8 + var6 * 2), 0.0D);
    1097                var5.addVertex((double)((float)var7 + (float)var6 * 1.1F), (double)(var8 + var6 * 2), 0.0D);
    1098                var5.addVertex((double)((float)var7 + (float)var6 * 1.1F), (double)((float)var8 - (float)var6 * 0.6F - 16.0F), 0.0D);
    1099                var5.draw();
    1100                GL11.glDisable(GL11.GL_BLEND);
    1101                double var9 = 0.0D;
    1102                int var13;
    1103
    1104                for (int var11 = 0; var11 < var3.size(); ++var11)
    1105                {
    1106                    ProfilerResult var12 = (ProfilerResult)var3.get(var11);
    1107                    var13 = MathHelper.floor_double(var12.field_76332_a / 4.0D) + 1;
    1108                    var5.startDrawing(6);
    1109                    var5.setColorOpaque_I(var12.func_76329_a());
    1110                    var5.addVertex((double)var7, (double)var8, 0.0D);
    1111                    int var14;
    1112                    float var15;
    1113                    float var17;
    1114                    float var16;
    1115
    1116                    for (var14 = var13; var14 >= 0; --var14)
    1117                    {
    1118                        var15 = (float)((var9 + var12.field_76332_a * (double)var14 / (double)var13) * Math.PI * 2.0D / 100.0D);
    1119                        var16 = MathHelper.sin(var15) * (float)var6;
    1120                        var17 = MathHelper.cos(var15) * (float)var6 * 0.5F;
    1121                        var5.addVertex((double)((float)var7 + var16), (double)((float)var8 - var17), 0.0D);
    1122                    }
    1123
    1124                    var5.draw();
    1125                    var5.startDrawing(5);
    1126                    var5.setColorOpaque_I((var12.func_76329_a() & 16711422) >> 1);
    1127
    1128                    for (var14 = var13; var14 >= 0; --var14)
    1129                    {
    1130                        var15 = (float)((var9 + var12.field_76332_a * (double)var14 / (double)var13) * Math.PI * 2.0D / 100.0D);
    1131                        var16 = MathHelper.sin(var15) * (float)var6;
    1132                        var17 = MathHelper.cos(var15) * (float)var6 * 0.5F;
    1133                        var5.addVertex((double)((float)var7 + var16), (double)((float)var8 - var17), 0.0D);
    1134                        var5.addVertex((double)((float)var7 + var16), (double)((float)var8 - var17 + 10.0F), 0.0D);
    1135                    }
    1136
    1137                    var5.draw();
    1138                    var9 += var12.field_76332_a;
    1139                }
    1140
    1141                DecimalFormat var19 = new DecimalFormat("##0.00");
    1142                GL11.glEnable(GL11.GL_TEXTURE_2D);
    1143                String var18 = "";
    1144
    1145                if (!var4.field_76331_c.equals("unspecified"))
    1146                {
    1147                    var18 = var18 + "[0] ";
    1148                }
    1149
    1150                if (var4.field_76331_c.length() == 0)
    1151                {
    1152                    var18 = var18 + "ROOT ";
    1153                }
    1154                else
    1155                {
    1156                    var18 = var18 + var4.field_76331_c + " ";
    1157                }
    1158
    1159                var13 = 16777215;
    1160                this.fontRenderer.drawStringWithShadow(var18, var7 - var6, var8 - var6 / 2 - 16, var13);
    1161                this.fontRenderer.drawStringWithShadow(var18 = var19.format(var4.field_76330_b) + "%", var7 + var6 - this.fontRenderer.getStringWidth(var18), var8 - var6 / 2 - 16, var13);
    1162
    1163                for (int var21 = 0; var21 < var3.size(); ++var21)
    1164                {
    1165                    ProfilerResult var20 = (ProfilerResult)var3.get(var21);
    1166                    String var22 = "";
    1167
    1168                    if (var20.field_76331_c.equals("unspecified"))
    1169                    {
    1170                        var22 = var22 + "[?] ";
    1171                    }
    1172                    else
    1173                    {
    1174                        var22 = var22 + "[" + (var21 + 1) + "] ";
    1175                    }
    1176
    1177                    var22 = var22 + var20.field_76331_c;
    1178                    this.fontRenderer.drawStringWithShadow(var22, var7 - var6, var8 + var6 / 2 + var21 * 8 + 20, var20.func_76329_a());
    1179                    this.fontRenderer.drawStringWithShadow(var22 = var19.format(var20.field_76332_a) + "%", var7 + var6 - 50 - this.fontRenderer.getStringWidth(var22), var8 + var6 / 2 + var21 * 8 + 20, var20.func_76329_a());
    1180                    this.fontRenderer.drawStringWithShadow(var22 = var19.format(var20.field_76330_b) + "%", var7 + var6 - this.fontRenderer.getStringWidth(var22), var8 + var6 / 2 + var21 * 8 + 20, var20.func_76329_a());
    1181                }
    1182            }
    1183        }
    1184
    1185        /**
    1186         * Called when the window is closing. Sets 'running' to false which allows the game loop to exit cleanly.
    1187         */
    1188        public void shutdown()
    1189        {
    1190            this.running = false;
    1191        }
    1192
    1193        /**
    1194         * Will set the focus to ingame if the Minecraft window is the active with focus. Also clears any GUI screen
    1195         * currently displayed
    1196         */
    1197        public void setIngameFocus()
    1198        {
    1199            if (Display.isActive())
    1200            {
    1201                if (!this.inGameHasFocus)
    1202                {
    1203                    this.inGameHasFocus = true;
    1204                    this.mouseHelper.grabMouseCursor();
    1205                    this.displayGuiScreen((GuiScreen)null);
    1206                    this.leftClickCounter = 10000;
    1207                }
    1208            }
    1209        }
    1210
    1211        /**
    1212         * Resets the player keystate, disables the ingame focus, and ungrabs the mouse cursor.
    1213         */
    1214        public void setIngameNotInFocus()
    1215        {
    1216            if (this.inGameHasFocus)
    1217            {
    1218                KeyBinding.unPressAllKeys();
    1219                this.inGameHasFocus = false;
    1220                this.mouseHelper.ungrabMouseCursor();
    1221            }
    1222        }
    1223
    1224        /**
    1225         * Displays the ingame menu
    1226         */
    1227        public void displayInGameMenu()
    1228        {
    1229            if (this.currentScreen == null)
    1230            {
    1231                this.displayGuiScreen(new GuiIngameMenu());
    1232
    1233                if (this.isSingleplayer() && !this.theIntegratedServer.getPublic())
    1234                {
    1235                    this.sndManager.pauseAllSounds();
    1236                }
    1237            }
    1238        }
    1239
    1240        private void sendClickBlockToController(int par1, boolean par2)
    1241        {
    1242            if (!par2)
    1243            {
    1244                this.leftClickCounter = 0;
    1245            }
    1246
    1247            if (par1 != 0 || this.leftClickCounter <= 0)
    1248            {
    1249                if (par2 && this.objectMouseOver != null && this.objectMouseOver.typeOfHit == EnumMovingObjectType.TILE && par1 == 0)
    1250                {
    1251                    int var3 = this.objectMouseOver.blockX;
    1252                    int var4 = this.objectMouseOver.blockY;
    1253                    int var5 = this.objectMouseOver.blockZ;
    1254                    this.playerController.onPlayerDamageBlock(var3, var4, var5, this.objectMouseOver.sideHit);
    1255
    1256                    if (this.thePlayer.canCurrentToolHarvestBlock(var3, var4, var5))
    1257                    {
    1258                        this.effectRenderer.addBlockHitEffects(var3, var4, var5, this.objectMouseOver);
    1259                        this.thePlayer.swingItem();
    1260                    }
    1261                }
    1262                else
    1263                {
    1264                    this.playerController.resetBlockRemoving();
    1265                }
    1266            }
    1267        }
    1268
    1269        /**
    1270         * Called whenever the mouse is clicked. Button clicked is 0 for left clicking and 1 for right clicking. Args:
    1271         * buttonClicked
    1272         */
    1273        private void clickMouse(int par1)
    1274        {
    1275            if (par1 != 0 || this.leftClickCounter <= 0)
    1276            {
    1277                if (par1 == 0)
    1278                {
    1279                    this.thePlayer.swingItem();
    1280                }
    1281
    1282                if (par1 == 1)
    1283                {
    1284                    this.rightClickDelayTimer = 4;
    1285                }
    1286
    1287                boolean var2 = true;
    1288                ItemStack var3 = this.thePlayer.inventory.getCurrentItem();
    1289
    1290                if (this.objectMouseOver == null)
    1291                {
    1292                    if (par1 == 0 && this.playerController.isNotCreative())
    1293                    {
    1294                        this.leftClickCounter = 10;
    1295                    }
    1296                }
    1297                else if (this.objectMouseOver.typeOfHit == EnumMovingObjectType.ENTITY)
    1298                {
    1299                    if (par1 == 0)
    1300                    {
    1301                        this.playerController.attackEntity(this.thePlayer, this.objectMouseOver.entityHit);
    1302                    }
    1303
    1304                    if (par1 == 1 && this.playerController.func_78768_b(this.thePlayer, this.objectMouseOver.entityHit))
    1305                    {
    1306                        var2 = false;
    1307                    }
    1308                }
    1309                else if (this.objectMouseOver.typeOfHit == EnumMovingObjectType.TILE)
    1310                {
    1311                    int var4 = this.objectMouseOver.blockX;
    1312                    int var5 = this.objectMouseOver.blockY;
    1313                    int var6 = this.objectMouseOver.blockZ;
    1314                    int var7 = this.objectMouseOver.sideHit;
    1315
    1316                    if (par1 == 0)
    1317                    {
    1318                        this.playerController.clickBlock(var4, var5, var6, this.objectMouseOver.sideHit);
    1319                    }
    1320                    else
    1321                    {
    1322                        int var8 = var3 != null ? var3.stackSize : 0;
    1323
    1324                        boolean result = !ForgeEventFactory.onPlayerInteract(thePlayer, Action.RIGHT_CLICK_BLOCK, var4, var5, var6, var7).isCanceled();
    1325                        if (result && this.playerController.onPlayerRightClick(this.thePlayer, this.theWorld, var3, var4, var5, var6, var7, this.objectMouseOver.hitVec))
    1326                        {
    1327                            var2 = false;
    1328                            this.thePlayer.swingItem();
    1329                        }
    1330
    1331                        if (var3 == null)
    1332                        {
    1333                            return;
    1334                        }
    1335
    1336                        if (var3.stackSize == 0)
    1337                        {
    1338                            this.thePlayer.inventory.mainInventory[this.thePlayer.inventory.currentItem] = null;
    1339                        }
    1340                        else if (var3.stackSize != var8 || this.playerController.isInCreativeMode())
    1341                        {
    1342                            this.entityRenderer.itemRenderer.func_78444_b();
    1343                        }
    1344                    }
    1345                }
    1346
    1347                if (var2 && par1 == 1)
    1348                {
    1349                    ItemStack var9 = this.thePlayer.inventory.getCurrentItem();
    1350
    1351                    boolean result = !ForgeEventFactory.onPlayerInteract(thePlayer, Action.RIGHT_CLICK_AIR, 0, 0, 0, -1).isCanceled();
    1352                    if (result && var9 != null && this.playerController.sendUseItem(this.thePlayer, this.theWorld, var9))
    1353                    {
    1354                        this.entityRenderer.itemRenderer.func_78445_c();
    1355                    }
    1356                }
    1357            }
    1358        }
    1359
    1360        /**
    1361         * Toggles fullscreen mode.
    1362         */
    1363        public void toggleFullscreen()
    1364        {
    1365            try
    1366            {
    1367                this.fullscreen = !this.fullscreen;
    1368
    1369                if (this.fullscreen)
    1370                {
    1371                    Display.setDisplayMode(Display.getDesktopDisplayMode());
    1372                    this.displayWidth = Display.getDisplayMode().getWidth();
    1373                    this.displayHeight = Display.getDisplayMode().getHeight();
    1374
    1375                    if (this.displayWidth <= 0)
    1376                    {
    1377                        this.displayWidth = 1;
    1378                    }
    1379
    1380                    if (this.displayHeight <= 0)
    1381                    {
    1382                        this.displayHeight = 1;
    1383                    }
    1384                }
    1385                else
    1386                {
    1387                    if (this.mcCanvas != null)
    1388                    {
    1389                        this.displayWidth = this.mcCanvas.getWidth();
    1390                        this.displayHeight = this.mcCanvas.getHeight();
    1391                    }
    1392                    else
    1393                    {
    1394                        this.displayWidth = this.tempDisplayWidth;
    1395                        this.displayHeight = this.tempDisplayHeight;
    1396                    }
    1397
    1398                    if (this.displayWidth <= 0)
    1399                    {
    1400                        this.displayWidth = 1;
    1401                    }
    1402
    1403                    if (this.displayHeight <= 0)
    1404                    {
    1405                        this.displayHeight = 1;
    1406                    }
    1407                }
    1408
    1409                if (this.currentScreen != null)
    1410                {
    1411                    this.resize(this.displayWidth, this.displayHeight);
    1412                }
    1413
    1414                Display.setFullscreen(this.fullscreen);
    1415                Display.setVSyncEnabled(this.gameSettings.enableVsync);
    1416                Display.update();
    1417            }
    1418            catch (Exception var2)
    1419            {
    1420                var2.printStackTrace();
    1421            }
    1422        }
    1423
    1424        /**
    1425         * Called to resize the current screen.
    1426         */
    1427        private void resize(int par1, int par2)
    1428        {
    1429            this.displayWidth = par1 <= 0 ? 1 : par1;
    1430            this.displayHeight = par2 <= 0 ? 1 : par2;
    1431
    1432            if (this.currentScreen != null)
    1433            {
    1434                ScaledResolution var3 = new ScaledResolution(this.gameSettings, par1, par2);
    1435                int var4 = var3.getScaledWidth();
    1436                int var5 = var3.getScaledHeight();
    1437                this.currentScreen.setWorldAndResolution(this, var4, var5);
    1438            }
    1439        }
    1440
    1441        /**
    1442         * Runs the current tick.
    1443         */
    1444        public void runTick()
    1445        {
    1446            FMLCommonHandler.instance().rescheduleTicks(Side.CLIENT);
    1447            if (this.rightClickDelayTimer > 0)
    1448            {
    1449                --this.rightClickDelayTimer;
    1450            }
    1451
    1452            FMLCommonHandler.instance().onPreClientTick();
    1453            this.mcProfiler.startSection("stats");
    1454            this.statFileWriter.func_77449_e();
    1455            this.mcProfiler.endStartSection("gui");
    1456
    1457            if (!this.isGamePaused)
    1458            {
    1459                this.ingameGUI.updateTick();
    1460            }
    1461
    1462            this.mcProfiler.endStartSection("pick");
    1463            this.entityRenderer.getMouseOver(1.0F);
    1464            this.mcProfiler.endStartSection("gameMode");
    1465
    1466            if (!this.isGamePaused && this.theWorld != null)
    1467            {
    1468                this.playerController.updateController();
    1469            }
    1470
    1471            GL11.glBindTexture(GL11.GL_TEXTURE_2D, this.renderEngine.getTexture("/terrain.png"));
    1472            this.mcProfiler.endStartSection("textures");
    1473
    1474            if (!this.isGamePaused)
    1475            {
    1476                this.renderEngine.updateDynamicTextures();
    1477            }
    1478
    1479            if (this.currentScreen == null && this.thePlayer != null)
    1480            {
    1481                if (this.thePlayer.getHealth() <= 0)
    1482                {
    1483                    this.displayGuiScreen((GuiScreen)null);
    1484                }
    1485                else if (this.thePlayer.isPlayerSleeping() && this.theWorld != null)
    1486                {
    1487                    this.displayGuiScreen(new GuiSleepMP());
    1488                }
    1489            }
    1490            else if (this.currentScreen != null && this.currentScreen instanceof GuiSleepMP && !this.thePlayer.isPlayerSleeping())
    1491            {
    1492                this.displayGuiScreen((GuiScreen)null);
    1493            }
    1494
    1495            if (this.currentScreen != null)
    1496            {
    1497                this.leftClickCounter = 10000;
    1498            }
    1499
    1500            if (this.currentScreen != null)
    1501            {
    1502                this.currentScreen.handleInput();
    1503
    1504                if (this.currentScreen != null)
    1505                {
    1506                    this.currentScreen.guiParticles.update();
    1507                    this.currentScreen.updateScreen();
    1508                }
    1509            }
    1510
    1511            if (this.currentScreen == null || this.currentScreen.allowUserInput)
    1512            {
    1513                this.mcProfiler.endStartSection("mouse");
    1514
    1515                while (Mouse.next())
    1516                {
    1517                    KeyBinding.setKeyBindState(Mouse.getEventButton() - 100, Mouse.getEventButtonState());
    1518
    1519                    if (Mouse.getEventButtonState())
    1520                    {
    1521                        KeyBinding.onTick(Mouse.getEventButton() - 100);
    1522                    }
    1523
    1524                    long var1 = getSystemTime() - this.systemTime;
    1525
    1526                    if (var1 <= 200L)
    1527                    {
    1528                        int var3 = Mouse.getEventDWheel();
    1529
    1530                        if (var3 != 0)
    1531                        {
    1532                            this.thePlayer.inventory.changeCurrentItem(var3);
    1533
    1534                            if (this.gameSettings.noclip)
    1535                            {
    1536                                if (var3 > 0)
    1537                                {
    1538                                    var3 = 1;
    1539                                }
    1540
    1541                                if (var3 < 0)
    1542                                {
    1543                                    var3 = -1;
    1544                                }
    1545
    1546                                this.gameSettings.noclipRate += (float)var3 * 0.25F;
    1547                            }
    1548                        }
    1549
    1550                        if (this.currentScreen == null)
    1551                        {
    1552                            if (!this.inGameHasFocus && Mouse.getEventButtonState())
    1553                            {
    1554                                this.setIngameFocus();
    1555                            }
    1556                        }
    1557                        else if (this.currentScreen != null)
    1558                        {
    1559                            this.currentScreen.handleMouseInput();
    1560                        }
    1561                    }
    1562                }
    1563
    1564                if (this.leftClickCounter > 0)
    1565                {
    1566                    --this.leftClickCounter;
    1567                }
    1568
    1569                this.mcProfiler.endStartSection("keyboard");
    1570                boolean var4;
    1571
    1572                while (Keyboard.next())
    1573                {
    1574                    KeyBinding.setKeyBindState(Keyboard.getEventKey(), Keyboard.getEventKeyState());
    1575
    1576                    if (Keyboard.getEventKeyState())
    1577                    {
    1578                        KeyBinding.onTick(Keyboard.getEventKey());
    1579                    }
    1580
    1581                    if (this.field_83002_am > 0L)
    1582                    {
    1583                        if (getSystemTime() - this.field_83002_am >= 6000L)
    1584                        {
    1585                            throw new ReportedException(new CrashReport("Manually triggered debug crash", new Throwable()));
    1586                        }
    1587
    1588                        if (!Keyboard.isKeyDown(46) || !Keyboard.isKeyDown(61))
    1589                        {
    1590                            this.field_83002_am = -1L;
    1591                        }
    1592                    }
    1593                    else if (Keyboard.isKeyDown(46) && Keyboard.isKeyDown(61))
    1594                    {
    1595                        this.field_83002_am = getSystemTime();
    1596                    }
    1597
    1598                    if (Keyboard.getEventKeyState())
    1599                    {
    1600                        if (Keyboard.getEventKey() == 87)
    1601                        {
    1602                            this.toggleFullscreen();
    1603                        }
    1604                        else
    1605                        {
    1606                            if (this.currentScreen != null)
    1607                            {
    1608                                this.currentScreen.handleKeyboardInput();
    1609                            }
    1610                            else
    1611                            {
    1612                                if (Keyboard.getEventKey() == 1)
    1613                                {
    1614                                    this.displayInGameMenu();
    1615                                }
    1616
    1617                                if (Keyboard.getEventKey() == 31 && Keyboard.isKeyDown(61))
    1618                                {
    1619                                    this.forceReload();
    1620                                }
    1621
    1622                                if (Keyboard.getEventKey() == 20 && Keyboard.isKeyDown(61))
    1623                                {
    1624                                    this.renderEngine.refreshTextures();
    1625                                }
    1626
    1627                                if (Keyboard.getEventKey() == 33 && Keyboard.isKeyDown(61))
    1628                                {
    1629                                    var4 = Keyboard.isKeyDown(42) | Keyboard.isKeyDown(54);
    1630                                    this.gameSettings.setOptionValue(EnumOptions.RENDER_DISTANCE, var4 ? -1 : 1);
    1631                                }
    1632
    1633                                if (Keyboard.getEventKey() == 30 && Keyboard.isKeyDown(61))
    1634                                {
    1635                                    this.renderGlobal.loadRenderers();
    1636                                }
    1637
    1638                                if (Keyboard.getEventKey() == 35 && Keyboard.isKeyDown(61))
    1639                                {
    1640                                    this.gameSettings.advancedItemTooltips = !this.gameSettings.advancedItemTooltips;
    1641                                    this.gameSettings.saveOptions();
    1642                                }
    1643
    1644                                if (Keyboard.getEventKey() == 25 && Keyboard.isKeyDown(61))
    1645                                {
    1646                                    this.gameSettings.pauseOnLostFocus = !this.gameSettings.pauseOnLostFocus;
    1647                                    this.gameSettings.saveOptions();
    1648                                }
    1649
    1650                                if (Keyboard.getEventKey() == 59)
    1651                                {
    1652                                    this.gameSettings.hideGUI = !this.gameSettings.hideGUI;
    1653                                }
    1654
    1655                                if (Keyboard.getEventKey() == 61)
    1656                                {
    1657                                    this.gameSettings.showDebugInfo = !this.gameSettings.showDebugInfo;
    1658                                    this.gameSettings.showDebugProfilerChart = GuiScreen.isShiftKeyDown();
    1659                                }
    1660
    1661                                if (Keyboard.getEventKey() == 63)
    1662                                {
    1663                                    ++this.gameSettings.thirdPersonView;
    1664
    1665                                    if (this.gameSettings.thirdPersonView > 2)
    1666                                    {
    1667                                        this.gameSettings.thirdPersonView = 0;
    1668                                    }
    1669                                }
    1670
    1671                                if (Keyboard.getEventKey() == 66)
    1672                                {
    1673                                    this.gameSettings.smoothCamera = !this.gameSettings.smoothCamera;
    1674                                }
    1675                            }
    1676
    1677                            int var5;
    1678
    1679                            for (var5 = 0; var5 < 9; ++var5)
    1680                            {
    1681                                if (Keyboard.getEventKey() == 2 + var5)
    1682                                {
    1683                                    this.thePlayer.inventory.currentItem = var5;
    1684                                }
    1685                            }
    1686
    1687                            if (this.gameSettings.showDebugInfo && this.gameSettings.showDebugProfilerChart)
    1688                            {
    1689                                if (Keyboard.getEventKey() == 11)
    1690                                {
    1691                                    this.updateDebugProfilerName(0);
    1692                                }
    1693
    1694                                for (var5 = 0; var5 < 9; ++var5)
    1695                                {
    1696                                    if (Keyboard.getEventKey() == 2 + var5)
    1697                                    {
    1698                                        this.updateDebugProfilerName(var5 + 1);
    1699                                    }
    1700                                }
    1701                            }
    1702                        }
    1703                    }
    1704                }
    1705
    1706                var4 = this.gameSettings.chatVisibility != 2;
    1707
    1708                while (this.gameSettings.keyBindInventory.isPressed())
    1709                {
    1710                    this.displayGuiScreen(new GuiInventory(this.thePlayer));
    1711                }
    1712
    1713                while (this.gameSettings.keyBindDrop.isPressed())
    1714                {
    1715                    this.thePlayer.dropOneItem();
    1716                }
    1717
    1718                while (this.gameSettings.keyBindChat.isPressed() && var4)
    1719                {
    1720                    this.displayGuiScreen(new GuiChat());
    1721                }
    1722
    1723                if (this.currentScreen == null && this.gameSettings.keyBindCommand.isPressed() && var4)
    1724                {
    1725                    this.displayGuiScreen(new GuiChat("/"));
    1726                }
    1727
    1728                if (this.thePlayer.isUsingItem())
    1729                {
    1730                    if (!this.gameSettings.keyBindUseItem.pressed)
    1731                    {
    1732                        this.playerController.onStoppedUsingItem(this.thePlayer);
    1733                    }
    1734
    1735                    label338:
    1736
    1737                    while (true)
    1738                    {
    1739                        if (!this.gameSettings.keyBindAttack.isPressed())
    1740                        {
    1741                            while (this.gameSettings.keyBindUseItem.isPressed())
    1742                            {
    1743                                ;
    1744                            }
    1745
    1746                            while (true)
    1747                            {
    1748                                if (this.gameSettings.keyBindPickBlock.isPressed())
    1749                                {
    1750                                    continue;
    1751                                }
    1752
    1753                                break label338;
    1754                            }
    1755                        }
    1756                    }
    1757                }
    1758                else
    1759                {
    1760                    while (this.gameSettings.keyBindAttack.isPressed())
    1761                    {
    1762                        this.clickMouse(0);
    1763                    }
    1764
    1765                    while (this.gameSettings.keyBindUseItem.isPressed())
    1766                    {
    1767                        this.clickMouse(1);
    1768                    }
    1769
    1770                    while (this.gameSettings.keyBindPickBlock.isPressed())
    1771                    {
    1772                        this.clickMiddleMouseButton();
    1773                    }
    1774                }
    1775
    1776                if (this.gameSettings.keyBindUseItem.pressed && this.rightClickDelayTimer == 0 && !this.thePlayer.isUsingItem())
    1777                {
    1778                    this.clickMouse(1);
    1779                }
    1780
    1781                this.sendClickBlockToController(0, this.currentScreen == null && this.gameSettings.keyBindAttack.pressed && this.inGameHasFocus);
    1782            }
    1783
    1784            if (this.theWorld != null)
    1785            {
    1786                if (this.thePlayer != null)
    1787                {
    1788                    ++this.joinPlayerCounter;
    1789
    1790                    if (this.joinPlayerCounter == 30)
    1791                    {
    1792                        this.joinPlayerCounter = 0;
    1793                        this.theWorld.joinEntityInSurroundings(this.thePlayer);
    1794                    }
    1795                }
    1796
    1797                this.mcProfiler.endStartSection("gameRenderer");
    1798
    1799                if (!this.isGamePaused)
    1800                {
    1801                    this.entityRenderer.updateRenderer();
    1802                }
    1803
    1804                this.mcProfiler.endStartSection("levelRenderer");
    1805
    1806                if (!this.isGamePaused)
    1807                {
    1808                    this.renderGlobal.updateClouds();
    1809                }
    1810
    1811                this.mcProfiler.endStartSection("level");
    1812
    1813                if (!this.isGamePaused)
    1814                {
    1815                    if (this.theWorld.lightningFlash > 0)
    1816                    {
    1817                        --this.theWorld.lightningFlash;
    1818                    }
    1819
    1820                    this.theWorld.updateEntities();
    1821                }
    1822
    1823                if (!this.isGamePaused)
    1824                {
    1825                    this.theWorld.setAllowedSpawnTypes(this.theWorld.difficultySetting > 0, true);
    1826                    this.theWorld.tick();
    1827                }
    1828
    1829                this.mcProfiler.endStartSection("animateTick");
    1830
    1831                if (!this.isGamePaused && this.theWorld != null)
    1832                {
    1833                    this.theWorld.func_73029_E(MathHelper.floor_double(this.thePlayer.posX), MathHelper.floor_double(this.thePlayer.posY), MathHelper.floor_double(this.thePlayer.posZ));
    1834                }
    1835
    1836                this.mcProfiler.endStartSection("particles");
    1837
    1838                if (!this.isGamePaused)
    1839                {
    1840                    this.effectRenderer.updateEffects();
    1841                }
    1842            }
    1843            else if (this.myNetworkManager != null)
    1844            {
    1845                this.mcProfiler.endStartSection("pendingConnection");
    1846                this.myNetworkManager.processReadPackets();
    1847            }
    1848
    1849            FMLCommonHandler.instance().onPostClientTick();
    1850            this.mcProfiler.endSection();
    1851            this.systemTime = getSystemTime();
    1852        }
    1853
    1854        /**
    1855         * Forces a reload of the sound manager and all the resources. Called in game by holding 'F3' and pressing 'S'.
    1856         */
    1857        private void forceReload()
    1858        {
    1859            System.out.println("FORCING RELOAD!");
    1860
    1861            if (this.sndManager != null)
    1862            {
    1863                this.sndManager.stopAllSounds();
    1864            }
    1865
    1866            this.sndManager = new SoundManager();
    1867            this.sndManager.loadSoundSettings(this.gameSettings);
    1868            this.downloadResourcesThread.reloadResources();
    1869        }
    1870
    1871        /**
    1872         * Arguments: World foldername,  World ingame name, WorldSettings
    1873         */
    1874        public void launchIntegratedServer(String par1Str, String par2Str, WorldSettings par3WorldSettings)
    1875        {
    1876            this.loadWorld((WorldClient)null);
    1877            System.gc();
    1878            ISaveHandler var4 = this.saveLoader.getSaveLoader(par1Str, false);
    1879            WorldInfo var5 = var4.loadWorldInfo();
    1880
    1881            if (var5 == null && par3WorldSettings != null)
    1882            {
    1883                this.statFileWriter.readStat(StatList.createWorldStat, 1);
    1884                var5 = new WorldInfo(par3WorldSettings, par1Str);
    1885                var4.saveWorldInfo(var5);
    1886            }
    1887
    1888            if (par3WorldSettings == null)
    1889            {
    1890                par3WorldSettings = new WorldSettings(var5);
    1891            }
    1892
    1893            this.statFileWriter.readStat(StatList.startGameStat, 1);
    1894            this.theIntegratedServer = new IntegratedServer(this, par1Str, par2Str, par3WorldSettings);
    1895            this.theIntegratedServer.startServerThread();
    1896            this.integratedServerIsRunning = true;
    1897            this.loadingScreen.displayProgressMessage(StatCollector.translateToLocal("menu.loadingLevel"));
    1898
    1899            while (!this.theIntegratedServer.serverIsInRunLoop())
    1900            {
    1901                String var6 = this.theIntegratedServer.getUserMessage();
    1902
    1903                if (var6 != null)
    1904                {
    1905                    this.loadingScreen.resetProgresAndWorkingMessage(StatCollector.translateToLocal(var6));
    1906                }
    1907                else
    1908                {
    1909                    this.loadingScreen.resetProgresAndWorkingMessage("");
    1910                }
    1911
    1912                try
    1913                {
    1914                    Thread.sleep(200L);
    1915                }
    1916                catch (InterruptedException var9)
    1917                {
    1918                    ;
    1919                }
    1920            }
    1921
    1922            this.displayGuiScreen((GuiScreen)null);
    1923
    1924            try
    1925            {
    1926                NetClientHandler var10 = new NetClientHandler(this, this.theIntegratedServer);
    1927                this.myNetworkManager = var10.getNetManager();
    1928            }
    1929            catch (IOException var8)
    1930            {
    1931                this.displayCrashReport(this.addGraphicsAndWorldToCrashReport(new CrashReport("Connecting to integrated server", var8)));
    1932            }
    1933        }
    1934
    1935        /**
    1936         * unloads the current world first
    1937         */
    1938        public void loadWorld(WorldClient par1WorldClient)
    1939        {
    1940            this.loadWorld(par1WorldClient, "");
    1941        }
    1942
    1943        /**
    1944         * par2Str is displayed on the loading screen to the user unloads the current world first
    1945         */
    1946        public void loadWorld(WorldClient par1WorldClient, String par2Str)
    1947        {
    1948            this.statFileWriter.syncStats();
    1949
    1950            if (par1WorldClient == null)
    1951            {
    1952                NetClientHandler var3 = this.getSendQueue();
    1953
    1954                if (var3 != null)
    1955                {
    1956                    var3.cleanup();
    1957                }
    1958
    1959                if (this.myNetworkManager != null)
    1960                {
    1961                    this.myNetworkManager.closeConnections();
    1962                }
    1963
    1964                if (this.theIntegratedServer != null)
    1965                {
    1966                    this.theIntegratedServer.initiateShutdown();
    1967                    if (loadingScreen!=null)
    1968                    {
    1969                        this.loadingScreen.resetProgresAndWorkingMessage("Shutting down internal server...");
    1970                    }
    1971                    while (!theIntegratedServer.isServerStopped())
    1972                    {
    1973                        try
    1974                        {
    1975                            Thread.sleep(10);
    1976                        }
    1977                        catch (InterruptedException ie) {}
    1978                    }
    1979                }
    1980
    1981                this.theIntegratedServer = null;
    1982            }
    1983
    1984            this.renderViewEntity = null;
    1985            this.myNetworkManager = null;
    1986
    1987            if (this.loadingScreen != null)
    1988            {
    1989                this.loadingScreen.resetProgressAndMessage(par2Str);
    1990                this.loadingScreen.resetProgresAndWorkingMessage("");
    1991            }
    1992
    1993            if (par1WorldClient == null && this.theWorld != null)
    1994            {
    1995                if (this.texturePackList.getIsDownloading())
    1996                {
    1997                    this.texturePackList.onDownloadFinished();
    1998                }
    1999
    2000                this.setServerData((ServerData)null);
    2001                this.integratedServerIsRunning = false;
    2002            }
    2003
    2004            this.sndManager.playStreaming((String)null, 0.0F, 0.0F, 0.0F);
    2005            this.sndManager.stopAllSounds();
    2006            this.theWorld = par1WorldClient;
    2007
    2008            if (par1WorldClient != null)
    2009            {
    2010                if (this.renderGlobal != null)
    2011                {
    2012                    this.renderGlobal.setWorldAndLoadRenderers(par1WorldClient);
    2013                }
    2014
    2015                if (this.effectRenderer != null)
    2016                {
    2017                    this.effectRenderer.clearEffects(par1WorldClient);
    2018                }
    2019
    2020                if (this.thePlayer == null)
    2021                {
    2022                    this.thePlayer = this.playerController.func_78754_a(par1WorldClient);
    2023                    this.playerController.flipPlayer(this.thePlayer);
    2024                }
    2025
    2026                this.thePlayer.preparePlayerToSpawn();
    2027                par1WorldClient.spawnEntityInWorld(this.thePlayer);
    2028                this.thePlayer.movementInput = new MovementInputFromOptions(this.gameSettings);
    2029                this.playerController.setPlayerCapabilities(this.thePlayer);
    2030                this.renderViewEntity = this.thePlayer;
    2031            }
    2032            else
    2033            {
    2034                this.saveLoader.flushCache();
    2035                this.thePlayer = null;
    2036            }
    2037
    2038            System.gc();
    2039            this.systemTime = 0L;
    2040        }
    2041
    2042        /**
    2043         * Installs a resource. Currently only sounds are download so this method just adds them to the SoundManager.
    2044         */
    2045        public void installResource(String par1Str, File par2File)
    2046        {
    2047            int var3 = par1Str.indexOf("/");
    2048            String var4 = par1Str.substring(0, var3);
    2049            par1Str = par1Str.substring(var3 + 1);
    2050
    2051            if (var4.equalsIgnoreCase("sound3"))
    2052            {
    2053                this.sndManager.addSound(par1Str, par2File);
    2054            }
    2055            else if (var4.equalsIgnoreCase("streaming"))
    2056            {
    2057                this.sndManager.addStreaming(par1Str, par2File);
    2058            }
    2059            else if (var4.equalsIgnoreCase("music") || var4.equalsIgnoreCase("newmusic"))
    2060            {
    2061                this.sndManager.addMusic(par1Str, par2File);
    2062            }
    2063        }
    2064
    2065        /**
    2066         * A String of renderGlobal.getDebugInfoRenders
    2067         */
    2068        public String debugInfoRenders()
    2069        {
    2070            return this.renderGlobal.getDebugInfoRenders();
    2071        }
    2072
    2073        /**
    2074         * Gets the information in the F3 menu about how many entities are infront/around you
    2075         */
    2076        public String getEntityDebug()
    2077        {
    2078            return this.renderGlobal.getDebugInfoEntities();
    2079        }
    2080
    2081        /**
    2082         * Gets the name of the world's current chunk provider
    2083         */
    2084        public String getWorldProviderName()
    2085        {
    2086            return this.theWorld.getProviderName();
    2087        }
    2088
    2089        /**
    2090         * A String of how many entities are in the world
    2091         */
    2092        public String debugInfoEntities()
    2093        {
    2094            return "P: " + this.effectRenderer.getStatistics() + ". T: " + this.theWorld.getDebugLoadedEntities();
    2095        }
    2096
    2097        public void setDimensionAndSpawnPlayer(int par1)
    2098        {
    2099            this.theWorld.setSpawnLocation();
    2100            this.theWorld.removeAllEntities();
    2101            int var2 = 0;
    2102
    2103            if (this.thePlayer != null)
    2104            {
    2105                var2 = this.thePlayer.entityId;
    2106                this.theWorld.setEntityDead(this.thePlayer);
    2107            }
    2108
    2109            this.renderViewEntity = null;
    2110            this.thePlayer = this.playerController.func_78754_a(this.theWorld);
    2111            this.thePlayer.dimension = par1;
    2112            this.renderViewEntity = this.thePlayer;
    2113            this.thePlayer.preparePlayerToSpawn();
    2114            this.theWorld.spawnEntityInWorld(this.thePlayer);
    2115            this.playerController.flipPlayer(this.thePlayer);
    2116            this.thePlayer.movementInput = new MovementInputFromOptions(this.gameSettings);
    2117            this.thePlayer.entityId = var2;
    2118            this.playerController.setPlayerCapabilities(this.thePlayer);
    2119
    2120            if (this.currentScreen instanceof GuiGameOver)
    2121            {
    2122                this.displayGuiScreen((GuiScreen)null);
    2123            }
    2124        }
    2125
    2126        /**
    2127         * Sets whether this is a demo or not.
    2128         */
    2129        void setDemo(boolean par1)
    2130        {
    2131            this.isDemo = par1;
    2132        }
    2133
    2134        /**
    2135         * Gets whether this is a demo or not.
    2136         */
    2137        public final boolean isDemo()
    2138        {
    2139            return this.isDemo;
    2140        }
    2141
    2142        /**
    2143         * get the client packet send queue
    2144         */
    2145        public NetClientHandler getSendQueue()
    2146        {
    2147            return this.thePlayer != null ? this.thePlayer.sendQueue : null;
    2148        }
    2149
    2150        public static void main(String[] par0ArrayOfStr)
    2151        {
    2152            FMLRelauncher.handleClientRelaunch(new ArgsWrapper(par0ArrayOfStr));
    2153        }
    2154
    2155        public static void fmlReentry(ArgsWrapper wrapper)
    2156        {
    2157            String[] par0ArrayOfStr = wrapper.args;
    2158            HashMap var1 = new HashMap();
    2159            boolean var2 = false;
    2160            boolean var3 = true;
    2161            boolean var4 = false;
    2162            String var5 = "Player" + getSystemTime() % 1000L;
    2163
    2164            if (par0ArrayOfStr.length > 0)
    2165            {
    2166                var5 = par0ArrayOfStr[0];
    2167            }
    2168
    2169            String var6 = "-";
    2170
    2171            if (par0ArrayOfStr.length > 1)
    2172            {
    2173                var6 = par0ArrayOfStr[1];
    2174            }
    2175
    2176            for (int var7 = 2; var7 < par0ArrayOfStr.length; ++var7)
    2177            {
    2178                String var8 = par0ArrayOfStr[var7];
    2179                String var9 = var7 == par0ArrayOfStr.length - 1 ? null : par0ArrayOfStr[var7 + 1];
    2180                boolean var10 = false;
    2181
    2182                if (!var8.equals("-demo") && !var8.equals("--demo"))
    2183                {
    2184                    if (var8.equals("--applet"))
    2185                    {
    2186                        var3 = false;
    2187                    }
    2188                    else if (var8.equals("--password") && var9 != null)
    2189                    {
    2190                        String[] var11 = HttpUtil.func_82718_a(var5, var9);
    2191
    2192                        if (var11 != null)
    2193                        {
    2194                            var5 = var11[0];
    2195                            var6 = var11[1];
    2196                            System.out.println("Logged in insecurely as " + var5 + " - sessionId is " + var6);
    2197                        }
    2198                        else
    2199                        {
    2200                            System.out.println("Could not log in as " + var5 + " with given password");
    2201                        }
    2202
    2203                        var10 = true;
    2204                    }
    2205                }
    2206                else
    2207                {
    2208                    var2 = true;
    2209                }
    2210
    2211                if (var10)
    2212                {
    2213                    ++var7;
    2214                }
    2215            }
    2216
    2217            var1.put("demo", "" + var2);
    2218            var1.put("stand-alone", "" + var3);
    2219            var1.put("username", var5);
    2220            var1.put("fullscreen", "" + var4);
    2221            var1.put("sessionid", var6);
    2222            Frame var13 = new Frame();
    2223            var13.setTitle("Minecraft");
    2224            var13.setBackground(Color.BLACK);
    2225            JPanel var12 = new JPanel();
    2226            var13.setLayout(new BorderLayout());
    2227            var12.setPreferredSize(new Dimension(854, 480));
    2228            var13.add(var12, "Center");
    2229            var13.pack();
    2230            var13.setLocationRelativeTo((Component)null);
    2231            var13.setVisible(true);
    2232            var13.addWindowListener(new GameWindowListener());
    2233            MinecraftFakeLauncher var14 = new MinecraftFakeLauncher(var1);
    2234            MinecraftApplet var15 = new MinecraftApplet();
    2235            var15.setStub(var14);
    2236            var14.setLayout(new BorderLayout());
    2237            var14.add(var15, "Center");
    2238            var14.validate();
    2239            var13.removeAll();
    2240            var13.setLayout(new BorderLayout());
    2241            var13.add(var14, "Center");
    2242            var13.validate();
    2243            var15.init();
    2244            var15.start();
    2245            Runtime.getRuntime().addShutdownHook(new ThreadShutdown());
    2246        }
    2247
    2248        public static boolean isGuiEnabled()
    2249        {
    2250            return theMinecraft == null || !theMinecraft.gameSettings.hideGUI;
    2251        }
    2252
    2253        public static boolean isFancyGraphicsEnabled()
    2254        {
    2255            return theMinecraft != null && theMinecraft.gameSettings.fancyGraphics;
    2256        }
    2257
    2258        /**
    2259         * Returns if ambient occlusion is enabled
    2260         */
    2261        public static boolean isAmbientOcclusionEnabled()
    2262        {
    2263            return theMinecraft != null && theMinecraft.gameSettings.ambientOcclusion;
    2264        }
    2265
    2266        public static boolean isDebugInfoEnabled()
    2267        {
    2268            return theMinecraft != null && theMinecraft.gameSettings.showDebugInfo;
    2269        }
    2270
    2271        /**
    2272         * Returns true if the message is a client command and should not be sent to the server. However there are no such
    2273         * commands at this point in time.
    2274         */
    2275        public boolean handleClientCommand(String par1Str)
    2276        {
    2277            return !par1Str.startsWith("/") ? false : false;
    2278        }
    2279
    2280        /**
    2281         * Called when the middle mouse button gets clicked
    2282         */
    2283        private void clickMiddleMouseButton()
    2284        {
    2285            if (this.objectMouseOver != null)
    2286            {
    2287                boolean var1 = this.thePlayer.capabilities.isCreativeMode;
    2288                int var5;
    2289
    2290                if (!ForgeHooks.onPickBlock(this.objectMouseOver, this.thePlayer, this.theWorld))
    2291                {
    2292                    return;
    2293                }
    2294
    2295                if (var1)
    2296                {
    2297                    var5 = this.thePlayer.inventorySlots.inventorySlots.size() - 9 + this.thePlayer.inventory.currentItem;
    2298                    this.playerController.sendSlotPacket(this.thePlayer.inventory.getStackInSlot(this.thePlayer.inventory.currentItem), var5);
    2299                }
    2300            }
    2301        }
    2302
    2303        /**
    2304         * adds core server Info (GL version , Texture pack, isModded, type), and the worldInfo to the crash report
    2305         */
    2306        public CrashReport addGraphicsAndWorldToCrashReport(CrashReport par1CrashReport)
    2307        {
    2308            par1CrashReport.addCrashSectionCallable("LWJGL", new CallableLWJGLVersion(this));
    2309            par1CrashReport.addCrashSectionCallable("OpenGL", new CallableGLInfo(this));
    2310            par1CrashReport.addCrashSectionCallable("Is Modded", new CallableModded(this));
    2311            par1CrashReport.addCrashSectionCallable("Type", new CallableType2(this));
    2312            par1CrashReport.addCrashSectionCallable("Texture Pack", new CallableTexturePack(this));
    2313            par1CrashReport.addCrashSectionCallable("Profiler Position", new CallableClientProfiler(this));
    2314            par1CrashReport.addCrashSectionCallable("Vec3 Pool Size", new CallableClientMemoryStats(this));
    2315
    2316            if (this.theWorld != null)
    2317            {
    2318                this.theWorld.addWorldInfoToCrashReport(par1CrashReport);
    2319            }
    2320
    2321            return par1CrashReport;
    2322        }
    2323
    2324        /**
    2325         * Return the singleton Minecraft instance for the game
    2326         */
    2327        public static Minecraft getMinecraft()
    2328        {
    2329            return theMinecraft;
    2330        }
    2331
    2332        /**
    2333         * Sets refreshTexturePacksScheduled to true, triggering a texture pack refresh next time the while(running) loop is
    2334         * run
    2335         */
    2336        public void scheduleTexturePackRefresh()
    2337        {
    2338            this.refreshTexturePacksScheduled = true;
    2339        }
    2340
    2341        public void addServerStatsToSnooper(PlayerUsageSnooper par1PlayerUsageSnooper)
    2342        {
    2343            par1PlayerUsageSnooper.addData("fps", Integer.valueOf(debugFPS));
    2344            par1PlayerUsageSnooper.addData("texpack_name", this.texturePackList.getSelectedTexturePack().getTexturePackFileName());
    2345            par1PlayerUsageSnooper.addData("texpack_resolution", Integer.valueOf(this.texturePackList.getSelectedTexturePack().getTexturePackResolution()));
    2346            par1PlayerUsageSnooper.addData("vsync_enabled", Boolean.valueOf(this.gameSettings.enableVsync));
    2347            par1PlayerUsageSnooper.addData("display_frequency", Integer.valueOf(Display.getDisplayMode().getFrequency()));
    2348            par1PlayerUsageSnooper.addData("display_type", this.fullscreen ? "fullscreen" : "windowed");
    2349
    2350            if (this.theIntegratedServer != null && this.theIntegratedServer.getPlayerUsageSnooper() != null)
    2351            {
    2352                par1PlayerUsageSnooper.addData("snooper_partner", this.theIntegratedServer.getPlayerUsageSnooper().getUniqueID());
    2353            }
    2354        }
    2355
    2356        public void addServerTypeToSnooper(PlayerUsageSnooper par1PlayerUsageSnooper)
    2357        {
    2358            par1PlayerUsageSnooper.addData("opengl_version", GL11.glGetString(GL11.GL_VERSION));
    2359            par1PlayerUsageSnooper.addData("opengl_vendor", GL11.glGetString(GL11.GL_VENDOR));
    2360            par1PlayerUsageSnooper.addData("client_brand", ClientBrandRetriever.getClientModName());
    2361            par1PlayerUsageSnooper.addData("applet", Boolean.valueOf(this.hideQuitButton));
    2362            ContextCapabilities var2 = GLContext.getCapabilities();
    2363            par1PlayerUsageSnooper.addData("gl_caps[ARB_multitexture]", Boolean.valueOf(var2.GL_ARB_multitexture));
    2364            par1PlayerUsageSnooper.addData("gl_caps[ARB_multisample]", Boolean.valueOf(var2.GL_ARB_multisample));
    2365            par1PlayerUsageSnooper.addData("gl_caps[ARB_texture_cube_map]", Boolean.valueOf(var2.GL_ARB_texture_cube_map));
    2366            par1PlayerUsageSnooper.addData("gl_caps[ARB_vertex_blend]", Boolean.valueOf(var2.GL_ARB_vertex_blend));
    2367            par1PlayerUsageSnooper.addData("gl_caps[ARB_matrix_palette]", Boolean.valueOf(var2.GL_ARB_matrix_palette));
    2368            par1PlayerUsageSnooper.addData("gl_caps[ARB_vertex_program]", Boolean.valueOf(var2.GL_ARB_vertex_program));
    2369            par1PlayerUsageSnooper.addData("gl_caps[ARB_vertex_shader]", Boolean.valueOf(var2.GL_ARB_vertex_shader));
    2370            par1PlayerUsageSnooper.addData("gl_caps[ARB_fragment_program]", Boolean.valueOf(var2.GL_ARB_fragment_program));
    2371            par1PlayerUsageSnooper.addData("gl_caps[ARB_fragment_shader]", Boolean.valueOf(var2.GL_ARB_fragment_shader));
    2372            par1PlayerUsageSnooper.addData("gl_caps[ARB_shader_objects]", Boolean.valueOf(var2.GL_ARB_shader_objects));
    2373            par1PlayerUsageSnooper.addData("gl_caps[ARB_vertex_buffer_object]", Boolean.valueOf(var2.GL_ARB_vertex_buffer_object));
    2374            par1PlayerUsageSnooper.addData("gl_caps[ARB_framebuffer_object]", Boolean.valueOf(var2.GL_ARB_framebuffer_object));
    2375            par1PlayerUsageSnooper.addData("gl_caps[ARB_pixel_buffer_object]", Boolean.valueOf(var2.GL_ARB_pixel_buffer_object));
    2376            par1PlayerUsageSnooper.addData("gl_caps[ARB_uniform_buffer_object]", Boolean.valueOf(var2.GL_ARB_uniform_buffer_object));
    2377            par1PlayerUsageSnooper.addData("gl_caps[ARB_texture_non_power_of_two]", Boolean.valueOf(var2.GL_ARB_texture_non_power_of_two));
    2378            par1PlayerUsageSnooper.addData("gl_caps[gl_max_vertex_uniforms]", Integer.valueOf(GL11.glGetInteger(GL20.GL_MAX_VERTEX_UNIFORM_COMPONENTS)));
    2379            par1PlayerUsageSnooper.addData("gl_caps[gl_max_fragment_uniforms]", Integer.valueOf(GL11.glGetInteger(GL20.GL_MAX_FRAGMENT_UNIFORM_COMPONENTS)));
    2380            par1PlayerUsageSnooper.addData("gl_max_texture_size", Integer.valueOf(getGLMaximumTextureSize()));
    2381        }
    2382
    2383        /**
    2384         * Used in the usage snooper.
    2385         */
    2386        private static int getGLMaximumTextureSize()
    2387        {
    2388            for (int var0 = 16384; var0 > 0; var0 >>= 1)
    2389            {
    2390                GL11.glTexImage2D(GL11.GL_PROXY_TEXTURE_2D, 0, GL11.GL_RGBA, var0, var0, 0, GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, (ByteBuffer)null);
    2391                int var1 = GL11.glGetTexLevelParameteri(GL11.GL_PROXY_TEXTURE_2D, 0, GL11.GL_TEXTURE_WIDTH);
    2392
    2393                if (var1 != 0)
    2394                {
    2395                    return var0;
    2396                }
    2397            }
    2398
    2399            return -1;
    2400        }
    2401
    2402        /**
    2403         * Returns whether snooping is enabled or not.
    2404         */
    2405        public boolean isSnooperEnabled()
    2406        {
    2407            return this.gameSettings.snooperEnabled;
    2408        }
    2409
    2410        /**
    2411         * Set the current ServerData instance.
    2412         */
    2413        public void setServerData(ServerData par1ServerData)
    2414        {
    2415            this.currentServerData = par1ServerData;
    2416        }
    2417
    2418        /**
    2419         * Get the current ServerData instance.
    2420         */
    2421        public ServerData getServerData()
    2422        {
    2423            return this.currentServerData;
    2424        }
    2425
    2426        public boolean isIntegratedServerRunning()
    2427        {
    2428            return this.integratedServerIsRunning;
    2429        }
    2430
    2431        /**
    2432         * Returns true if there is only one player playing, and the current server is the integrated one.
    2433         */
    2434        public boolean isSingleplayer()
    2435        {
    2436            return this.integratedServerIsRunning && this.theIntegratedServer != null;
    2437        }
    2438
    2439        /**
    2440         * Returns the currently running integrated server
    2441         */
    2442        public IntegratedServer getIntegratedServer()
    2443        {
    2444            return this.theIntegratedServer;
    2445        }
    2446
    2447        public static void stopIntegratedServer()
    2448        {
    2449            if (theMinecraft != null)
    2450            {
    2451                IntegratedServer var0 = theMinecraft.getIntegratedServer();
    2452
    2453                if (var0 != null)
    2454                {
    2455                    var0.stopServer();
    2456                }
    2457            }
    2458        }
    2459
    2460        /**
    2461         * Returns the PlayerUsageSnooper instance.
    2462         */
    2463        public PlayerUsageSnooper getPlayerUsageSnooper()
    2464        {
    2465            return this.usageSnooper;
    2466        }
    2467
    2468        /**
    2469         * Gets the system time in milliseconds.
    2470         */
    2471        public static long getSystemTime()
    2472        {
    2473            return Sys.getTime() * 1000L / Sys.getTimerResolution();
    2474        }
    2475
    2476        /**
    2477         * Returns whether we're in full screen or not.
    2478         */
    2479        public boolean isFullScreen()
    2480        {
    2481            return this.fullscreen;
    2482        }
    2483    }