/** 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;
}
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));
}
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});
}
}
});
}
}
@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) {
}
}
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});
}
}
});
}
}
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;
}
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);
}
}
}
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;
}
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);
}
}
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;
}
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));
}