/** Returns an array of biomes for the location input. */
  @Override
  public BiomeGenBase[] getBiomesForGeneration(
      BiomeGenBase[] par1ArrayOfBiomeGenBase, int par2, int par3, int par4, int par5) {
    IntCache.resetIntCache();

    if (par1ArrayOfBiomeGenBase == null || par1ArrayOfBiomeGenBase.length < par4 * par5) {
      par1ArrayOfBiomeGenBase = new BiomeGenBase[par4 * par5];
    }

    int[] aint = this.mbGenBiomes.getInts(par2, par3, par4, par5);

    try {
      for (int i1 = 0; i1 < par4 * par5; ++i1) {
        par1ArrayOfBiomeGenBase[i1] = BiomeGenBase.getBiome(aint[i1]);
      }

      return par1ArrayOfBiomeGenBase;
    } catch (Throwable throwable) {
      CrashReport crashreport = CrashReport.makeCrashReport(throwable, "Invalid Biome id");
      CrashReportCategory crashreportcategory = crashreport.makeCategory("RawBiomeBlock");
      crashreportcategory.addCrashSection(
          "biomes[] size", Integer.valueOf(par1ArrayOfBiomeGenBase.length));
      crashreportcategory.addCrashSection("x", Integer.valueOf(par2));
      crashreportcategory.addCrashSection("z", Integer.valueOf(par3));
      crashreportcategory.addCrashSection("w", Integer.valueOf(par4));
      crashreportcategory.addCrashSection("h", Integer.valueOf(par5));
      throw new ReportedException(crashreport);
    }
  }
  /** checks given Chunk's Biomes against List of allowed ones */
  @Override
  public boolean areBiomesViable(int par1, int par2, int par3, List par4List) {
    IntCache.resetIntCache();
    int l = par1 - par3 >> 2;
    int i1 = par2 - par3 >> 2;
    int j1 = par1 + par3 >> 2;
    int k1 = par2 + par3 >> 2;
    int l1 = j1 - l + 1;
    int i2 = k1 - i1 + 1;
    int[] aint = this.mbGenBiomes.getInts(l, i1, l1, i2);

    try {
      for (int j2 = 0; j2 < l1 * i2; ++j2) {
        BiomeGenBase biomegenbase = BiomeGenBase.getBiome(aint[j2]);

        if (!par4List.contains(biomegenbase)) {
          return false;
        }
      }

      return true;
    } catch (Throwable throwable) {
      CrashReport crashreport = CrashReport.makeCrashReport(throwable, "Invalid Biome id");
      CrashReportCategory crashreportcategory = crashreport.makeCategory("Layer");
      crashreportcategory.addCrashSection("Layer", this.mbGenBiomes.toString());
      crashreportcategory.addCrashSection("x", Integer.valueOf(par1));
      crashreportcategory.addCrashSection("z", Integer.valueOf(par2));
      crashreportcategory.addCrashSection("radius", Integer.valueOf(par3));
      crashreportcategory.addCrashSection("allowed", par4List);
      throw new ReportedException(crashreport);
    }
  }
  /** checks given Chunk's Biomes against List of allowed ones */
  public boolean areBiomesViable(int p_76940_1_, int p_76940_2_, int p_76940_3_, List p_76940_4_) {
    IntCache.resetIntCache();
    int var5 = p_76940_1_ - p_76940_3_ >> 2;
    int var6 = p_76940_2_ - p_76940_3_ >> 2;
    int var7 = p_76940_1_ + p_76940_3_ >> 2;
    int var8 = p_76940_2_ + p_76940_3_ >> 2;
    int var9 = var7 - var5 + 1;
    int var10 = var8 - var6 + 1;
    int[] var11 = this.genBiomes.getInts(var5, var6, var9, var10);

    try {
      for (int var12 = 0; var12 < var9 * var10; ++var12) {
        BiomeGenBase var16 = BiomeGenBase.getBiome(var11[var12]);

        if (!p_76940_4_.contains(var16)) {
          return false;
        }
      }

      return true;
    } catch (Throwable var15) {
      CrashReport var13 = CrashReport.makeCrashReport(var15, "Invalid Biome id");
      CrashReportCategory var14 = var13.makeCategory("Layer");
      var14.addCrashSection("Layer", this.genBiomes.toString());
      var14.addCrashSection("x", Integer.valueOf(p_76940_1_));
      var14.addCrashSection("z", Integer.valueOf(p_76940_2_));
      var14.addCrashSection("radius", Integer.valueOf(p_76940_3_));
      var14.addCrashSection("allowed", p_76940_4_);
      throw new ReportedException(var13);
    }
  }
  private void updateEffects() {
    for (int k = 0; k < fxes.length; ++k) {

      for (int j = 0; j < this.fxes[k].size(); ++j) {
        final EntityFX entityfx = this.fxes[k].get(j);

        try {
          if (entityfx != null) {
            entityfx.onUpdate();
          }
        } catch (Throwable throwable) {
          CrashReport crashreport = CrashReport.makeCrashReport(throwable, "Ticking Particle");
          CrashReportCategory crashreportcategory =
              crashreport.makeCategory("Particle being ticked");
          crashreportcategory.addCrashSectionCallable(
              "Particle",
              new Callable() {
                private static final String __OBFID = "CL_00000916";

                public String call() {
                  return entityfx.toString();
                }
              });
          throw new ReportedException(crashreport);
        }

        if (entityfx == null || entityfx.isDead) {
          this.fxes[k].remove(j--);
        }
      }
    }
  }
  /** Returns an array of biomes for the location input. */
  public BiomeGenBase[] getBiomesForGeneration(
      BiomeGenBase[] p_76937_1_, int p_76937_2_, int p_76937_3_, int p_76937_4_, int p_76937_5_) {
    IntCache.resetIntCache();

    if (p_76937_1_ == null || p_76937_1_.length < p_76937_4_ * p_76937_5_) {
      p_76937_1_ = new BiomeGenBase[p_76937_4_ * p_76937_5_];
    }

    int[] var6 = this.genBiomes.getInts(p_76937_2_, p_76937_3_, p_76937_4_, p_76937_5_);

    try {
      for (int var7 = 0; var7 < p_76937_4_ * p_76937_5_; ++var7) {
        p_76937_1_[var7] =
            BiomeGenBase.getBiomeFromBiomeList(var6[var7], BiomeGenBase.field_180279_ad);
      }

      return p_76937_1_;
    } catch (Throwable var10) {
      CrashReport var8 = CrashReport.makeCrashReport(var10, "Invalid Biome id");
      CrashReportCategory var9 = var8.makeCategory("RawBiomeBlock");
      var9.addCrashSection("biomes[] size", Integer.valueOf(p_76937_1_.length));
      var9.addCrashSection("x", Integer.valueOf(p_76937_2_));
      var9.addCrashSection("z", Integer.valueOf(p_76937_3_));
      var9.addCrashSection("w", Integer.valueOf(p_76937_4_));
      var9.addCrashSection("h", Integer.valueOf(p_76937_5_));
      throw new ReportedException(var8);
    }
  }
  public boolean loadTexture(ResourceLocation p_110579_1_, final ITextureObject p_110579_2_) {
    boolean flag = true;
    ITextureObject p_110579_2_2 = p_110579_2_;

    try {
      ((ITextureObject) p_110579_2_).loadTexture(this.theResourceManager);
    } catch (IOException ioexception) {
      logger.warn("Failed to load texture: " + p_110579_1_, ioexception);
      p_110579_2_2 = TextureUtil.missingTexture;
      this.mapTextureObjects.put(p_110579_1_, p_110579_2_2);
      flag = false;
    } catch (Throwable throwable) {
      CrashReport crashreport = CrashReport.makeCrashReport(throwable, "Registering texture");
      CrashReportCategory crashreportcategory =
          crashreport.makeCategory("Resource location being registered");
      crashreportcategory.addCrashSection("Resource location", p_110579_1_);
      crashreportcategory.addCrashSectionCallable(
          "Texture object class",
          new Callable() {
            private static final String __OBFID = "CL_00001065";

            public String call() {
              return p_110579_2_.getClass().getName();
            }
          });
      throw new ReportedException(crashreport);
    }

    this.mapTextureObjects.put(p_110579_1_, p_110579_2_2);
    return flag;
  }
