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