Java 类net.minecraft.util.MinecraftError 实例源码

/**
 * Displays a string on the loading screen supposed to indicate what is being done currently.
 */
public void displayLoadingString(String message)
{
    if (!this.mc.running)
    {
        if (!this.field_73724_e)
        {
            throw new MinecraftError();
        }
    }
    else
    {
        this.systemTime = 0L;
        this.message = message;
        this.setLoadingProgress(-1);
        this.systemTime = 0L;
    }
}

/**
 * Displays a string on the loading screen supposed to indicate what is being done currently.
 */
public void displayLoadingString(String message)
{
    if (!this.mc.running)
    {
        if (!this.field_73724_e)
        {
            throw new MinecraftError();
        }
    }
    else
    {
        this.systemTime = 0L;
        this.message = message;
        this.setLoadingProgress(-1);
        this.systemTime = 0L;
    }
}

/**
 * Displays a string on the loading screen supposed to indicate what is being done currently.
 */
public void displayLoadingString(String message)
{
    if (!this.mc.running)
    {
        if (!this.field_73724_e)
        {
            throw new MinecraftError();
        }
    }
    else
    {
        this.systemTime = 0L;
        this.message = message;
        this.setLoadingProgress(-1);
        this.systemTime = 0L;
    }
}

/**
 * Displays a string on the loading screen supposed to indicate what is being done currently.
 */
public void displayLoadingString(String message)
{
    if (!this.mc.running)
    {
        if (!this.loadingSuccess)
        {
            throw new MinecraftError();
        }
    }
    else
    {
        this.systemTime = 0L;
        this.message = message;
        this.setLoadingProgress(-1);
        this.systemTime = 0L;
    }
}

/**
 * Displays a string on the loading screen supposed to indicate what is being done currently.
 */
public void displayLoadingString(String message)
{
    if (!this.mc.running)
    {
        if (!this.loadingSuccess)
        {
            throw new MinecraftError();
        }
    }
    else
    {
        this.systemTime = 0L;
        this.message = message;
        this.setLoadingProgress(-1);
        this.systemTime = 0L;
    }
}

/**
 * This is called with "Working..." by resetProgressAndMessage
 */
public void resetProgresAndWorkingMessage(String par1Str)
{
    if (!this.mc.running)
    {
        if (!this.field_73724_e)
        {
            throw new MinecraftError();
        }
    }
    else
    {
        this.field_73723_d = 0L;
        this.field_73727_a = par1Str;
        this.setLoadingProgress(-1);
        this.field_73723_d = 0L;
    }
}

/**
 * Displays a string on the loading screen supposed to indicate what is being done currently.
 */
public void displayLoadingString(String message)
{
    if (!this.mc.running)
    {
        if (!this.loadingSuccess)
        {
            throw new MinecraftError();
        }
    }
    else
    {
        this.systemTime = 0L;
        this.message = message;
        this.setLoadingProgress(-1);
        this.systemTime = 0L;
    }
}

public void resetProgresAndWorkingMessage(String p_73719_1_)
{
    if (!this.mc.running)
    {
        if (!this.field_73724_e)
        {
            throw new MinecraftError();
        }
    }
    else
    {
        this.field_73723_d = 0L;
        this.field_73727_a = p_73719_1_;
        this.setLoadingProgress(-1);
        this.field_73723_d = 0L;
    }
}

public void resetProgresAndWorkingMessage(String p_73719_1_)
{
    if (!this.mc.running)
    {
        if (!this.field_73724_e)
        {
            throw new MinecraftError();
        }
    }
    else
    {
        this.field_73723_d = 0L;
        this.field_73727_a = p_73719_1_;
        this.setLoadingProgress(-1);
        this.field_73723_d = 0L;
    }
}

public void func_73722_d(String p_73722_1_) {
   this.field_73726_c = p_73722_1_;
   if(!this.field_73725_b.field_71425_J) {
      if(!this.field_73724_e) {
         throw new MinecraftError();
      }
   } else {
      ScaledResolution var2 = new ScaledResolution(this.field_73725_b.field_71474_y, this.field_73725_b.field_71443_c, this.field_73725_b.field_71440_d);
      GL11.glClear(256);
      GL11.glMatrixMode(5889);
      GL11.glLoadIdentity();
      GL11.glOrtho(0.0D, var2.func_78327_c(), var2.func_78324_d(), 0.0D, 100.0D, 300.0D);
      GL11.glMatrixMode(5888);
      GL11.glLoadIdentity();
      GL11.glTranslatef(0.0F, 0.0F, -200.0F);
   }
}

public void func_73722_d(String par1Str)
{
    this.currentlyDisplayedText = par1Str;

    if (!this.mc.running)
    {
        if (!this.field_73724_e)
        {
            throw new MinecraftError();
        }
    }
    else
    {
        ScaledResolution scaledresolution = new ScaledResolution(this.mc.gameSettings, this.mc.displayWidth, this.mc.displayHeight);
        GL11.glClear(GL11.GL_DEPTH_BUFFER_BIT);
        GL11.glMatrixMode(GL11.GL_PROJECTION);
        GL11.glLoadIdentity();
        GL11.glOrtho(0.0D, scaledresolution.getScaledWidth_double(), scaledresolution.getScaledHeight_double(), 0.0D, 100.0D, 300.0D);
        GL11.glMatrixMode(GL11.GL_MODELVIEW);
        GL11.glLoadIdentity();
        GL11.glTranslatef(0.0F, 0.0F, -200.0F);
    }
}

/**
 * This is called with "Working..." by resetProgressAndMessage
 */
public void resetProgresAndWorkingMessage(String par1Str)
{
    if (!this.mc.running)
    {
        if (!this.field_73724_e)
        {
            throw new MinecraftError();
        }
    }
    else
    {
        this.field_73723_d = 0L;
        this.field_73727_a = par1Str;
        this.setLoadingProgress(-1);
        this.field_73723_d = 0L;
    }
}

