public static byte field_28006_b[] = new byte[0xa00000];

    /**

     * Set to 'this' in Minecraft constructor; used by some settings get methods

     */

    private static Minecraft theMinecraft;

    public PlayerController playerController;

    private boolean fullscreen;

    private boolean hasCrashed;

    public int displayWidth;

    public int displayHeight;

    /** Checks OpenGL capabilities (as of 1.2.3_04 effectively unused). */

    private OpenGlCapsChecker glCapabilities;

    private Timer timer;

    /** The World instance that Minecraft uses. */

    public World theWorld;

    public RenderGlobal renderGlobal;

    /** The player who's actually in control of this game. */

    public EntityPlayerSP thePlayer;

    /**

     * The Entity from which the renderer determines the render viewpoint. Currently is always the parent Minecraft

     * class's 'thePlayer' instance. Modification of its location, rotation, or other settings at render time will

     * modify the camera likewise, with the caveat of triggering chunk rebuilds as it moves, making it unsuitable for

     * changing the viewpoint mid-render.

     */

    public EntityLiving renderViewEntity;

    public EffectRenderer effectRenderer;

    public Session session;

    public String minecraftUri;

    public Canvas mcCanvas;

    /** a boolean to hide a Quit button from the main menu */

    public boolean hideQuitButton;

    public volatile boolean isGamePaused;

    /** The RenderEngine instance used by Minecraft */

    public RenderEngine renderEngine;

    /** The font renderer used for displaying and measuring text. */

    public FontRenderer fontRenderer;

    public FontRenderer standardGalacticFontRenderer;

    /** The GuiScreen that's being displayed at the moment. */

    public GuiScreen currentScreen;

    public LoadingScreenRenderer loadingScreen;

    public EntityRenderer entityRenderer;

    /** Reference to the download resources thread. */

    private ThreadDownloadResources downloadResourcesThread;

    /** Number of ticks ran since the program was started. */

    private int ticksRan;

    /** Mouse left click counter */

    private int leftClickCounter;

    /** Display width */

    private int tempDisplayWidth;

    /** Display height */

    private int tempDisplayHeight;

    /** Gui achievement */

    public GuiAchievement guiAchievement;

    public GuiIngame ingameGUI;

    /** Skip render world */

    public boolean skipRenderWorld;

    /** The ModelBiped of the player */

    public ModelBiped playerModelBiped;

    /** The ray trace hit that the mouse is over. */

    public MovingObjectPosition objectMouseOver;

    /** The game settings that currently hold effect. */

    public GameSettings gameSettings;

    protected MinecraftApplet mcApplet;

    public SoundManager sndManager;

    /** Mouse helper instance. */

    public MouseHelper mouseHelper;

    /** The TexturePackLister used by this instance of Minecraft... */

    public TexturePackList texturePackList;

    public File mcDataDir;

    private ISaveFormat saveLoader;

    public static long frameTimes[] = new long[512];

    public static long tickTimes[] = new long[512];

    public static int numRecordedFrameTimes = 0;

    /**

     * time in milliseconds when TheadCheckHasPaid determined you have not paid. 0 if you have paid. Used in

     * GuiAchievement whether to display the nag text.

     */

    public static long hasPaidCheckTime = 0L;

    /**

     * When you place a block, it's set to 6, decremented once per tick, when it's 0, you can place another block.

     */

    private int rightClickDelayTimer;

    /** Stat file writer */

    public StatFileWriter statFileWriter;

    private String serverName;

    private int serverPort;

    private TextureWaterFX textureWaterFX;

    private TextureLavaFX textureLavaFX;

    /** The working dir (OS specific) for minecraft */

    private static File minecraftDir = null;

    /**

     * Set to true to keep the game loop running. Set to false by shutdown() to allow the game loop to exit cleanly.

     */

    public volatile boolean running;

    /** String that shows the debug information */

    public String debug;

    /** Approximate time (in ms) of last update to debug string */

    long debugUpdateTime;

    /** holds the current fps */

    int fpsCounter;

    /**

     * Makes sure it doesn't keep taking screenshots when both buttons are down.

     */

    boolean isTakingScreenshot;

    long prevFrameTime;

    /** Profiler currently displayed in the debug screen pie chart */

    private String debugProfilerName;

    /**

     * Does the actual gameplay have focus. If so then mouse and keys will effect the player instead of menus.

     */

    public boolean inGameHasFocus;

    public boolean isRaining;

    long systemTime;

    /** Join player counter */

    private int joinPlayerCounter;

    public Minecraft(Component par1Component, Canvas par2Canvas, MinecraftApplet par3MinecraftApplet, int par4, int par5, boolean par6)

    {

        fullscreen = false;

        hasCrashed = false;

        timer = new Timer(20F);

        session = null;

        hideQuitButton = false;

        isGamePaused = false;

        currentScreen = null;

        ticksRan = 0;

        leftClickCounter = 0;

        guiAchievement = new GuiAchievement(this);

        skipRenderWorld = false;

        playerModelBiped = new ModelBiped(0.0F);

        objectMouseOver = null;

        sndManager = new SoundManager();

        rightClickDelayTimer = 0;

        textureWaterFX = new TextureWaterFX();

        textureLavaFX = new TextureLavaFX();

        running = true;

        debug = "";

        debugUpdateTime = System.currentTimeMillis();

        fpsCounter = 0;

        isTakingScreenshot = false;

        prevFrameTime = -1L;

        debugProfilerName = "root";

        inGameHasFocus = false;

        isRaining = false;

        systemTime = System.currentTimeMillis();

        joinPlayerCounter = 0;

        StatList.func_27360_a();

        tempDisplayHeight = par5;

        fullscreen = par6;

        mcApplet = par3MinecraftApplet;

        Packet3Chat.maxChatLength = 32767;

        new ThreadClientSleep(this, "Timer hack thread");

        mcCanvas = par2Canvas;

        displayWidth = par4;

        displayHeight = par5;

        fullscreen = par6;

        if (par3MinecraftApplet == null || "true".equals(par3MinecraftApplet.getParameter("stand-alone")))

        {

            hideQuitButton = false;

        }

        theMinecraft = this;

    }

    public void onMinecraftCrash(UnexpectedThrowable par1UnexpectedThrowable)

    {

        hasCrashed = true;

        displayUnexpectedThrowable(par1UnexpectedThrowable);

    }

    /**

     * Displays an unexpected error that has come up during the game.

     */

    public abstract void displayUnexpectedThrowable(UnexpectedThrowable unexpectedthrowable);

    public void setServer(String par1Str, int par2)

    {

        serverName = par1Str;

        serverPort = par2;

    }

    /**

     * Starts the game: initializes the canvas, the title, the settings, etcetera.

     */

    public void startGame() throws LWJGLException

    {

        if (mcCanvas != null)

        {

            Graphics g = mcCanvas.getGraphics();

            if (g != null)

            {

                g.setColor(Color.BLACK);

                g.fillRect(0, 0, displayWidth, displayHeight);

                g.dispose();

            }

            Display.setParent(mcCanvas);

        }

        else if (fullscreen)

        {

            Display.setFullscreen(true);

            displayWidth = Display.getDisplayMode().getWidth();

            displayHeight = Display.getDisplayMode().getHeight();

            if (displayWidth <= 0)

            {

                displayWidth = 1;

            }

            if (displayHeight <= 0)

            {

                displayHeight = 1;

            }

        }

        else

        {

            Display.setDisplayMode(new DisplayMode(displayWidth, displayHeight));

        }

        Display.setTitle("Minecraft Minecraft 1.2.5");

        System.out.println((new StringBuilder()).append("LWJGL Version: ").append(Sys.getVersion()).toString());

        try

        {

            PixelFormat pixelformat = new PixelFormat();

            pixelformat = pixelformat.withDepthBits(24);

            Display.create(pixelformat);

        }

        catch (LWJGLException lwjglexception)

        {

            lwjglexception.printStackTrace();

            try

            {

                Thread.sleep(1000L);

            }

            catch (InterruptedException interruptedexception) { }

            Display.create();

        }

        OpenGlHelper.initializeTextures();

        mcDataDir = getMinecraftDir();

        saveLoader = new AnvilSaveConverter(new File(mcDataDir, "saves"));

        gameSettings = new GameSettings(this, mcDataDir);

        texturePackList = new TexturePackList(this, mcDataDir);

        renderEngine = new RenderEngine(texturePackList, gameSettings);

        loadScreen();

        fontRenderer = new FontRenderer(gameSettings, "/font/default.png", renderEngine, false);

        standardGalacticFontRenderer = new FontRenderer(gameSettings, "/font/alternate.png", renderEngine, false);

        if (gameSettings.language != null)

        {

            StringTranslate.getInstance().setLanguage(gameSettings.language);

            fontRenderer.setUnicodeFlag(StringTranslate.getInstance().isUnicode());

            fontRenderer.setBidiFlag(StringTranslate.isBidrectional(gameSettings.language));

        }

        ColorizerWater.setWaterBiomeColorizer(renderEngine.getTextureContents("/misc/watercolor.png"));

        ColorizerGrass.setGrassBiomeColorizer(renderEngine.getTextureContents("/misc/grasscolor.png"));

        ColorizerFoliage.getFoilageBiomeColorizer(renderEngine.getTextureContents("/misc/foliagecolor.png"));

        entityRenderer = new EntityRenderer(this);

        RenderManager.instance.itemRenderer = new ItemRenderer(this);

        statFileWriter = new StatFileWriter(session, mcDataDir);

        AchievementList.openInventory.setStatStringFormatter(new StatStringFormatKeyInv(this));

        loadScreen();

        Mouse.create();

        mouseHelper = new MouseHelper(mcCanvas);

        try

        {

            Controllers.create();

        }

        catch (Exception exception)

        {

            exception.printStackTrace();

        }

        createAndSendReport();

        checkGLError("Pre startup");

        GL11.glEnable(GL11.GL_TEXTURE_2D);

        GL11.glShadeModel(GL11.GL_SMOOTH);

        GL11.glClearDepth(1.0D);

        GL11.glEnable(GL11.GL_DEPTH_TEST);

        GL11.glDepthFunc(GL11.GL_LEQUAL);

        GL11.glEnable(GL11.GL_ALPHA_TEST);

        GL11.glAlphaFunc(GL11.GL_GREATER, 0.1F);

        GL11.glCullFace(GL11.GL_BACK);

        GL11.glMatrixMode(GL11.GL_PROJECTION);

        GL11.glLoadIdentity();

        GL11.glMatrixMode(GL11.GL_MODELVIEW);

        checkGLError("Startup");

        glCapabilities = new OpenGlCapsChecker();

        sndManager.loadSoundSettings(gameSettings);

        renderEngine.registerTextureFX(textureLavaFX);

        renderEngine.registerTextureFX(textureWaterFX);

        renderEngine.registerTextureFX(new TexturePortalFX());

        renderEngine.registerTextureFX(new TextureCompassFX(this));

        renderEngine.registerTextureFX(new TextureWatchFX(this));

        renderEngine.registerTextureFX(new TextureWaterFlowFX());

        renderEngine.registerTextureFX(new TextureLavaFlowFX());

        renderEngine.registerTextureFX(new TextureFlamesFX(0));

        renderEngine.registerTextureFX(new TextureFlamesFX(1));

        renderGlobal = new RenderGlobal(this, renderEngine);

        GL11.glViewport(0, 0, displayWidth, displayHeight);

        effectRenderer = new EffectRenderer(theWorld, renderEngine);

        try

        {

            downloadResourcesThread = new ThreadDownloadResources(mcDataDir, this);

            downloadResourcesThread.start();

        }

        catch (Exception exception1) { }

        checkGLError("Post startup");

        ingameGUI = new GuiIngame(this);

        if (serverName != null)

        {

            displayGuiScreen(new GuiConnecting(this, serverName, serverPort));

        }

        else

        {

            displayGuiScreen(new GuiMainMenu());

        }

        loadingScreen = new LoadingScreenRenderer(this);

    }

    /**

     * Displays a new screen.

     */

    private void loadScreen() throws LWJGLException

    {

        ScaledResolution scaledresolution = new ScaledResolution(gameSettings, displayWidth, displayHeight);

        GL11.glClear(16640);

        GL11.glMatrixMode(GL11.GL_PROJECTION);

        GL11.glLoadIdentity();

        GL11.glOrtho(0.0D, scaledresolution.scaledWidthD, scaledresolution.scaledHeightD, 0.0D, 1000D, 3000D);

        GL11.glMatrixMode(GL11.GL_MODELVIEW);

        GL11.glLoadIdentity();

        GL11.glTranslatef(0.0F, 0.0F, -2000F);

        GL11.glViewport(0, 0, displayWidth, displayHeight);

        GL11.glClearColor(0.0F, 0.0F, 0.0F, 0.0F);

        Tessellator tessellator = Tessellator.instance;

        GL11.glDisable(GL11.GL_LIGHTING);

        GL11.glEnable(GL11.GL_TEXTURE_2D);

        GL11.glDisable(GL11.GL_FOG);

        GL11.glBindTexture(GL11.GL_TEXTURE_2D, renderEngine.getTexture("/title/mojang.png"));

        tessellator.startDrawingQuads();

        tessellator.setColorOpaque_I(0xffffff);

        tessellator.addVertexWithUV(0.0D, displayHeight, 0.0D, 0.0D, 0.0D);

        tessellator.addVertexWithUV(displayWidth, displayHeight, 0.0D, 0.0D, 0.0D);

        tessellator.addVertexWithUV(displayWidth, 0.0D, 0.0D, 0.0D, 0.0D);

        tessellator.addVertexWithUV(0.0D, 0.0D, 0.0D, 0.0D, 0.0D);

        tessellator.draw();

        char c = 256;

        char c1 = 256;

        GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);

        tessellator.setColorOpaque_I(0xffffff);

        scaledTessellator((scaledresolution.getScaledWidth() - c) / 2, (scaledresolution.getScaledHeight() - c1) / 2, 0, 0, c, c1);

        GL11.glDisable(GL11.GL_LIGHTING);

        GL11.glDisable(GL11.GL_FOG);

        GL11.glEnable(GL11.GL_ALPHA_TEST);

        GL11.glAlphaFunc(GL11.GL_GREATER, 0.1F);

        Display.swapBuffers();

    }

    /**

     * Loads Tessellator with a scaled resolution

     */

    public void scaledTessellator(int par1, int par2, int par3, int par4, int par5, int par6)

    {

        float f = 0.00390625F;

        float f1 = 0.00390625F;

        Tessellator tessellator = Tessellator.instance;

        tessellator.startDrawingQuads();

        tessellator.addVertexWithUV(par1 + 0, par2 + par6, 0.0D, (float)(par3 + 0) * f, (float)(par4 + par6) * f1);

        tessellator.addVertexWithUV(par1 + par5, par2 + par6, 0.0D, (float)(par3 + par5) * f, (float)(par4 + par6) * f1);

        tessellator.addVertexWithUV(par1 + par5, par2 + 0, 0.0D, (float)(par3 + par5) * f, (float)(par4 + 0) * f1);

        tessellator.addVertexWithUV(par1 + 0, par2 + 0, 0.0D, (float)(par3 + 0) * f, (float)(par4 + 0) * f1);

        tessellator.draw();

    }

    /**

     * gets the working dir (OS specific) for minecraft

     */

    public static File getMinecraftDir()

    {

        if (minecraftDir == null)

        {

            minecraftDir = getAppDir("minecraft");

        }

        return minecraftDir;

    }

    /**

     * gets the working dir (OS specific) for the specific application (which is always minecraft)

     */

    public static File getAppDir(String par0Str)

    {

        String s = System.getProperty("user.home", ".");

        File file;

        switch (EnumOSMappingHelper.enumOSMappingArray[getOs().ordinal()])

        {

            case 1:

            case 2:

                file = new File(s, (new StringBuilder()).append('.').append(par0Str).append('/').toString());

                break;

            case 3:

                String s1 = System.getenv("APPDATA");

                if (s1 != null)

                {

                    file = new File(s1, (new StringBuilder()).append(".").append(par0Str).append('/').toString());

                }

                else

                {

                    file = new File(s, (new StringBuilder()).append('.').append(par0Str).append('/').toString());

                }

                break;

            case 4:

                file = new File(s, (new StringBuilder()).append("Library/Application Support/").append(par0Str).toString());

                break;

            default:

                file = new File(s, (new StringBuilder()).append(par0Str).append('/').toString());

                break;

        }

        if (!file.exists() && !file.mkdirs())

        {

            throw new RuntimeException((new StringBuilder()).append("The working directory could not be created: ").append(file).toString());

        }

        else

        {

            return file;

        }

    }

    private static EnumOS2 getOs()

    {

        String s = System.getProperty("os.name").toLowerCase();

        if (s.contains("win"))

        {

            return EnumOS2.windows;

        }

        if (s.contains("mac"))

        {

            return EnumOS2.macos;

        }

        if (s.contains("solaris"))

        {

            return EnumOS2.solaris;

        }

        if (s.contains("sunos"))

        {

            return EnumOS2.solaris;

        }

        if (s.contains("linux"))

        {

            return EnumOS2.linux;

        }

        if (s.contains("unix"))

        {

            return EnumOS2.linux;

        }

        else

        {

            return EnumOS2.unknown;

        }

    }

    /**

     * Returns the save loader that is currently being used

     */

    public ISaveFormat getSaveLoader()

    {

        return saveLoader;

    }

    /**

     * Sets the argument GuiScreen as the main (topmost visible) screen.

     */

    public void displayGuiScreen(GuiScreen par1GuiScreen)

    {

        if (currentScreen instanceof GuiErrorScreen)

        {

            return;

        }

        if (currentScreen != null)

        {

            currentScreen.onGuiClosed();

        }

        if (par1GuiScreen instanceof GuiMainMenu)

        {

            statFileWriter.func_27175_b();

        }

        statFileWriter.syncStats();

        if (par1GuiScreen == null && theWorld == null)

        {

            par1GuiScreen = new GuiMainMenu();

        }

        else if (par1GuiScreen == null && thePlayer.getHealth() <= 0)

        {

            par1GuiScreen = new GuiGameOver();

        }

        if (par1GuiScreen instanceof GuiMainMenu)

        {

            gameSettings.showDebugInfo = false;

            ingameGUI.clearChatMessages();

        }

        currentScreen = par1GuiScreen;

        if (par1GuiScreen != null)

        {

            setIngameNotInFocus();

            ScaledResolution scaledresolution = new ScaledResolution(gameSettings, displayWidth, displayHeight);

            int i = scaledresolution.getScaledWidth();

            int j = scaledresolution.getScaledHeight();

            par1GuiScreen.setWorldAndResolution(this, i, j);

            skipRenderWorld = false;

        }

        else

        {

            setIngameFocus();

        }

    }

    /**

     * Checks for an OpenGL error. If there is one, prints the error ID and error string.

     */

    private void checkGLError(String par1Str)

    {

        int i = GL11.glGetError();

        if (i != 0)

        {

            String s = GLU.gluErrorString(i);

            System.out.println("########## GL ERROR ##########");

            System.out.println((new StringBuilder()).append("@ ").append(par1Str).toString());

            System.out.println((new StringBuilder()).append(i).append(": ").append(s).toString());

        }

    }

    /**

     * Shuts down the minecraft applet by stopping the resource downloads, and clearing up GL stuff; called when the

     * application (or web page) is exited.

     */

    public void shutdownMinecraftApplet()

    {

        try

        {

            statFileWriter.func_27175_b();

            statFileWriter.syncStats();

            if (mcApplet != null)

            {

                mcApplet.clearApplet();

            }