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