Example #7
0
 public void func_85027_a(CrashReportCategory par1CrashReportCategory) {
   par1CrashReportCategory.addCrashSectionCallable("Name", new CallableItemEntityName(this));
   par1CrashReportCategory.addCrashSectionCallable(
       "Actual item type", new CallableItemEntityType(this));
   par1CrashReportCategory.addCrashSectionCallable(
       "Actual item data value", new CallableItemEntityData(this));
 }
Example #8
0
  public boolean loadTexture(ResourceLocation textureLocation, ITextureObject textureObj) {
    boolean flag = true;

    try {
      ((ITextureObject) textureObj).loadTexture(this.theResourceManager);
    } catch (IOException ioexception) {
      logger.warn((String) ("Failed to load texture: " + textureLocation), (Throwable) ioexception);
      textureObj = TextureUtil.missingTexture;
      this.mapTextureObjects.put(textureLocation, (ITextureObject) textureObj);
      flag = false;
    } catch (Throwable throwable) {
      final ITextureObject textureObjf = textureObj;
      CrashReport crashreport = CrashReport.makeCrashReport(throwable, "Registering texture");
      CrashReportCategory crashreportcategory =
          crashreport.makeCategory("Resource location being registered");
      crashreportcategory.addCrashSection("Resource location", textureLocation);
      crashreportcategory.addCrashSectionCallable(
          "Texture object class",
          new Callable<String>() {
            public String call() throws Exception {
              return textureObjf.getClass().getName();
            }
          });
      throw new ReportedException(crashreport);
    }

    this.mapTextureObjects.put(textureLocation, (ITextureObject) textureObj);
    return flag;
  }
  public void addInfoToCrashReport(CrashReportCategory reportCategory) {
    reportCategory.addCrashSectionCallable(
        "Name",
        new Callable() {
          private static final String __OBFID = "CL_00000341";

          public String call() {
            return (String) TileEntity.classToNameMap.get(TileEntity.this.getClass())
                + " // "
                + TileEntity.this.getClass().getCanonicalName();
          }
        });
    if (this.worldObj != null) {
      CrashReportCategory.addBlockInfo(
          reportCategory, this.pos, this.getBlockType(), this.getBlockMetadata());
      reportCategory.addCrashSectionCallable(
          "Actual block type",
          new Callable() {
            private static final String __OBFID = "CL_00000343";

            public String call() {
              int var1 =
                  Block.getIdFromBlock(
                      TileEntity.this.worldObj.getBlockState(TileEntity.this.pos).getBlock());

              try {
                return String.format(
                    "ID #%d (%s // %s)",
                    new Object[] {
                      Integer.valueOf(var1),
                      Block.getBlockById(var1).getUnlocalizedName(),
                      Block.getBlockById(var1).getClass().getCanonicalName()
                    });
              } catch (Throwable var3) {
                return "ID #" + var1;
              }
            }
          });
      reportCategory.addCrashSectionCallable(
          "Actual block data value",
          new Callable() {
            private static final String __OBFID = "CL_00000344";

            public String call() {
              IBlockState var1 = TileEntity.this.worldObj.getBlockState(TileEntity.this.pos);
              int var2 = var1.getBlock().getMetaFromState(var1);
              if (var2 < 0) {
                return "Unknown? (Got " + var2 + ")";
              } else {
                String var3 =
                    String.format("%4s", new Object[] {Integer.toBinaryString(var2)})
                        .replace(" ", "0");
                return String.format(
                    "%1$d / 0x%1$X / 0b%2$s", new Object[] {Integer.valueOf(var2), var3});
              }
            }
          });
    }
  }