public void func_73722_d(String par1Str)
{
    this.currentlyDisplayedText = par1Str;

    if (!this.mc.running)
    {
        if (!this.field_73724_e)
        {
            throw new MinecraftError();
        }
    }
    else
    {
        ScaledResolution scaledresolution = new ScaledResolution(this.mc.gameSettings, this.mc.displayWidth, this.mc.displayHeight);
        GL11.glClear(GL11.GL_DEPTH_BUFFER_BIT);
        GL11.glMatrixMode(GL11.GL_PROJECTION);
        GL11.glLoadIdentity();
        GL11.glOrtho(0.0D, scaledresolution.getScaledWidth_double(), scaledresolution.getScaledHeight_double(), 0.0D, 100.0D, 300.0D);
        GL11.glMatrixMode(GL11.GL_MODELVIEW);
        GL11.glLoadIdentity();
        GL11.glTranslatef(0.0F, 0.0F, -200.0F);
    }
}

/**
 * This is called with "Working..." by resetProgressAndMessage
 */
public void resetProgresAndWorkingMessage(String par1Str)
{
    if (!this.mc.running)
    {
        if (!this.field_73724_e)
        {
            throw new MinecraftError();
        }
    }
    else
    {
        this.field_73723_d = 0L;
        this.field_73727_a = par1Str;
        this.setLoadingProgress(-1);
        this.field_73723_d = 0L;
    }
}

private void displayString(String message)
{
    this.currentlyDisplayedText = message;

    if (!this.mc.running)
    {
        if (!this.field_73724_e)
        {
            throw new MinecraftError();
        }
    }
    else
    {
        GlStateManager.clear(256);
        GlStateManager.matrixMode(5889);
        GlStateManager.loadIdentity();

        if (OpenGlHelper.isFramebufferEnabled())
        {
            int i = this.scaledResolution.getScaleFactor();
            GlStateManager.ortho(0.0D, (double)(this.scaledResolution.getScaledWidth() * i), (double)(this.scaledResolution.getScaledHeight() * i), 0.0D, 100.0D, 300.0D);
        }
        else
        {
            ScaledResolution scaledresolution = new ScaledResolution(this.mc);
            GlStateManager.ortho(0.0D, scaledresolution.getScaledWidth_double(), scaledresolution.getScaledHeight_double(), 0.0D, 100.0D, 300.0D);
        }

        GlStateManager.matrixMode(5888);
        GlStateManager.loadIdentity();
        GlStateManager.translate(0.0F, 0.0F, -200.0F);
    }
}

private void displayString(String message)
{
    this.currentlyDisplayedText = message;

    if (!this.mc.running)
    {
        if (!this.field_73724_e)
        {
            throw new MinecraftError();
        }
    }
    else
    {
        GlStateManager.clear(256);
        GlStateManager.matrixMode(5889);
        GlStateManager.loadIdentity();

        if (OpenGlHelper.isFramebufferEnabled())
        {
            int i = this.scaledResolution.getScaleFactor();
            GlStateManager.ortho(0.0D, (double)(this.scaledResolution.getScaledWidth() * i), (double)(this.scaledResolution.getScaledHeight() * i), 0.0D, 100.0D, 300.0D);
        }
        else
        {
            ScaledResolution scaledresolution = new ScaledResolution(this.mc);
            GlStateManager.ortho(0.0D, scaledresolution.getScaledWidth_double(), scaledresolution.getScaledHeight_double(), 0.0D, 100.0D, 300.0D);
        }

        GlStateManager.matrixMode(5888);
        GlStateManager.loadIdentity();
        GlStateManager.translate(0.0F, 0.0F, -200.0F);
    }
}

private void displayString(String message)
{
    this.currentlyDisplayedText = message;

    if (!this.mc.running)
    {
        if (!this.field_73724_e)
        {
            throw new MinecraftError();
        }
    }
    else
    {
        GlStateManager.clear(256);
        GlStateManager.matrixMode(5889);
        GlStateManager.loadIdentity();

        if (OpenGlHelper.isFramebufferEnabled())
        {
            int i = this.scaledResolution.getScaleFactor();
            GlStateManager.ortho(0.0D, (double)(this.scaledResolution.getScaledWidth() * i), (double)(this.scaledResolution.getScaledHeight() * i), 0.0D, 100.0D, 300.0D);
        }
        else
        {
            ScaledResolution scaledresolution = new ScaledResolution(this.mc);
            GlStateManager.ortho(0.0D, scaledresolution.getScaledWidth_double(), scaledresolution.getScaledHeight_double(), 0.0D, 100.0D, 300.0D);
        }

        GlStateManager.matrixMode(5888);
        GlStateManager.loadIdentity();
        GlStateManager.translate(0.0F, 0.0F, -200.0F);
    }
}

private void displayString(String message)
{
    this.currentlyDisplayedText = message;

    if (!this.mc.running)
    {
        if (!this.loadingSuccess)
        {
            throw new MinecraftError();
        }
    }
    else
    {
        GlStateManager.clear(256);
        GlStateManager.matrixMode(5889);
        GlStateManager.loadIdentity();

        if (OpenGlHelper.isFramebufferEnabled())
        {
            int i = this.scaledResolution.getScaleFactor();
            GlStateManager.ortho(0.0D, (double)(this.scaledResolution.getScaledWidth() * i), (double)(this.scaledResolution.getScaledHeight() * i), 0.0D, 100.0D, 300.0D);
        }
        else
        {
            ScaledResolution scaledresolution = new ScaledResolution(this.mc);
            GlStateManager.ortho(0.0D, scaledresolution.getScaledWidth_double(), scaledresolution.getScaledHeight_double(), 0.0D, 100.0D, 300.0D);
        }

        GlStateManager.matrixMode(5888);
        GlStateManager.loadIdentity();
        GlStateManager.translate(0.0F, 0.0F, -200.0F);
    }
}