Example #10
0
  @SubscribeEvent
  public void onCrashReportEvent(CrashReportEvent event) {
    if (!diagnostics) return;
    if (event.getHeader().length() > 0) {
      return;
    }
    Throwable t = event.getThrowable();
    if (t instanceof LoaderException
        || t instanceof InvocationTargetException
        || t instanceof ReportedException) {
      t = t.getCause();
    }
    if (t == null) {
      return;
    }
    try {
      event.setHeader(handleThrowable(t));
    } catch (Throwable t2) {
      // Ignore any errors. We don't want to f**k up the crash reports.
    }
    List<ModContainer> mods = Utils.getModsFromStackTrace(event.getThrowable().getStackTrace());
    Set<ModContainer> s = Sets.newHashSet();
    ModContainer active = Loader.instance().activeModContainer();
    if (!mods.isEmpty() || (active != null && !active.getModId().equals("SquidAPI"))) {
      CrashReportCategory c = event.createCategory("Possibly involved mods");
      if (active != null && !active.getModId().equals("SquidAPI"))
        c.addCrashSection(
            active.getName(),
            String.format(
                "Version: %s. Main class: %s. Source: %s. Url: %s. Checksum: %s.",
                active.getVersion(),
                active.getMod().getClass().getName(),
                active.getSource().getName(),
                active.getMetadata().url,
                getChecksum(active.getSource())));
      for (ModContainer mod : mods) {
        if (!s.contains(mod)) {
          c.addCrashSection(
              mod.getName(),
              String.format(
                  "Version: %s. Main class: %s. Source: %s. Url: %s. Checksum: %s.",
                  mod.getVersion(),
                  mod.getMod().getClass().getName(),
                  mod.getSource().getName(),
                  mod.getMetadata().url,
                  getChecksum(mod.getSource())));
          s.add(mod);
        }
      }
    }
    try {
      if (Utils.isCoolSquid()) {
        event.setHeader("DRM!!! IT'S DRMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM!!!!!!!!!");
      }
    } catch (Throwable t2) {

    }
  }
Example #11
0
  public void addInfoToCrashReport(CrashReportCategory reportCategory) {
    reportCategory.setDetail(
        "Name",
        new ICrashReportDetail<String>() {
          public String call() throws Exception {
            return (String) TileEntity.classToNameMap.get(TileEntity.this.getClass())
                + " // "
                + TileEntity.this.getClass().getCanonicalName();
          }
        });

    if (this.worldObj != null) {
      CrashReportCategory.addBlockInfo(
          reportCategory, this.pos, this.getBlockType(), this.getBlockMetadata());
      reportCategory.setDetail(
          "Actual block type",
          new ICrashReportDetail<String>() {
            public String call() throws Exception {
              int i =
                  Block.getIdFromBlock(
                      TileEntity.this.worldObj.getBlockState(TileEntity.this.pos).getBlock());

              try {
                return String.format(
                    "ID #%d (%s // %s)",
                    new Object[] {
                      Integer.valueOf(i),
                      Block.getBlockById(i).getUnlocalizedName(),
                      Block.getBlockById(i).getClass().getCanonicalName()
                    });
              } catch (Throwable var3) {
                return "ID #" + i;
              }
            }
          });
      reportCategory.setDetail(
          "Actual block data value",
          new ICrashReportDetail<String>() {
            public String call() throws Exception {
              IBlockState iblockstate = TileEntity.this.worldObj.getBlockState(TileEntity.this.pos);
              int i = iblockstate.getBlock().getMetaFromState(iblockstate);

              if (i < 0) {
                return "Unknown? (Got " + i + ")";
              } else {
                String s =
                    String.format("%4s", new Object[] {Integer.toBinaryString(i)})
                        .replace(" ", "0");
                return String.format(
                    "%1$d / 0x%1$X / 0b%2$s", new Object[] {Integer.valueOf(i), s});
              }
            }
          });
    }
  }