private void displayString(String message)
{
    this.currentlyDisplayedText = message;

    if (!this.mc.running)
    {
        if (!this.loadingSuccess)
        {
            throw new MinecraftError();
        }
    }
    else
    {
        GlStateManager.clear(256);
        GlStateManager.matrixMode(5889);
        GlStateManager.loadIdentity();

        if (OpenGlHelper.isFramebufferEnabled())
        {
            int i = this.scaledResolution.getScaleFactor();
            GlStateManager.ortho(0.0D, (double)(this.scaledResolution.getScaledWidth() * i), (double)(this.scaledResolution.getScaledHeight() * i), 0.0D, 100.0D, 300.0D);
        }
        else
        {
            ScaledResolution scaledresolution = new ScaledResolution(this.mc);
            GlStateManager.ortho(0.0D, scaledresolution.getScaledWidth_double(), scaledresolution.getScaledHeight_double(), 0.0D, 100.0D, 300.0D);
        }

        GlStateManager.matrixMode(5888);
        GlStateManager.loadIdentity();
        GlStateManager.translate(0.0F, 0.0F, -200.0F);
    }
}

public void func_73722_d(String par1Str)
{
    this.currentlyDisplayedText = par1Str;

    if (!this.mc.running)
    {
        if (!this.field_73724_e)
        {
            throw new MinecraftError();
        }
    }
    else
    {
        GL11.glClear(GL11.GL_DEPTH_BUFFER_BIT);
        GL11.glMatrixMode(GL11.GL_PROJECTION);
        GL11.glLoadIdentity();

        if (OpenGlHelper.isFramebufferEnabled())
        {
            int var2 = this.field_146587_f.getScaleFactor();
            GL11.glOrtho(0.0D, (double)(this.field_146587_f.getScaledWidth() * var2), (double)(this.field_146587_f.getScaledHeight() * var2), 0.0D, 100.0D, 300.0D);
        }
        else
        {
            ScaledResolution var3 = new ScaledResolution(this.mc.gameSettings, this.mc.displayWidth, this.mc.displayHeight);
            GL11.glOrtho(0.0D, var3.getScaledWidth_double(), var3.getScaledHeight_double(), 0.0D, 100.0D, 300.0D);
        }

        GL11.glMatrixMode(GL11.GL_MODELVIEW);
        GL11.glLoadIdentity();
        GL11.glTranslatef(0.0F, 0.0F, -200.0F);
    }
}

private void displayString(String message)
{
    this.currentlyDisplayedText = message;

    if (!this.mc.running)
    {
        if (!this.loadingSuccess)
        {
            throw new MinecraftError();
        }
    }
    else
    {
        GlStateManager.clear(256);
        GlStateManager.matrixMode(5889);
        GlStateManager.loadIdentity();

        if (OpenGlHelper.isFramebufferEnabled())
        {
            int i = this.scaledResolution.getScaleFactor();
            GlStateManager.ortho(0.0D, (double)(this.scaledResolution.getScaledWidth() * i), (double)(this.scaledResolution.getScaledHeight() * i), 0.0D, 100.0D, 300.0D);
        }
        else
        {
            ScaledResolution scaledresolution = new ScaledResolution(this.mc);
            GlStateManager.ortho(0.0D, scaledresolution.getScaledWidth_double(), scaledresolution.getScaledHeight_double(), 0.0D, 100.0D, 300.0D);
        }

        GlStateManager.matrixMode(5888);
        GlStateManager.loadIdentity();
        GlStateManager.translate(0.0F, 0.0F, -200.0F);
    }
}

public void func_73722_d(String p_73722_1_)
{
    this.currentlyDisplayedText = p_73722_1_;

    if (!this.mc.running)
    {
        if (!this.field_73724_e)
        {
            throw new MinecraftError();
        }
    }
    else
    {
        GL11.glClear(GL11.GL_DEPTH_BUFFER_BIT);
        GL11.glMatrixMode(GL11.GL_PROJECTION);
        GL11.glLoadIdentity();

        if (OpenGlHelper.isFramebufferEnabled())
        {
            int i = this.field_146587_f.getScaleFactor();
            GL11.glOrtho(0.0D, (double)(this.field_146587_f.getScaledWidth() * i), (double)(this.field_146587_f.getScaledHeight() * i), 0.0D, 100.0D, 300.0D);
        }
        else
        {
            ScaledResolution scaledresolution = new ScaledResolution(this.mc, this.mc.displayWidth, this.mc.displayHeight);
            GL11.glOrtho(0.0D, scaledresolution.getScaledWidth_double(), scaledresolution.getScaledHeight_double(), 0.0D, 100.0D, 300.0D);
        }

        GL11.glMatrixMode(GL11.GL_MODELVIEW);
        GL11.glLoadIdentity();
        GL11.glTranslatef(0.0F, 0.0F, -200.0F);
    }
}

public void func_73722_d(String p_73722_1_)
{
    this.currentlyDisplayedText = p_73722_1_;

    if (!this.mc.running)
    {
        if (!this.field_73724_e)
        {
            throw new MinecraftError();
        }
    }
    else
    {
        GL11.glClear(GL11.GL_DEPTH_BUFFER_BIT);
        GL11.glMatrixMode(GL11.GL_PROJECTION);
        GL11.glLoadIdentity();

        if (OpenGlHelper.isFramebufferEnabled())
        {
            int i = this.field_146587_f.getScaleFactor();
            GL11.glOrtho(0.0D, (double)(this.field_146587_f.getScaledWidth() * i), (double)(this.field_146587_f.getScaledHeight() * i), 0.0D, 100.0D, 300.0D);
        }
        else
        {
            ScaledResolution scaledresolution = new ScaledResolution(this.mc, this.mc.displayWidth, this.mc.displayHeight);
            GL11.glOrtho(0.0D, scaledresolution.getScaledWidth_double(), scaledresolution.getScaledHeight_double(), 0.0D, 100.0D, 300.0D);
        }

        GL11.glMatrixMode(GL11.GL_MODELVIEW);
        GL11.glLoadIdentity();
        GL11.glTranslatef(0.0F, 0.0F, -200.0F);
    }
}

public void func_73719_c(String p_73719_1_) {
   if(!this.field_73725_b.field_71425_J) {
      if(!this.field_73724_e) {
         throw new MinecraftError();
      }
   } else {
      this.field_73723_d = 0L;
      this.field_73727_a = p_73719_1_;
      this.func_73718_a(-1);
      this.field_73723_d = 0L;
   }
}

public void run()
{
    this.running = true;

    try
    {
        this.startGame();
    }
    catch (Throwable throwable)
    {
        CrashReport crashreport = CrashReport.makeCrashReport(throwable, "Initializing game");
        crashreport.makeCategory("Initialization");
        this.displayCrashReport(this.addGraphicsAndWorldToCrashReport(crashreport));
        return;
    }

    while (true)
    {
        try
        {
            while (this.running)
            {
                if (!this.hasCrashed || this.crashReporter == null)
                {
                    try
                    {
                        this.runGameLoop();
                    }
                    catch (OutOfMemoryError var10)
                    {
                        this.freeMemory();
                        this.displayGuiScreen(new GuiMemoryErrorScreen());
                        System.gc();
                    }
                }
                else
                {
                    this.displayCrashReport(this.crashReporter);
                }
            }
        }
        catch (MinecraftError var12)
        {
            break;
        }
        catch (ReportedException reportedexception)
        {
            this.addGraphicsAndWorldToCrashReport(reportedexception.getCrashReport());
            this.freeMemory();
            logger.fatal((String)"Reported exception thrown!", (Throwable)reportedexception);
            this.displayCrashReport(reportedexception.getCrashReport());
            break;
        }
        catch (Throwable throwable1)
        {
            CrashReport crashreport1 = this.addGraphicsAndWorldToCrashReport(new CrashReport("Unexpected error", throwable1));
            this.freeMemory();
            logger.fatal("Unreported exception thrown!", throwable1);
            this.displayCrashReport(crashreport1);
            break;
        }
        finally
        {
            this.shutdownMinecraftApplet();
        }

        return;
    }
}

public void run()
{
    this.running = true;

    try
    {
        this.startGame();
        Client.init();
    }
    catch (Throwable throwable)
    {
        CrashReport crashreport = CrashReport.makeCrashReport(throwable, "Initializing game");
        crashreport.makeCategory("Initialization");
        this.displayCrashReport(this.addGraphicsAndWorldToCrashReport(crashreport));
        return;
    }

    while (true)
    {
        try
        {
            while (this.running)
            {
                if (!this.hasCrashed || this.crashReporter == null)
                {
                    try
                    {
                        this.runGameLoop();
                    }
                    catch (OutOfMemoryError var10)
                    {
                        this.freeMemory();
                        this.displayGuiScreen(new GuiMemoryErrorScreen());
                        System.gc();
                    }
                }
                else
                {
                    this.displayCrashReport(this.crashReporter);
                }
            }
        }
        catch (MinecraftError var12)
        {
            break;
        }
        catch (ReportedException reportedexception)
        {
            this.addGraphicsAndWorldToCrashReport(reportedexception.getCrashReport());
            this.freeMemory();
            logger.fatal((String)"Reported exception thrown!", (Throwable)reportedexception);
            this.displayCrashReport(reportedexception.getCrashReport());
            break;
        }
        catch (Throwable throwable1)
        {
            CrashReport crashreport1 = this.addGraphicsAndWorldToCrashReport(new CrashReport("Unexpected error", throwable1));
            this.freeMemory();
            logger.fatal("Unreported exception thrown!", throwable1);
            this.displayCrashReport(crashreport1);
            break;
        }
        finally
        {
            this.shutdownMinecraftApplet();
        }

        return;
    }
}

public void run() {
    this.running = true;

    try {
        this.startGame();
    } catch (Throwable throwable) {
        CrashReport crashreport = CrashReport.makeCrashReport(throwable, "Initializing game");
        crashreport.makeCategory("Initialization");
        this.displayCrashReport(this.addGraphicsAndWorldToCrashReport(crashreport));
        return;
    }

    while (true) {
        try {
            while (this.running) {
                if (!this.hasCrashed || this.crashReporter == null) {
                    try {
                        this.runGameLoop();
                    } catch (OutOfMemoryError var10) {
                        this.freeMemory();
                        this.displayGuiScreen(new GuiMemoryErrorScreen());
                        System.gc();
                    }
                } else {
                    this.displayCrashReport(this.crashReporter);
                }
            }
        } catch (MinecraftError var12) {
            break;
        } catch (ReportedException reportedexception) {
            this.addGraphicsAndWorldToCrashReport(reportedexception.getCrashReport());
            this.freeMemory();
            logger.fatal((String) "Reported exception thrown!", (Throwable) reportedexception);
            this.displayCrashReport(reportedexception.getCrashReport());
            break;
        } catch (Throwable throwable1) {
            CrashReport crashreport1 = this
                    .addGraphicsAndWorldToCrashReport(new CrashReport("Unexpected error", throwable1));
            this.freeMemory();
            logger.fatal("Unreported exception thrown!", throwable1);
            this.displayCrashReport(crashreport1);
            break;
        } finally {
            this.shutdownMinecraftApplet();
        }

        return;
    }
}

public void run()
{
    this.running = true;

    try
    {
        this.startGame();
    }
    catch (Throwable throwable)
    {
        CrashReport crashreport = CrashReport.makeCrashReport(throwable, "Initializing game");
        crashreport.makeCategory("Initialization");
        this.displayCrashReport(this.addGraphicsAndWorldToCrashReport(crashreport));
        return;
    }

    while (true)
    {
        try
        {
            while (this.running)
            {
                if (!this.hasCrashed || this.crashReporter == null)
                {
                    try
                    {
                        this.runGameLoop();
                    }
                    catch (OutOfMemoryError var10)
                    {
                        this.freeMemory();
                        this.displayGuiScreen(new GuiMemoryErrorScreen());
                        System.gc();
                    }
                }
                else
                {
                    this.displayCrashReport(this.crashReporter);
                }
            }
        }
        catch (MinecraftError var12)
        {
            break;
        }
        catch (ReportedException reportedexception)
        {
            this.addGraphicsAndWorldToCrashReport(reportedexception.getCrashReport());
            this.freeMemory();
            LOGGER.fatal((String)"Reported exception thrown!", (Throwable)reportedexception);
            this.displayCrashReport(reportedexception.getCrashReport());
            break;
        }
        catch (Throwable throwable1)
        {
            CrashReport crashreport1 = this.addGraphicsAndWorldToCrashReport(new CrashReport("Unexpected error", throwable1));
            this.freeMemory();
            LOGGER.fatal("Unreported exception thrown!", throwable1);
            this.displayCrashReport(crashreport1);
            break;
        }
        finally
        {
            this.shutdownMinecraftApplet();
        }

        return;
    }
}