Example #12
0
  private CrashReport func_82581_a(
      String p_82581_1_, int p_82581_2_, ClassCastException p_82581_3_) {
    CrashReport var4 = CrashReport.func_85055_a(p_82581_3_, "Reading NBT data");
    CrashReportCategory var5 = var4.func_85057_a("Corrupt NBT tag", 1);
    var5.func_71500_a("Tag type found", new CallableTagCompound1(this, p_82581_1_));
    var5.func_71500_a("Tag type expected", new CallableTagCompound2(this, p_82581_2_));
    var5.func_71507_a("Tag name", p_82581_1_);
    if (this.func_74740_e() != null && this.func_74740_e().length() > 0) {
      var5.func_71507_a("Tag parent", this.func_74740_e());
    }

    return var4;
  }
Example #13
0
  public static void populateCrashReport(CrashReport crashReport) {
    if (EventProxy.error != null) {
      CrashReportCategory category = crashReport.makeCategoryDepth("Event Handler Error", 1);

      category.addCrashSectionCallable(
          EventProxy.error,
          new Callable<String>() {
            @Override
            public String call() throws Exception {
              return EventProxy.errorDetails.toString();
            }
          });
    }
  }
  public void renderParticles(Entity entity, float f) {
    float f1 = ActiveRenderInfo.rotationX;
    float f2 = ActiveRenderInfo.rotationZ;
    float f3 = ActiveRenderInfo.rotationYZ;
    float f4 = ActiveRenderInfo.rotationXY;
    float f5 = ActiveRenderInfo.rotationXZ;
    EntityFX.interpPosX = entity.lastTickPosX + (entity.posX - entity.lastTickPosX) * (double) f;
    EntityFX.interpPosY = entity.lastTickPosY + (entity.posY - entity.lastTickPosY) * (double) f;
    EntityFX.interpPosZ = entity.lastTickPosZ + (entity.posZ - entity.lastTickPosZ) * (double) f;

    for (int k = 0; k < fxes.length; ++k) {
      if (!this.fxes[k].isEmpty()) {
        GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
        GL11.glDepthMask(false);
        GL11.glEnable(GL11.GL_BLEND);
        switch (k) {
          case 0:
            GL11.glBlendFunc(GL11.GL_ONE, GL11.GL_ONE);
            renderer.bindTexture(additiveTextureSheet);
            break;
        }

        GL11.glAlphaFunc(GL11.GL_GREATER, 0.003921569F);
        Tessellator tessellator = Tessellator.instance;
        tessellator.startDrawingQuads();

        for (int j = 0; j < this.fxes[k].size(); ++j) {
          final EntityFX entityfx = this.fxes[k].get(j);
          if (entityfx == null) continue;
          tessellator.setBrightness(entityfx.getBrightnessForRender(f));

          try {
            entityfx.renderParticle(tessellator, f, f1, f5, f2, f3, f4);
          } catch (Throwable throwable) {
            CrashReport crashreport = CrashReport.makeCrashReport(throwable, "Rendering Particle");
            CrashReportCategory crashreportcategory =
                crashreport.makeCategory("Particle being rendered");
            crashreportcategory.addCrashSectionCallable("Particle", entityfx::toString);
            throw new ReportedException(crashreport);
          }
        }

        tessellator.draw();
        GL11.glDisable(GL11.GL_BLEND);
        GL11.glDepthMask(true);
        GL11.glAlphaFunc(GL11.GL_GREATER, 0.1F);
      }
    }
  }