public void run()
{
    this.running = true;

    try
    {
        this.startGame();
    }
    catch (Throwable throwable)
    {
        CrashReport crashreport = CrashReport.makeCrashReport(throwable, "Initializing game");
        crashreport.makeCategory("Initialization");
        this.displayCrashReport(this.addGraphicsAndWorldToCrashReport(crashreport));
        return;
    }

    while (true)
    {
        try
        {
            while (this.running)
            {
                if (!this.hasCrashed || this.crashReporter == null)
                {
                    try
                    {
                        this.runGameLoop();
                    }
                    catch (OutOfMemoryError var10)
                    {
                        this.freeMemory();
                        this.displayGuiScreen(new GuiMemoryErrorScreen());
                        System.gc();
                    }
                }
                else
                {
                    this.displayCrashReport(this.crashReporter);
                }
            }
        }
        catch (MinecraftError var12)
        {
            break;
        }
        catch (ReportedException reportedexception)
        {
            this.addGraphicsAndWorldToCrashReport(reportedexception.getCrashReport());
            this.freeMemory();
            LOGGER.fatal((String)"Reported exception thrown!", (Throwable)reportedexception);
            this.displayCrashReport(reportedexception.getCrashReport());
            break;
        }
        catch (Throwable throwable1)
        {
            CrashReport crashreport1 = this.addGraphicsAndWorldToCrashReport(new CrashReport("Unexpected error", throwable1));
            this.freeMemory();
            LOGGER.fatal("Unreported exception thrown!", throwable1);
            this.displayCrashReport(crashreport1);
            break;
        }
        finally
        {
            this.shutdownMinecraftApplet();
        }

        return;
    }
}

public void run()
{
    this.running = true;
    CrashReport var2;

    try
    {
        this.startGame();
    }
    catch (Throwable var11)
    {
        var2 = CrashReport.makeCrashReport(var11, "Initializing game");
        var2.makeCategory("Initialization");
        this.displayCrashReport(this.addGraphicsAndWorldToCrashReport(var2));
        return;
    }

    while (true)
    {
        try
        {
            while (this.running)
            {
                if (!this.hasCrashed || this.crashReporter == null)
                {
                    try
                    {
                        this.runGameLoop();
                    }
                    catch (OutOfMemoryError var10)
                    {
                        this.freeMemory();
                        this.displayGuiScreen(new GuiMemoryErrorScreen());
                        System.gc();
                    }

                    continue;
                }

                this.displayCrashReport(this.crashReporter);
                return;
            }
        }
        catch (MinecraftError var12)
        {
            ;
        }
        catch (ReportedException var13)
        {
            this.addGraphicsAndWorldToCrashReport(var13.getCrashReport());
            this.freeMemory();
            logger.fatal("Reported exception thrown!", var13);
            this.displayCrashReport(var13.getCrashReport());
        }
        catch (Throwable var14)
        {
            var2 = this.addGraphicsAndWorldToCrashReport(new CrashReport("Unexpected error", var14));
            this.freeMemory();
            logger.fatal("Unreported exception thrown!", var14);
            this.displayCrashReport(var2);
        }
        finally
        {
            this.shutdownMinecraftApplet();
        }

        return;
    }
}

public void run()
{
    this.running = true;

    try
    {
        this.startGame();
    }
    catch (Throwable throwable)
    {
        CrashReport crashreport = CrashReport.makeCrashReport(throwable, "Initializing game");
        crashreport.makeCategory("Initialization");
        this.displayCrashReport(this.addGraphicsAndWorldToCrashReport(crashreport));
        return;
    }

    while (true)
    {
        try
        {
            while (this.running)
            {
                if (!this.hasCrashed || this.crashReporter == null)
                {
                    try
                    {
                        this.runGameLoop();
                    }
                    catch (OutOfMemoryError var10)
                    {
                        this.freeMemory();
                        this.displayGuiScreen(new GuiMemoryErrorScreen());
                        System.gc();
                    }
                }
                else
                {
                    this.displayCrashReport(this.crashReporter);
                }
            }
        }
        catch (MinecraftError var12)
        {
            break;
        }
        catch (ReportedException reportedexception)
        {
            this.addGraphicsAndWorldToCrashReport(reportedexception.getCrashReport());
            this.freeMemory();
            LOGGER.fatal((String)"Reported exception thrown!", (Throwable)reportedexception);
            this.displayCrashReport(reportedexception.getCrashReport());
            break;
        }
        catch (Throwable throwable1)
        {
            CrashReport crashreport1 = this.addGraphicsAndWorldToCrashReport(new CrashReport("Unexpected error", throwable1));
            this.freeMemory();
            LOGGER.fatal("Unreported exception thrown!", throwable1);
            this.displayCrashReport(crashreport1);
            break;
        }
        finally
        {
            this.shutdownMinecraftApplet();
        }

        return;
    }
}

public void run()
{
    this.running = true;
    CrashReport crashreport;

    try
    {
        this.startGame();
    }
    catch (Throwable throwable)
    {
        crashreport = CrashReport.makeCrashReport(throwable, "Initializing game");
        crashreport.makeCategory("Initialization");
        this.displayCrashReport(this.addGraphicsAndWorldToCrashReport(crashreport));
        return;
    }

    while (true)
    {
        try
        {
            while (this.running)
            {
                if (!this.hasCrashed || this.crashReporter == null)
                {
                    try
                    {
                        this.runGameLoop();
                    }
                    catch (OutOfMemoryError outofmemoryerror)
                    {
                        this.freeMemory();
                        this.displayGuiScreen(new GuiMemoryErrorScreen());
                        System.gc();
                    }

                    continue;
                }

                this.displayCrashReport(this.crashReporter);
            }
        }
        catch (MinecraftError minecrafterror)
        {
            break;
        }
        catch (ReportedException reportedexception)
        {
            this.addGraphicsAndWorldToCrashReport(reportedexception.getCrashReport());
            this.freeMemory();
            logger.fatal("Reported exception thrown!", reportedexception);
            this.displayCrashReport(reportedexception.getCrashReport());
            break;
        }
        catch (Throwable throwable1)
        {
            crashreport = this.addGraphicsAndWorldToCrashReport(new CrashReport("Unexpected error", throwable1));
            this.freeMemory();
            logger.fatal("Unreported exception thrown!", throwable1);
            this.displayCrashReport(crashreport);
            break;
        }
        finally
        {
            this.shutdownMinecraftApplet();
        }

        return;
    }
}