Example #15
0
  private DataWatcher.WatchableObject func_75691_i(int p_75691_1_) {
    this.field_75694_d.readLock().lock();

    DataWatcher.WatchableObject var2;
    try {
      var2 = (DataWatcher.WatchableObject) this.field_75695_b.get(Integer.valueOf(p_75691_1_));
    } catch (Throwable var6) {
      CrashReport var4 = CrashReport.func_85055_a(var6, "Getting synched entity data");
      CrashReportCategory var5 = var4.func_85058_a("Synched entity data");
      var5.func_71507_a("Data ID", Integer.valueOf(p_75691_1_));
      throw new ReportedException(var4);
    }

    this.field_75694_d.readLock().unlock();
    return var2;
  }
  private <T> EntityDataManager.DataEntry<T> getEntry(DataParameter<T> key) {
    this.lock.readLock().lock();
    EntityDataManager.DataEntry<T> dataentry;

    try {
      dataentry = (EntityDataManager.DataEntry) this.entries.get(Integer.valueOf(key.getId()));
    } catch (Throwable throwable) {
      CrashReport crashreport =
          CrashReport.makeCrashReport(throwable, "Getting synched entity data");
      CrashReportCategory crashreportcategory = crashreport.makeCategory("Synched entity data");
      crashreportcategory.addCrashSection("Data ID", key);
      throw new ReportedException(crashreport);
    }

    this.lock.readLock().unlock();
    return dataentry;
  }
  /** is threadsafe, unless it throws an exception, then */
  private WatchableObject getWatchedObject(int par1) {
    this.lock.readLock().lock();
    WatchableObject watchableobject;

    try {
      watchableobject = (WatchableObject) this.watchedObjects.get(Integer.valueOf(par1));
    } catch (Throwable throwable) {
      CrashReport crashreport =
          CrashReport.makeCrashReport(throwable, "Getting synched entity data");
      CrashReportCategory crashreportcategory = crashreport.makeCategory("Synched entity data");
      crashreportcategory.addCrashSection("Data ID", Integer.valueOf(par1));
      throw new ReportedException(crashreport);
    }

    this.lock.readLock().unlock();
    return watchableobject;
  }