public void run()
{
    this.running = true;
    CrashReport crashreport;

    try
    {
        this.startGame();
    }
    catch (Throwable throwable)
    {
        crashreport = CrashReport.makeCrashReport(throwable, "Initializing game");
        crashreport.makeCategory("Initialization");
        this.displayCrashReport(this.addGraphicsAndWorldToCrashReport(crashreport));
        return;
    }

    while (true)
    {
        try
        {
            while (this.running)
            {
                if (!this.hasCrashed || this.crashReporter == null)
                {
                    try
                    {
                        this.runGameLoop();
                    }
                    catch (OutOfMemoryError outofmemoryerror)
                    {
                        this.freeMemory();
                        this.displayGuiScreen(new GuiMemoryErrorScreen());
                        System.gc();
                    }

                    continue;
                }

                this.displayCrashReport(this.crashReporter);
            }
        }
        catch (MinecraftError minecrafterror)
        {
            break;
        }
        catch (ReportedException reportedexception)
        {
            this.addGraphicsAndWorldToCrashReport(reportedexception.getCrashReport());
            this.freeMemory();
            logger.fatal("Reported exception thrown!", reportedexception);
            this.displayCrashReport(reportedexception.getCrashReport());
            break;
        }
        catch (Throwable throwable1)
        {
            crashreport = this.addGraphicsAndWorldToCrashReport(new CrashReport("Unexpected error", throwable1));
            this.freeMemory();
            logger.fatal("Unreported exception thrown!", throwable1);
            this.displayCrashReport(crashreport);
            break;
        }
        finally
        {
            this.shutdownMinecraftApplet();
        }

        return;
    }
}

public void func_73718_a(int p_73718_1_) {
   if(!this.field_73725_b.field_71425_J) {
      if(!this.field_73724_e) {
         throw new MinecraftError();
      }
   } else {
      long var2 = Minecraft.func_71386_F();
      if(var2 - this.field_73723_d >= 100L) {
         this.field_73723_d = var2;
         ScaledResolution var4 = new ScaledResolution(this.field_73725_b.field_71474_y, this.field_73725_b.field_71443_c, this.field_73725_b.field_71440_d);
         int var5 = var4.func_78326_a();
         int var6 = var4.func_78328_b();
         GL11.glClear(256);
         GL11.glMatrixMode(5889);
         GL11.glLoadIdentity();
         GL11.glOrtho(0.0D, var4.func_78327_c(), var4.func_78324_d(), 0.0D, 100.0D, 300.0D);
         GL11.glMatrixMode(5888);
         GL11.glLoadIdentity();
         GL11.glTranslatef(0.0F, 0.0F, -200.0F);
         GL11.glClear(16640);
         Tessellator var7 = Tessellator.field_78398_a;
         this.field_73725_b.func_110434_K().func_110577_a(Gui.field_110325_k);
         float var8 = 32.0F;
         var7.func_78382_b();
         var7.func_78378_d(4210752);
         var7.func_78374_a(0.0D, (double)var6, 0.0D, 0.0D, (double)((float)var6 / var8));
         var7.func_78374_a((double)var5, (double)var6, 0.0D, (double)((float)var5 / var8), (double)((float)var6 / var8));
         var7.func_78374_a((double)var5, 0.0D, 0.0D, (double)((float)var5 / var8), 0.0D);
         var7.func_78374_a(0.0D, 0.0D, 0.0D, 0.0D, 0.0D);
         var7.func_78381_a();
         if(p_73718_1_ >= 0) {
            byte var9 = 100;
            byte var10 = 2;
            int var11 = var5 / 2 - var9 / 2;
            int var12 = var6 / 2 + 16;
            GL11.glDisable(3553);
            var7.func_78382_b();
            var7.func_78378_d(8421504);
            var7.func_78377_a((double)var11, (double)var12, 0.0D);
            var7.func_78377_a((double)var11, (double)(var12 + var10), 0.0D);
            var7.func_78377_a((double)(var11 + var9), (double)(var12 + var10), 0.0D);
            var7.func_78377_a((double)(var11 + var9), (double)var12, 0.0D);
            var7.func_78378_d(8454016);
            var7.func_78377_a((double)var11, (double)var12, 0.0D);
            var7.func_78377_a((double)var11, (double)(var12 + var10), 0.0D);
            var7.func_78377_a((double)(var11 + p_73718_1_), (double)(var12 + var10), 0.0D);
            var7.func_78377_a((double)(var11 + p_73718_1_), (double)var12, 0.0D);
            var7.func_78381_a();
            GL11.glEnable(3553);
         }

         this.field_73725_b.field_71466_p.func_78261_a(this.field_73726_c, (var5 - this.field_73725_b.field_71466_p.func_78256_a(this.field_73726_c)) / 2, var6 / 2 - 4 - 16, 16777215);
         this.field_73725_b.field_71466_p.func_78261_a(this.field_73727_a, (var5 - this.field_73725_b.field_71466_p.func_78256_a(this.field_73727_a)) / 2, var6 / 2 - 4 + 8, 16777215);
         Display.update();

         try {
            Thread.yield();
         } catch (Exception var13) {
            ;
         }

      }
   }
}

public void func_99999_d() {
   this.field_71425_J = true;

   CrashReport var2;
   try {
      this.func_71384_a();
   } catch (Throwable var11) {
      var2 = CrashReport.func_85055_a(var11, "Initializing game");
      var2.func_85058_a("Initialization");
      this.func_71377_b(this.func_71396_d(var2));
      return;
   }

   while(true) {
      try {
         if(this.field_71425_J) {
            if(this.field_71434_R && this.field_71433_S != null) {
               this.func_71377_b(this.field_71433_S);
               return;
            }

            if(this.field_71468_ad) {
               this.field_71468_ad = false;
               this.func_110436_a();
            }

            try {
               this.func_71411_J();
            } catch (OutOfMemoryError var10) {
               this.func_71398_f();
               this.func_71373_a(new GuiMemoryErrorScreen());
               System.gc();
            }
            continue;
         }
      } catch (MinecraftError var12) {
         ;
      } catch (ReportedException var13) {
         this.func_71396_d(var13.func_71575_a());
         this.func_71398_f();
         var13.printStackTrace();
         this.func_71377_b(var13.func_71575_a());
      } catch (Throwable var14) {
         var2 = this.func_71396_d(new CrashReport("Unexpected error", var14));
         this.func_71398_f();
         var14.printStackTrace();
         this.func_71377_b(var2);
      } finally {
         this.func_71405_e();
      }

      return;
   }
}

/**
 * Updates the progress bar on the loading screen to the specified amount. Args: loadProgress
 */
public void setLoadingProgress(int par1)
{
    if (!this.mc.running)
    {
        if (!this.field_73724_e)
        {
            throw new MinecraftError();
        }
    }
    else
    {
        long j = Minecraft.getSystemTime();

        if (j - this.field_73723_d >= 100L)
        {
            this.field_73723_d = j;
            ScaledResolution scaledresolution = new ScaledResolution(this.mc.gameSettings, this.mc.displayWidth, this.mc.displayHeight);
            int k = scaledresolution.getScaledWidth();
            int l = scaledresolution.getScaledHeight();
            GL11.glClear(GL11.GL_DEPTH_BUFFER_BIT);
            GL11.glMatrixMode(GL11.GL_PROJECTION);
            GL11.glLoadIdentity();
            GL11.glOrtho(0.0D, scaledresolution.getScaledWidth_double(), scaledresolution.getScaledHeight_double(), 0.0D, 100.0D, 300.0D);
            GL11.glMatrixMode(GL11.GL_MODELVIEW);
            GL11.glLoadIdentity();
            GL11.glTranslatef(0.0F, 0.0F, -200.0F);
            GL11.glClear(GL11.GL_COLOR_BUFFER_BIT | GL11.GL_DEPTH_BUFFER_BIT);
            Tessellator tessellator = Tessellator.instance;
            this.mc.getTextureManager().bindTexture(Gui.optionsBackground);
            float f = 32.0F;
            tessellator.startDrawingQuads();
            tessellator.setColorOpaque_I(4210752);
            tessellator.addVertexWithUV(0.0D, (double)l, 0.0D, 0.0D, (double)((float)l / f));
            tessellator.addVertexWithUV((double)k, (double)l, 0.0D, (double)((float)k / f), (double)((float)l / f));
            tessellator.addVertexWithUV((double)k, 0.0D, 0.0D, (double)((float)k / f), 0.0D);
            tessellator.addVertexWithUV(0.0D, 0.0D, 0.0D, 0.0D, 0.0D);
            tessellator.draw();

            if (par1 >= 0)
            {
                byte b0 = 100;
                byte b1 = 2;
                int i1 = k / 2 - b0 / 2;
                int j1 = l / 2 + 16;
                GL11.glDisable(GL11.GL_TEXTURE_2D);
                tessellator.startDrawingQuads();
                tessellator.setColorOpaque_I(8421504);
                tessellator.addVertex((double)i1, (double)j1, 0.0D);
                tessellator.addVertex((double)i1, (double)(j1 + b1), 0.0D);
                tessellator.addVertex((double)(i1 + b0), (double)(j1 + b1), 0.0D);
                tessellator.addVertex((double)(i1 + b0), (double)j1, 0.0D);
                tessellator.setColorOpaque_I(8454016);
                tessellator.addVertex((double)i1, (double)j1, 0.0D);
                tessellator.addVertex((double)i1, (double)(j1 + b1), 0.0D);
                tessellator.addVertex((double)(i1 + par1), (double)(j1 + b1), 0.0D);
                tessellator.addVertex((double)(i1 + par1), (double)j1, 0.0D);
                tessellator.draw();
                GL11.glEnable(GL11.GL_TEXTURE_2D);
            }

            this.mc.fontRenderer.drawStringWithShadow(this.currentlyDisplayedText, (k - this.mc.fontRenderer.getStringWidth(this.currentlyDisplayedText)) / 2, l / 2 - 4 - 16, 16777215);
            this.mc.fontRenderer.drawStringWithShadow(this.field_73727_a, (k - this.mc.fontRenderer.getStringWidth(this.field_73727_a)) / 2, l / 2 - 4 + 8, 16777215);
            Display.update();

            try
            {
                Thread.yield();
            }
            catch (Exception exception)
            {
                ;
            }
        }
    }
}

public void run()
{
    this.running = true;
    CrashReport crashreport;

    try
    {
        this.startGame();
    }
    catch (Throwable throwable)
    {
        crashreport = CrashReport.makeCrashReport(throwable, "Initializing game");
        crashreport.makeCategory("Initialization");
        this.displayCrashReport(this.addGraphicsAndWorldToCrashReport(crashreport));
        return;
    }

    try
    {
        while (this.running)
        {
            if (this.running)
            {
                if (this.hasCrashed && this.crashReporter != null)
                {
                    this.displayCrashReport(this.crashReporter);
                    return;
                }

                if (this.refreshTexturePacksScheduled)
                {
                    this.refreshTexturePacksScheduled = false;
                    this.refreshResources();
                }

                try
                {
                    this.runGameLoop();
                }
                catch (OutOfMemoryError outofmemoryerror)
                {
                    this.freeMemory();
                    this.displayGuiScreen(new GuiMemoryErrorScreen());
                    System.gc();
                }

                continue;
            }
        }
    }
    catch (MinecraftError minecrafterror)
    {
    }
    catch (ReportedException reportedexception)
    {
        this.addGraphicsAndWorldToCrashReport(reportedexception.getCrashReport());
        this.freeMemory();
        reportedexception.printStackTrace();
        this.displayCrashReport(reportedexception.getCrashReport());
    }
    catch (Throwable throwable1)
    {
        crashreport = this.addGraphicsAndWorldToCrashReport(new CrashReport("Unexpected error", throwable1));
        this.freeMemory();
        throwable1.printStackTrace();
        this.displayCrashReport(crashreport);
    }
    finally
    {
        this.shutdownMinecraftApplet();
    }

}