Example #18
0
  protected static boolean func_151616_a(final int p_151616_0_, final int p_151616_1_) {
    if (p_151616_0_ == p_151616_1_) {
      return true;
    } else if (p_151616_0_ != BiomeGenBase.field_150607_aa.biomeID
        && p_151616_0_ != BiomeGenBase.field_150608_ab.biomeID) {
      try {
        return BiomeGenBase.func_150568_d(p_151616_0_) != null
                && BiomeGenBase.func_150568_d(p_151616_1_) != null
            ? BiomeGenBase.func_150568_d(p_151616_0_)
                .func_150569_a(BiomeGenBase.func_150568_d(p_151616_1_))
            : false;
      } catch (Throwable var5) {
        CrashReport var3 = CrashReport.makeCrashReport(var5, "Comparing biomes");
        CrashReportCategory var4 = var3.makeCategory("Biomes being compared");
        var4.addCrashSection("Biome A ID", Integer.valueOf(p_151616_0_));
        var4.addCrashSection("Biome B ID", Integer.valueOf(p_151616_1_));
        var4.addCrashSectionCallable(
            "Biome A",
            new Callable() {
              private static final String __OBFID = "CL_00000560";

              public String call() {
                return String.valueOf(BiomeGenBase.func_150568_d(p_151616_0_));
              }
            });
        var4.addCrashSectionCallable(
            "Biome B",
            new Callable() {
              private static final String __OBFID = "CL_00000561";

              public String call() {
                return String.valueOf(BiomeGenBase.func_150568_d(p_151616_1_));
              }
            });
        throw new ReportedException(var3);
      }
    } else {
      return p_151616_1_ == BiomeGenBase.field_150607_aa.biomeID
          || p_151616_1_ == BiomeGenBase.field_150608_ab.biomeID;
    }
  }
  /**
   * Returns a list of rainfall values for the specified blocks. Args: listToReuse, x, z, width,
   * length.
   */
  public float[] getRainfall(
      float[] p_76936_1_, int p_76936_2_, int p_76936_3_, int p_76936_4_, int p_76936_5_) {
    IntCache.resetIntCache();

    if (p_76936_1_ == null || p_76936_1_.length < p_76936_4_ * p_76936_5_) {
      p_76936_1_ = new float[p_76936_4_ * p_76936_5_];
    }

    int[] var6 = this.biomeIndexLayer.getInts(p_76936_2_, p_76936_3_, p_76936_4_, p_76936_5_);

    for (int var7 = 0; var7 < p_76936_4_ * p_76936_5_; ++var7) {
      try {
        float var8 =
            (float)
                    BiomeGenBase.getBiomeFromBiomeList(var6[var7], BiomeGenBase.field_180279_ad)
                        .getIntRainfall()
                / 65536.0F;

        if (var8 > 1.0F) {
          var8 = 1.0F;
        }

        p_76936_1_[var7] = var8;
      } catch (Throwable var11) {
        CrashReport var9 = CrashReport.makeCrashReport(var11, "Invalid Biome id");
        CrashReportCategory var10 = var9.makeCategory("DownfallBlock");
        var10.addCrashSection("biome id", Integer.valueOf(var7));
        var10.addCrashSection("downfalls[] size", Integer.valueOf(p_76936_1_.length));
        var10.addCrashSection("x", Integer.valueOf(p_76936_2_));
        var10.addCrashSection("z", Integer.valueOf(p_76936_3_));
        var10.addCrashSection("w", Integer.valueOf(p_76936_4_));
        var10.addCrashSection("h", Integer.valueOf(p_76936_5_));
        throw new ReportedException(var9);
      }
    }

    return p_76936_1_;
  }
  /**
   * Renders the specified entity with the passed in position, yaw, and partialTickTime. Args:
   * entity, x, y, z, yaw, partialTickTime
   */
  public void renderEntityWithPosYaw(
      Entity par1Entity, double par2, double par4, double par6, float par8, float par9) {
    Render render = null;

    try {
      render = this.getEntityRenderObject(par1Entity);

      if (render != null && this.renderEngine != null) {
        if (field_85095_o && !par1Entity.isInvisible()) {
          try {
            this.func_85094_b(par1Entity, par2, par4, par6, par8, par9);
          } catch (Throwable throwable) {
            throw new ReportedException(
                CrashReport.makeCrashReport(throwable, "Rendering entity hitbox in world"));
          }
        }

        try {
          render.doRender(par1Entity, par2, par4, par6, par8, par9);
        } catch (Throwable throwable1) {
          throw new ReportedException(
              CrashReport.makeCrashReport(throwable1, "Rendering entity in world"));
        }

        try {
          render.doRenderShadowAndFire(par1Entity, par2, par4, par6, par8, par9);
        } catch (Throwable throwable2) {
          throw new ReportedException(
              CrashReport.makeCrashReport(throwable2, "Post-rendering entity in world"));
        }
      }
    } catch (Throwable throwable3) {
      CrashReport crashreport =
          CrashReport.makeCrashReport(throwable3, "Rendering entity in world");
      CrashReportCategory crashreportcategory = crashreport.makeCategory("Entity being rendered");
      par1Entity.func_85029_a(crashreportcategory);
      CrashReportCategory crashreportcategory1 = crashreport.makeCategory("Renderer details");
      crashreportcategory1.addCrashSection("Assigned renderer", render);
      crashreportcategory1.addCrashSection(
          "Location", CrashReportCategory.func_85074_a(par2, par4, par6));
      crashreportcategory1.addCrashSection("Rotation", Float.valueOf(par8));
      crashreportcategory1.addCrashSection("Delta", Float.valueOf(par9));
      throw new ReportedException(crashreport);
    }
  }
Example #21
0
 public CrashReportCategory func_72914_a(CrashReport p_72914_1_) {
   CrashReportCategory var2 = super.func_72914_a(p_72914_1_);
   var2.func_71500_a("Forced entities", new CallableMPL1(this));
   var2.func_71500_a("Retry entities", new CallableMPL2(this));
   return var2;
 }
Example #22
0
 public void enhanceCrashReport(CrashReport crashReport, CrashReportCategory category) {
   for (ICrashCallable call : crashCallables) {
     category.func_71500_a(call.getLabel(), call);
   }
 }
 public String func_85134_a() {
   return CrashReportCategory.func_85071_a(
       WorldInfo.func_85125_d(this.field_85135_a),
       WorldInfo.func_85124_e(this.field_85135_a),
       WorldInfo.func_85123_f(this.field_85135_a));
 }