/**
 * Updates the progress bar on the loading screen to the specified amount. Args: loadProgress
 */
public void setLoadingProgress(int par1)
{
    if (!this.mc.running)
    {
        if (!this.field_73724_e)
        {
            throw new MinecraftError();
        }
    }
    else
    {
        long j = Minecraft.getSystemTime();

        if (j - this.field_73723_d >= 100L)
        {
            this.field_73723_d = j;
            ScaledResolution scaledresolution = new ScaledResolution(this.mc.gameSettings, this.mc.displayWidth, this.mc.displayHeight);
            int k = scaledresolution.getScaledWidth();
            int l = scaledresolution.getScaledHeight();
            GL11.glClear(GL11.GL_DEPTH_BUFFER_BIT);
            GL11.glMatrixMode(GL11.GL_PROJECTION);
            GL11.glLoadIdentity();
            GL11.glOrtho(0.0D, scaledresolution.getScaledWidth_double(), scaledresolution.getScaledHeight_double(), 0.0D, 100.0D, 300.0D);
            GL11.glMatrixMode(GL11.GL_MODELVIEW);
            GL11.glLoadIdentity();
            GL11.glTranslatef(0.0F, 0.0F, -200.0F);
            GL11.glClear(GL11.GL_COLOR_BUFFER_BIT | GL11.GL_DEPTH_BUFFER_BIT);
            Tessellator tessellator = Tessellator.instance;
            this.mc.getTextureManager().bindTexture(Gui.optionsBackground);
            float f = 32.0F;
            tessellator.startDrawingQuads();
            tessellator.setColorOpaque_I(4210752);
            tessellator.addVertexWithUV(0.0D, (double)l, 0.0D, 0.0D, (double)((float)l / f));
            tessellator.addVertexWithUV((double)k, (double)l, 0.0D, (double)((float)k / f), (double)((float)l / f));
            tessellator.addVertexWithUV((double)k, 0.0D, 0.0D, (double)((float)k / f), 0.0D);
            tessellator.addVertexWithUV(0.0D, 0.0D, 0.0D, 0.0D, 0.0D);
            tessellator.draw();

            if (par1 >= 0)
            {
                byte b0 = 100;
                byte b1 = 2;
                int i1 = k / 2 - b0 / 2;
                int j1 = l / 2 + 16;
                GL11.glDisable(GL11.GL_TEXTURE_2D);
                tessellator.startDrawingQuads();
                tessellator.setColorOpaque_I(8421504);
                tessellator.addVertex((double)i1, (double)j1, 0.0D);
                tessellator.addVertex((double)i1, (double)(j1 + b1), 0.0D);
                tessellator.addVertex((double)(i1 + b0), (double)(j1 + b1), 0.0D);
                tessellator.addVertex((double)(i1 + b0), (double)j1, 0.0D);
                tessellator.setColorOpaque_I(8454016);
                tessellator.addVertex((double)i1, (double)j1, 0.0D);
                tessellator.addVertex((double)i1, (double)(j1 + b1), 0.0D);
                tessellator.addVertex((double)(i1 + par1), (double)(j1 + b1), 0.0D);
                tessellator.addVertex((double)(i1 + par1), (double)j1, 0.0D);
                tessellator.draw();
                GL11.glEnable(GL11.GL_TEXTURE_2D);
            }

            this.mc.fontRenderer.drawStringWithShadow(this.currentlyDisplayedText, (k - this.mc.fontRenderer.getStringWidth(this.currentlyDisplayedText)) / 2, l / 2 - 4 - 16, 16777215);
            this.mc.fontRenderer.drawStringWithShadow(this.field_73727_a, (k - this.mc.fontRenderer.getStringWidth(this.field_73727_a)) / 2, l / 2 - 4 + 8, 16777215);
            Display.update();

            try
            {
                Thread.yield();
            }
            catch (Exception exception)
            {
                ;
            }
        }
    }
}

public void run()
{
    this.running = true;
    CrashReport crashreport;

    try
    {
        this.startGame();
    }
    catch (Throwable throwable)
    {
        crashreport = CrashReport.makeCrashReport(throwable, "Initializing game");
        crashreport.makeCategory("Initialization");
        this.displayCrashReport(this.addGraphicsAndWorldToCrashReport(crashreport));
        return;
    }

    try
    {
        while (this.running)
        {
            if (this.running)
            {
                if (this.hasCrashed && this.crashReporter != null)
                {
                    this.displayCrashReport(this.crashReporter);
                    return;
                }

                if (this.refreshTexturePacksScheduled)
                {
                    this.refreshTexturePacksScheduled = false;
                    this.refreshResources();
                }

                try
                {
                    this.runGameLoop();
                }
                catch (OutOfMemoryError outofmemoryerror)
                {
                    this.freeMemory();
                    this.displayGuiScreen(new GuiMemoryErrorScreen());
                    System.gc();
                }

                continue;
            }
        }
    }
    catch (MinecraftError minecrafterror)
    {
    }
    catch (ReportedException reportedexception)
    {
        this.addGraphicsAndWorldToCrashReport(reportedexception.getCrashReport());
        this.freeMemory();
        reportedexception.printStackTrace();
        this.displayCrashReport(reportedexception.getCrashReport());
    }
    catch (Throwable throwable1)
    {
        crashreport = this.addGraphicsAndWorldToCrashReport(new CrashReport("Unexpected error", throwable1));
        this.freeMemory();
        throwable1.printStackTrace();
        this.displayCrashReport(crashreport);
    }
    finally
    {
        this.shutdownMinecraftApplet();
    }

}