eaglercraft/Project164
1
0
Fork 0
mirror of https://git.zelz.net/catfoolyou/Project164.git synced 2025-12-14 10:57:42 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fixed server crash

Browse Source
This commit is contained in:
catfoolyou
2025-02-27 10:59:22 -05:00
parent 30ad33dcef
commit ca62d2cae1
52 changed files with 107 additions and 3747 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
src/main/java/net/minecraft/server/MinecraftServer.java
View File

@@ -10,7 +10,6 @@ import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import net.minecraft.src.AnvilSaveConverter;
import net.minecraft.src.AxisAlignedBB;
import net.minecraft.src.CallableIsServerModded;
import net.minecraft.src.CallableServerMemoryStats;
@@ -53,7 +52,7 @@ public abstract class MinecraftServer implements ICommandSender, Runnable, IPlay
{
/** Instance of Minecraft Server. */
private static MinecraftServer mcServer;
private final ISaveFormat anvilConverterForAnvilFile;
//private final ISaveFormat anvilConverterForAnvilFile;
/** The PlayerUsageSnooper instance. */
private final PlayerUsageSnooper usageSnooper = new PlayerUsageSnooper("server", this, getSystemTimeMillis());
@@ -166,7 +165,7 @@ public abstract class MinecraftServer implements ICommandSender, Runnable, IPlay
mcServer = this;
this.anvilFile = par1File;
this.commandManager = new ServerCommandManager();
this.anvilConverterForAnvilFile = new AnvilSaveConverter(par1File);
//this.anvilConverterForAnvilFile = new AnvilSaveConverter(par1File);
this.registerDispenseBehaviors();
}
@@ -212,7 +211,7 @@ public abstract class MinecraftServer implements ICommandSender, Runnable, IPlay
this.setUserMessage("menu.loadingLevel");
this.worldServers = new WorldServer[3];
this.timeOfLastDimensionTick = new long[this.worldServers.length][100];
ISaveHandler var7 = this.anvilConverterForAnvilFile.getSaveLoader(par1Str, true);
ISaveHandler var7 = null;
WorldInfo var9 = var7.loadWorldInfo();
WorldSettings var8;
@@ -1044,7 +1043,7 @@ public abstract class MinecraftServer implements ICommandSender, Runnable, IPlay
public ISaveFormat getActiveAnvilConverter()
{
return this.anvilConverterForAnvilFile;
return null;
}
/**

425
src/main/java/net/minecraft/src/AnvilChunkLoader.java
View File

@@ -1,425 +0,0 @@
package net.minecraft.src;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
public class AnvilChunkLoader implements IChunkLoader, IThreadedFileIO
{
private List chunksToRemove = new ArrayList();
private Set pendingAnvilChunksCoordinates = new HashSet();
private Object syncLockObject = new Object();
/** Save directory for chunks using the Anvil format */
private final File chunkSaveLocation;
public AnvilChunkLoader(File par1File)
{
this.chunkSaveLocation = par1File;
}
/**
* Loads the specified(XZ) chunk into the specified world.
*/
public Chunk loadChunk(World par1World, int par2, int par3) throws IOException
{
NBTTagCompound var4 = null;
ChunkCoordIntPair var5 = new ChunkCoordIntPair(par2, par3);
Object var6 = this.syncLockObject;
synchronized (this.syncLockObject)
{
if (this.pendingAnvilChunksCoordinates.contains(var5))
{
for (int var7 = 0; var7 < this.chunksToRemove.size(); ++var7)
{
if (((AnvilChunkLoaderPending)this.chunksToRemove.get(var7)).chunkCoordinate.equals(var5))
{
var4 = ((AnvilChunkLoaderPending)this.chunksToRemove.get(var7)).nbtTags;
break;
}
}
}
}
if (var4 == null)
{
DataInputStream var10 = RegionFileCache.getChunkInputStream(this.chunkSaveLocation, par2, par3);
if (var10 == null)
{
return null;
}
var4 = CompressedStreamTools.read(var10);
}
return this.checkedReadChunkFromNBT(par1World, par2, par3, var4);
}
/**
* Wraps readChunkFromNBT. Checks the coordinates and several NBT tags.
*/
protected Chunk checkedReadChunkFromNBT(World par1World, int par2, int par3, NBTTagCompound par4NBTTagCompound)
{
if (!par4NBTTagCompound.hasKey("Level"))
{
System.err.println("Chunk file at " + par2 + "," + par3 + " is missing level data, skipping");
return null;
}
else if (!par4NBTTagCompound.getCompoundTag("Level").hasKey("Sections"))
{
System.err.println("Chunk file at " + par2 + "," + par3 + " is missing block data, skipping");
return null;
}
else
{
Chunk var5 = this.readChunkFromNBT(par1World, par4NBTTagCompound.getCompoundTag("Level"));
if (!var5.isAtLocation(par2, par3))
{
System.err.println("Chunk file at " + par2 + "," + par3 + " is in the wrong location; relocating. (Expected " + par2 + ", " + par3 + ", got " + var5.xPosition + ", " + var5.zPosition + ")");
par4NBTTagCompound.setInteger("xPos", par2);
par4NBTTagCompound.setInteger("zPos", par3);
var5 = this.readChunkFromNBT(par1World, par4NBTTagCompound.getCompoundTag("Level"));
}
return var5;
}
}
public void saveChunk(World par1World, Chunk par2Chunk) throws MinecraftException, IOException
{
par1World.checkSessionLock();
try
{
NBTTagCompound var3 = new NBTTagCompound();
NBTTagCompound var4 = new NBTTagCompound();
var3.setTag("Level", var4);
this.writeChunkToNBT(par2Chunk, par1World, var4);
this.addChunkToPending(par2Chunk.getChunkCoordIntPair(), var3);
}
catch (Exception var5)
{
var5.printStackTrace();
}
}
protected void addChunkToPending(ChunkCoordIntPair par1ChunkCoordIntPair, NBTTagCompound par2NBTTagCompound)
{
Object var3 = this.syncLockObject;
synchronized (this.syncLockObject)
{
if (this.pendingAnvilChunksCoordinates.contains(par1ChunkCoordIntPair))
{
for (int var4 = 0; var4 < this.chunksToRemove.size(); ++var4)
{
if (((AnvilChunkLoaderPending)this.chunksToRemove.get(var4)).chunkCoordinate.equals(par1ChunkCoordIntPair))
{
this.chunksToRemove.set(var4, new AnvilChunkLoaderPending(par1ChunkCoordIntPair, par2NBTTagCompound));
return;
}
}
}
this.chunksToRemove.add(new AnvilChunkLoaderPending(par1ChunkCoordIntPair, par2NBTTagCompound));
this.pendingAnvilChunksCoordinates.add(par1ChunkCoordIntPair);
ThreadedFileIOBase.threadedIOInstance.queueIO(this);
}
}
/**
* Returns a boolean stating if the write was unsuccessful.
*/
public boolean writeNextIO()
{
AnvilChunkLoaderPending var1 = null;
Object var2 = this.syncLockObject;
synchronized (this.syncLockObject)
{
if (this.chunksToRemove.isEmpty())
{
return false;
}
var1 = (AnvilChunkLoaderPending)this.chunksToRemove.remove(0);
this.pendingAnvilChunksCoordinates.remove(var1.chunkCoordinate);
}
if (var1 != null)
{
try
{
this.writeChunkNBTTags(var1);
}
catch (Exception var4)
{
var4.printStackTrace();
}
}
return true;
}
private void writeChunkNBTTags(AnvilChunkLoaderPending par1AnvilChunkLoaderPending) throws IOException
{
DataOutputStream var2 = RegionFileCache.getChunkOutputStream(this.chunkSaveLocation, par1AnvilChunkLoaderPending.chunkCoordinate.chunkXPos, par1AnvilChunkLoaderPending.chunkCoordinate.chunkZPos);
CompressedStreamTools.write(par1AnvilChunkLoaderPending.nbtTags, var2);
var2.close();
}
/**
* Save extra data associated with this Chunk not normally saved during autosave, only during chunk unload.
* Currently unused.
*/
public void saveExtraChunkData(World par1World, Chunk par2Chunk) {}
/**
* Called every World.tick()
*/
public void chunkTick() {}
/**
* Save extra data not associated with any Chunk. Not saved during autosave, only during world unload. Currently
* unused.
*/
public void saveExtraData()
{
while (this.writeNextIO())
{
;
}
}
/**
* Writes the Chunk passed as an argument to the NBTTagCompound also passed, using the World argument to retrieve
* the Chunk's last update time.
*/
private void writeChunkToNBT(Chunk par1Chunk, World par2World, NBTTagCompound par3NBTTagCompound)
{
par3NBTTagCompound.setInteger("xPos", par1Chunk.xPosition);
par3NBTTagCompound.setInteger("zPos", par1Chunk.zPosition);
par3NBTTagCompound.setLong("LastUpdate", par2World.getTotalWorldTime());
par3NBTTagCompound.setIntArray("HeightMap", par1Chunk.heightMap);
par3NBTTagCompound.setBoolean("TerrainPopulated", par1Chunk.isTerrainPopulated);
par3NBTTagCompound.setLong("InhabitedTime", par1Chunk.inhabitedTime);
ExtendedBlockStorage[] var4 = par1Chunk.getBlockStorageArray();
NBTTagList var5 = new NBTTagList("Sections");
boolean var6 = !par2World.provider.hasNoSky;
ExtendedBlockStorage[] var7 = var4;
int var8 = var4.length;
NBTTagCompound var11;
for (int var9 = 0; var9 < var8; ++var9)
{
ExtendedBlockStorage var10 = var7[var9];
if (var10 != null)
{
var11 = new NBTTagCompound();
var11.setByte("Y", (byte)(var10.getYLocation() >> 4 & 255));
var11.setByteArray("Blocks", var10.getBlockLSBArray());
if (var10.getBlockMSBArray() != null)
{
var11.setByteArray("Add", var10.getBlockMSBArray().data);
}
var11.setByteArray("Data", var10.getMetadataArray().data);
var11.setByteArray("BlockLight", var10.getBlocklightArray().data);
if (var6)
{
var11.setByteArray("SkyLight", var10.getSkylightArray().data);
}
else
{
var11.setByteArray("SkyLight", new byte[var10.getBlocklightArray().data.length]);
}
var5.appendTag(var11);
}
}
par3NBTTagCompound.setTag("Sections", var5);
par3NBTTagCompound.setByteArray("Biomes", par1Chunk.getBiomeArray());
par1Chunk.hasEntities = false;
NBTTagList var16 = new NBTTagList();
Iterator var18;
for (var8 = 0; var8 < par1Chunk.entityLists.length; ++var8)
{
var18 = par1Chunk.entityLists[var8].iterator();
while (var18.hasNext())
{
Entity var20 = (Entity)var18.next();
var11 = new NBTTagCompound();
if (var20.writeToNBTOptional(var11))
{
par1Chunk.hasEntities = true;
var16.appendTag(var11);
}
}
}
par3NBTTagCompound.setTag("Entities", var16);
NBTTagList var17 = new NBTTagList();
var18 = par1Chunk.chunkTileEntityMap.values().iterator();
while (var18.hasNext())
{
TileEntity var21 = (TileEntity)var18.next();
var11 = new NBTTagCompound();
var21.writeToNBT(var11);
var17.appendTag(var11);
}
par3NBTTagCompound.setTag("TileEntities", var17);
List var19 = par2World.getPendingBlockUpdates(par1Chunk, false);
if (var19 != null)
{
long var22 = par2World.getTotalWorldTime();
NBTTagList var12 = new NBTTagList();
Iterator var13 = var19.iterator();
while (var13.hasNext())
{
NextTickListEntry var14 = (NextTickListEntry)var13.next();
NBTTagCompound var15 = new NBTTagCompound();
var15.setInteger("i", var14.blockID);
var15.setInteger("x", var14.xCoord);
var15.setInteger("y", var14.yCoord);
var15.setInteger("z", var14.zCoord);
var15.setInteger("t", (int)(var14.scheduledTime - var22));
var15.setInteger("p", var14.priority);
var12.appendTag(var15);
}
par3NBTTagCompound.setTag("TileTicks", var12);
}
}
/**
* Reads the data stored in the passed NBTTagCompound and creates a Chunk with that data in the passed World.
* Returns the created Chunk.
*/
private Chunk readChunkFromNBT(World par1World, NBTTagCompound par2NBTTagCompound)
{
int var3 = par2NBTTagCompound.getInteger("xPos");
int var4 = par2NBTTagCompound.getInteger("zPos");
Chunk var5 = new Chunk(par1World, var3, var4);
var5.heightMap = par2NBTTagCompound.getIntArray("HeightMap");
var5.isTerrainPopulated = par2NBTTagCompound.getBoolean("TerrainPopulated");
var5.inhabitedTime = par2NBTTagCompound.getLong("InhabitedTime");
NBTTagList var6 = par2NBTTagCompound.getTagList("Sections");
byte var7 = 16;
ExtendedBlockStorage[] var8 = new ExtendedBlockStorage[var7];
boolean var9 = !par1World.provider.hasNoSky;
for (int var10 = 0; var10 < var6.tagCount(); ++var10)
{
NBTTagCompound var11 = (NBTTagCompound)var6.tagAt(var10);
byte var12 = var11.getByte("Y");
ExtendedBlockStorage var13 = new ExtendedBlockStorage(var12 << 4, var9);
var13.setBlockLSBArray(var11.getByteArray("Blocks"));
if (var11.hasKey("Add"))
{
var13.setBlockMSBArray(new NibbleArray(var11.getByteArray("Add"), 4));
}
var13.setBlockMetadataArray(new NibbleArray(var11.getByteArray("Data"), 4));
var13.setBlocklightArray(new NibbleArray(var11.getByteArray("BlockLight"), 4));
if (var9)
{
var13.setSkylightArray(new NibbleArray(var11.getByteArray("SkyLight"), 4));
}
var13.removeInvalidBlocks();
var8[var12] = var13;
}
var5.setStorageArrays(var8);
if (par2NBTTagCompound.hasKey("Biomes"))
{
var5.setBiomeArray(par2NBTTagCompound.getByteArray("Biomes"));
}
NBTTagList var17 = par2NBTTagCompound.getTagList("Entities");
if (var17 != null)
{
for (int var18 = 0; var18 < var17.tagCount(); ++var18)
{
NBTTagCompound var20 = (NBTTagCompound)var17.tagAt(var18);
Entity var22 = EntityList.createEntityFromNBT(var20, par1World);
var5.hasEntities = true;
if (var22 != null)
{
var5.addEntity(var22);
Entity var14 = var22;
for (NBTTagCompound var15 = var20; var15.hasKey("Riding"); var15 = var15.getCompoundTag("Riding"))
{
Entity var16 = EntityList.createEntityFromNBT(var15.getCompoundTag("Riding"), par1World);
if (var16 != null)
{
var5.addEntity(var16);
var14.mountEntity(var16);
}
var14 = var16;
}
}
}
}
NBTTagList var19 = par2NBTTagCompound.getTagList("TileEntities");
if (var19 != null)
{
for (int var21 = 0; var21 < var19.tagCount(); ++var21)
{
NBTTagCompound var24 = (NBTTagCompound)var19.tagAt(var21);
TileEntity var26 = TileEntity.createAndLoadEntity(var24);
if (var26 != null)
{
var5.addTileEntity(var26);
}
}
}
if (par2NBTTagCompound.hasKey("TileTicks"))
{
NBTTagList var23 = par2NBTTagCompound.getTagList("TileTicks");
if (var23 != null)
{
for (int var25 = 0; var25 < var23.tagCount(); ++var25)
{
NBTTagCompound var27 = (NBTTagCompound)var23.tagAt(var25);
par1World.scheduleBlockUpdateFromLoad(var27.getInteger("x"), var27.getInteger("y"), var27.getInteger("z"), var27.getInteger("i"), var27.getInteger("t"), var27.getInteger("p"));
}
}
}
return var5;
}
}

13
src/main/java/net/minecraft/src/AnvilChunkLoaderPending.java
View File

@@ -1,13 +0,0 @@
package net.minecraft.src;
class AnvilChunkLoaderPending
{
public final ChunkCoordIntPair chunkCoordinate;
public final NBTTagCompound nbtTags;
public AnvilChunkLoaderPending(ChunkCoordIntPair par1ChunkCoordIntPair, NBTTagCompound par2NBTTagCompound)
{
this.chunkCoordinate = par1ChunkCoordIntPair;
this.nbtTags = par2NBTTagCompound;
}
}

23
src/main/java/net/minecraft/src/AnvilConverterData.java
View File

@@ -1,23 +0,0 @@
package net.minecraft.src;
public class AnvilConverterData
{
public long lastUpdated;
public boolean terrainPopulated;
public byte[] heightmap;
public NibbleArrayReader blockLight;
public NibbleArrayReader skyLight;
public NibbleArrayReader data;
public byte[] blocks;
public NBTTagList entities;
public NBTTagList tileEntities;
public NBTTagList tileTicks;
public final int x;
public final int z;
public AnvilConverterData(int par1, int par2)
{
this.x = par1;
this.z = par2;
}
}

9
src/main/java/net/minecraft/src/AnvilConverterException.java
View File

@@ -1,9 +0,0 @@
package net.minecraft.src;
public class AnvilConverterException extends Exception
{
public AnvilConverterException(String par1Str)
{
super(par1Str);
}
}

263
src/main/java/net/minecraft/src/AnvilSaveConverter.java
View File

@@ -1,263 +0,0 @@
package net.minecraft.src;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import net.minecraft.server.MinecraftServer;
public class AnvilSaveConverter extends SaveFormatOld
{
public AnvilSaveConverter(File par1File)
{
super(par1File);
}
public List getSaveList() throws AnvilConverterException
{
if (this.savesDirectory != null && this.savesDirectory.exists() && this.savesDirectory.isDirectory())
{
ArrayList var1 = new ArrayList();
File[] var2 = this.savesDirectory.listFiles();
File[] var3 = var2;
int var4 = var2.length;
for (int var5 = 0; var5 < var4; ++var5)
{
File var6 = var3[var5];
if (var6.isDirectory())
{
String var7 = var6.getName();
WorldInfo var8 = this.getWorldInfo(var7);
if (var8 != null && (var8.getSaveVersion() == 19132 || var8.getSaveVersion() == 19133))
{
boolean var9 = var8.getSaveVersion() != this.getSaveVersion();
String var10 = var8.getWorldName();
if (var10 == null || MathHelper.stringNullOrLengthZero(var10))
{
var10 = var7;
}
long var11 = 0L;
var1.add(new SaveFormatComparator(var7, var10, var8.getLastTimePlayed(), var11, var8.getGameType(), var9, var8.isHardcoreModeEnabled(), var8.areCommandsAllowed()));
}
}
}
return var1;
}
else
{
throw new AnvilConverterException("Unable to read or access folder where game worlds are saved!");
}
}
protected int getSaveVersion()
{
return 19133;
}
public void flushCache()
{
RegionFileCache.clearRegionFileReferences();
}
/**
* Returns back a loader for the specified save directory
*/
public ISaveHandler getSaveLoader(String par1Str, boolean par2)
{
return new AnvilSaveHandler(this.savesDirectory, par1Str, par2);
}
/**
* Checks if the save directory uses the old map format
*/
public boolean isOldMapFormat(String par1Str)
{
WorldInfo var2 = this.getWorldInfo(par1Str);
return var2 != null && var2.getSaveVersion() != this.getSaveVersion();
}
/**
* Converts the specified map to the new map format. Args: worldName, loadingScreen
*/
public boolean convertMapFormat(String par1Str, IProgressUpdate par2IProgressUpdate)
{
par2IProgressUpdate.setLoadingProgress(0);
ArrayList var3 = new ArrayList();
ArrayList var4 = new ArrayList();
ArrayList var5 = new ArrayList();
File var6 = new File(this.savesDirectory, par1Str);
File var7 = new File(var6, "DIM-1");
File var8 = new File(var6, "DIM1");
MinecraftServer.getServer().getLogAgent().logInfo("Scanning folders...");
this.addRegionFilesToCollection(var6, var3);
if (var7.exists())
{
this.addRegionFilesToCollection(var7, var4);
}
if (var8.exists())
{
this.addRegionFilesToCollection(var8, var5);
}
int var9 = var3.size() + var4.size() + var5.size();
MinecraftServer.getServer().getLogAgent().logInfo("Total conversion count is " + var9);
WorldInfo var10 = this.getWorldInfo(par1Str);
Object var11 = null;
if (var10.getTerrainType() == WorldType.FLAT)
{
var11 = new WorldChunkManagerHell(BiomeGenBase.plains, 0.5F, 0.5F);
}
else
{
var11 = new WorldChunkManager(var10.getSeed(), var10.getTerrainType());
}
this.convertFile(new File(var6, "region"), var3, (WorldChunkManager)var11, 0, var9, par2IProgressUpdate);
this.convertFile(new File(var7, "region"), var4, new WorldChunkManagerHell(BiomeGenBase.hell, 1.0F, 0.0F), var3.size(), var9, par2IProgressUpdate);
this.convertFile(new File(var8, "region"), var5, new WorldChunkManagerHell(BiomeGenBase.sky, 0.5F, 0.0F), var3.size() + var4.size(), var9, par2IProgressUpdate);
var10.setSaveVersion(19133);
if (var10.getTerrainType() == WorldType.DEFAULT_1_1)
{
var10.setTerrainType(WorldType.DEFAULT);
}
this.createFile(par1Str);
ISaveHandler var12 = this.getSaveLoader(par1Str, false);
var12.saveWorldInfo(var10);
return true;
}
/**
* par: filename for the level.dat_mcr backup
*/
private void createFile(String par1Str)
{
File var2 = new File(this.savesDirectory, par1Str);
if (!var2.exists())
{
System.out.println("Warning: Unable to create level.dat_mcr backup");
}
else
{
File var3 = new File(var2, "level.dat");
if (!var3.exists())
{
System.out.println("Warning: Unable to create level.dat_mcr backup");
}
else
{
File var4 = new File(var2, "level.dat_mcr");
if (!var3.renameTo(var4))
{
System.out.println("Warning: Unable to create level.dat_mcr backup");
}
}
}
}
private void convertFile(File par1File, Iterable par2Iterable, WorldChunkManager par3WorldChunkManager, int par4, int par5, IProgressUpdate par6IProgressUpdate)
{
Iterator var7 = par2Iterable.iterator();
while (var7.hasNext())
{
File var8 = (File)var7.next();
this.convertChunks(par1File, var8, par3WorldChunkManager, par4, par5, par6IProgressUpdate);
++par4;
int var9 = (int)Math.round(100.0D * (double)par4 / (double)par5);
par6IProgressUpdate.setLoadingProgress(var9);
}
}
/**
* copies a 32x32 chunk set from par2File to par1File, via AnvilConverterData
*/
private void convertChunks(File par1File, File par2File, WorldChunkManager par3WorldChunkManager, int par4, int par5, IProgressUpdate par6IProgressUpdate)
{
try
{
String var7 = par2File.getName();
RegionFile var8 = new RegionFile(par2File);
RegionFile var9 = new RegionFile(new File(par1File, var7.substring(0, var7.length() - ".mcr".length()) + ".mca"));
for (int var10 = 0; var10 < 32; ++var10)
{
int var11;
for (var11 = 0; var11 < 32; ++var11)
{
if (var8.isChunkSaved(var10, var11) && !var9.isChunkSaved(var10, var11))
{
DataInputStream var12 = var8.getChunkDataInputStream(var10, var11);
if (var12 == null)
{
MinecraftServer.getServer().getLogAgent().logWarning("Failed to fetch input stream");
}
else
{
NBTTagCompound var13 = CompressedStreamTools.read(var12);
var12.close();
NBTTagCompound var14 = var13.getCompoundTag("Level");
AnvilConverterData var15 = ChunkLoader.load(var14);
NBTTagCompound var16 = new NBTTagCompound();
NBTTagCompound var17 = new NBTTagCompound();
var16.setTag("Level", var17);
ChunkLoader.convertToAnvilFormat(var15, var17, par3WorldChunkManager);
DataOutputStream var18 = var9.getChunkDataOutputStream(var10, var11);
CompressedStreamTools.write(var16, var18);
var18.close();
}
}
}
var11 = (int)Math.round(100.0D * (double)(par4 * 1024) / (double)(par5 * 1024));
int var20 = (int)Math.round(100.0D * (double)((var10 + 1) * 32 + par4 * 1024) / (double)(par5 * 1024));
if (var20 > var11)
{
par6IProgressUpdate.setLoadingProgress(var20);
}
}
var8.close();
var9.close();
}
catch (IOException var19)
{
var19.printStackTrace();
}
}
/**
* filters the files in the par1 directory, and adds them to the par2 collections
*/
private void addRegionFilesToCollection(File par1File, Collection par2Collection)
{
File var3 = new File(par1File, "region");
File[] var4 = var3.listFiles(new AnvilSaveConverterFileFilter(this));
if (var4 != null)
{
Collections.addAll(par2Collection, var4);
}
}
}

19
src/main/java/net/minecraft/src/AnvilSaveConverterFileFilter.java
View File

@@ -1,19 +0,0 @@
package net.minecraft.src;
import java.io.File;
import java.io.FilenameFilter;
class AnvilSaveConverterFileFilter implements FilenameFilter
{
final AnvilSaveConverter parent;
AnvilSaveConverterFileFilter(AnvilSaveConverter par1AnvilSaveConverter)
{
this.parent = par1AnvilSaveConverter;
}
public boolean accept(File par1File, String par2Str)
{
return par2Str.endsWith(".mcr");
}
}

63
src/main/java/net/minecraft/src/AnvilSaveHandler.java
View File

@@ -1,63 +0,0 @@
package net.minecraft.src;
import java.io.File;
public class AnvilSaveHandler extends SaveHandler
{
public AnvilSaveHandler(File par1File, String par2Str, boolean par3)
{
super(par1File, par2Str, par3);
}
/**
* Returns the chunk loader with the provided world provider
*/
public IChunkLoader getChunkLoader(WorldProvider par1WorldProvider)
{
File var2 = this.getWorldDirectory();
File var3;
if (par1WorldProvider instanceof WorldProviderHell)
{
var3 = new File(var2, "DIM-1");
var3.mkdirs();
return new AnvilChunkLoader(var3);
}
else if (par1WorldProvider instanceof WorldProviderEnd)
{
var3 = new File(var2, "DIM1");
var3.mkdirs();
return new AnvilChunkLoader(var3);
}
else
{
return new AnvilChunkLoader(var2);
}
}
/**
* Saves the given World Info with the given NBTTagCompound as the Player.
*/
public void saveWorldInfoWithPlayer(WorldInfo par1WorldInfo, NBTTagCompound par2NBTTagCompound)
{
par1WorldInfo.setSaveVersion(19133);
super.saveWorldInfoWithPlayer(par1WorldInfo, par2NBTTagCompound);
}
/**
* Called to flush all changes to disk, waiting for them to complete.
*/
public void flush()
{
try
{
ThreadedFileIOBase.threadedIOInstance.waitForFinish();
}
catch (InterruptedException var2)
{
var2.printStackTrace();
}
RegionFileCache.clearRegionFileReferences();
}
}

130
src/main/java/net/minecraft/src/ChunkLoader.java
View File

@@ -2,135 +2,5 @@ package net.minecraft.src;
public class ChunkLoader
{
public static AnvilConverterData load(NBTTagCompound par0NBTTagCompound)
{
int var1 = par0NBTTagCompound.getInteger("xPos");
int var2 = par0NBTTagCompound.getInteger("zPos");
AnvilConverterData var3 = new AnvilConverterData(var1, var2);
var3.blocks = par0NBTTagCompound.getByteArray("Blocks");
var3.data = new NibbleArrayReader(par0NBTTagCompound.getByteArray("Data"), 7);
var3.skyLight = new NibbleArrayReader(par0NBTTagCompound.getByteArray("SkyLight"), 7);
var3.blockLight = new NibbleArrayReader(par0NBTTagCompound.getByteArray("BlockLight"), 7);
var3.heightmap = par0NBTTagCompound.getByteArray("HeightMap");
var3.terrainPopulated = par0NBTTagCompound.getBoolean("TerrainPopulated");
var3.entities = par0NBTTagCompound.getTagList("Entities");
var3.tileEntities = par0NBTTagCompound.getTagList("TileEntities");
var3.tileTicks = par0NBTTagCompound.getTagList("TileTicks");
try
{
var3.lastUpdated = par0NBTTagCompound.getLong("LastUpdate");
}
catch (ClassCastException var5)
{
var3.lastUpdated = (long)par0NBTTagCompound.getInteger("LastUpdate");
}
return var3;
}
public static void convertToAnvilFormat(AnvilConverterData par0AnvilConverterData, NBTTagCompound par1NBTTagCompound, WorldChunkManager par2WorldChunkManager)
{
par1NBTTagCompound.setInteger("xPos", par0AnvilConverterData.x);
par1NBTTagCompound.setInteger("zPos", par0AnvilConverterData.z);
par1NBTTagCompound.setLong("LastUpdate", par0AnvilConverterData.lastUpdated);
int[] var3 = new int[par0AnvilConverterData.heightmap.length];
for (int var4 = 0; var4 < par0AnvilConverterData.heightmap.length; ++var4)
{
var3[var4] = par0AnvilConverterData.heightmap[var4];
}
par1NBTTagCompound.setIntArray("HeightMap", var3);
par1NBTTagCompound.setBoolean("TerrainPopulated", par0AnvilConverterData.terrainPopulated);
NBTTagList var16 = new NBTTagList("Sections");
int var7;
for (int var5 = 0; var5 < 8; ++var5)
{
boolean var6 = true;
for (var7 = 0; var7 < 16 && var6; ++var7)
{
int var8 = 0;
while (var8 < 16 && var6)
{
int var9 = 0;
while (true)
{
if (var9 < 16)
{
int var10 = var7 << 11 | var9 << 7 | var8 + (var5 << 4);
byte var11 = par0AnvilConverterData.blocks[var10];
if (var11 == 0)
{
++var9;
continue;
}
var6 = false;
}
++var8;
break;
}
}
}
if (!var6)
{
byte[] var19 = new byte[4096];
NibbleArray var20 = new NibbleArray(var19.length, 4);
NibbleArray var21 = new NibbleArray(var19.length, 4);
NibbleArray var22 = new NibbleArray(var19.length, 4);
for (int var23 = 0; var23 < 16; ++var23)
{
for (int var12 = 0; var12 < 16; ++var12)
{
for (int var13 = 0; var13 < 16; ++var13)
{
int var14 = var23 << 11 | var13 << 7 | var12 + (var5 << 4);
byte var15 = par0AnvilConverterData.blocks[var14];
var19[var12 << 8 | var13 << 4 | var23] = (byte)(var15 & 255);
var20.set(var23, var12, var13, par0AnvilConverterData.data.get(var23, var12 + (var5 << 4), var13));
var21.set(var23, var12, var13, par0AnvilConverterData.skyLight.get(var23, var12 + (var5 << 4), var13));
var22.set(var23, var12, var13, par0AnvilConverterData.blockLight.get(var23, var12 + (var5 << 4), var13));
}
}
}
NBTTagCompound var24 = new NBTTagCompound();
var24.setByte("Y", (byte)(var5 & 255));
var24.setByteArray("Blocks", var19);
var24.setByteArray("Data", var20.data);
var24.setByteArray("SkyLight", var21.data);
var24.setByteArray("BlockLight", var22.data);
var16.appendTag(var24);
}
}
par1NBTTagCompound.setTag("Sections", var16);
byte[] var17 = new byte[256];
for (int var18 = 0; var18 < 16; ++var18)
{
for (var7 = 0; var7 < 16; ++var7)
{
var17[var7 << 4 | var18] = (byte)(par2WorldChunkManager.getBiomeGenAt(par0AnvilConverterData.x << 4 | var18, par0AnvilConverterData.z << 4 | var7).biomeID & 255);
}
}
par1NBTTagCompound.setByteArray("Biomes", var17);
par1NBTTagCompound.setTag("Entities", par0AnvilConverterData.entities);
par1NBTTagCompound.setTag("TileEntities", par0AnvilConverterData.tileEntities);
if (par0AnvilConverterData.tileTicks != null)
{
par1NBTTagCompound.setTag("TileTicks", par0AnvilConverterData.tileTicks);
}
}
}

2
src/main/java/net/minecraft/src/GLAllocation.java
View File

@@ -86,4 +86,4 @@ public class GLAllocation {
public static FloatBuffer createDirectFloatBuffer(int par0) {
return EaglerAdapter.isWebGL ? FloatBuffer.wrap(new float[par0]) : createDirectByteBuffer(par0 << 2).asFloatBuffer();
}
}
}

6
src/main/java/net/minecraft/src/GuiSelectWorld.java
View File

@@ -66,7 +66,7 @@ public class GuiSelectWorld extends GuiScreen
{
this.loadSaves();
}
catch (AnvilConverterException var2)
catch (Exception var2)
{
var2.printStackTrace();
this.mc.displayGuiScreen(new GuiErrorScreen("Unable to load words", var2.getMessage()));
@@ -86,7 +86,7 @@ public class GuiSelectWorld extends GuiScreen
/**
* loads the saves
*/
private void loadSaves() throws AnvilConverterException
private void loadSaves() throws Exception
{
ISaveFormat var1 = this.mc.getSaveLoader();
this.saveList = var1.getSaveList();
@@ -232,7 +232,7 @@ public class GuiSelectWorld extends GuiScreen
{
this.loadSaves();
}
catch (AnvilConverterException var5)
catch (Exception var5)
{
var5.printStackTrace();
}

2
src/main/java/net/minecraft/src/ISaveFormat.java
View File

@@ -9,7 +9,7 @@ public interface ISaveFormat
*/
ISaveHandler getSaveLoader(String var1, boolean var2);
List getSaveList() throws AnvilConverterException;
List getSaveList() throws Exception;
void flushCache();

175
src/main/java/net/minecraft/src/Render.java
View File

@@ -39,50 +39,57 @@ public abstract class Render
par1TextureLocation.bindTexture();
}
private static final TextureLocation terrain = new TextureLocation("/terrain.png");
/**
* Renders fire on top of the entity. Args: entity, x, y, z, partialTickTime
*/
private void renderEntityOnFire(Entity par1Entity, double par2, double par4, double par6, float par8)
{
private void renderEntityOnFire(Entity par1Entity, double par2, double par4, double par6, float par8) {
EaglerAdapter.glDisable(EaglerAdapter.GL_LIGHTING);
Icon var9 = Block.fire.getFireIcon(0);
Icon var10 = Block.fire.getFireIcon(1);
EaglerAdapter.glPushMatrix();
EaglerAdapter.glTranslatef((float)par2, (float)par4, (float)par6);
EaglerAdapter.glTranslatef((float) par2, (float) par4, (float) par6);
float var11 = par1Entity.width * 1.4F;
EaglerAdapter.glScalef(var11, var11, var11);
terrain.bindTexture();
EaglerAdapter.glTexParameteri(EaglerAdapter.GL_TEXTURE_2D, EaglerAdapter.GL_TEXTURE_MIN_FILTER, EaglerAdapter.GL_NEAREST);
EaglerAdapter.glTexParameteri(EaglerAdapter.GL_TEXTURE_2D, EaglerAdapter.GL_TEXTURE_MAG_FILTER, EaglerAdapter.GL_NEAREST);
Tessellator var12 = Tessellator.instance;
float var13 = 0.5F;
float var14 = 0.0F;
float var15 = par1Entity.height / var11;
float var16 = (float)(par1Entity.posY - par1Entity.boundingBox.minY);
float var16 = (float) (par1Entity.posY - par1Entity.boundingBox.minY);
EaglerAdapter.glRotatef(-this.renderManager.playerViewY, 0.0F, 1.0F, 0.0F);
EaglerAdapter.glTranslatef(0.0F, 0.0F, -0.3F + (float)((int)var15) * 0.02F);
EaglerAdapter.glTranslatef(0.0F, 0.0F, -0.3F + (float) ((int) var15) * 0.02F);
EaglerAdapter.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
float var17 = 0.0F;
int var18 = 0;
var12.startDrawingQuads();
while (var15 > 0.0F)
{
Icon var19 = var18 % 2 == 0 ? var9 : var10;
this.bindTexture(TextureMap.locationBlocksTexture);
while (var15 > 0.0F) {
Icon var19;
if (var18 % 2 == 0) {
var19 = var9;
} else {
var19 = var10;
}
float var20 = var19.getMinU();
float var21 = var19.getMinV();
float var22 = var19.getMaxU();
float var23 = var19.getMaxV();
if (var18 / 2 % 2 == 0)
{
if (var18 / 2 % 2 == 0) {
float var24 = var22;
var22 = var20;
var20 = var24;
}
var12.addVertexWithUV((double)(var13 - var14), (double)(0.0F - var16), (double)var17, (double)var22, (double)var23);
var12.addVertexWithUV((double)(-var13 - var14), (double)(0.0F - var16), (double)var17, (double)var20, (double)var23);
var12.addVertexWithUV((double)(-var13 - var14), (double)(1.4F - var16), (double)var17, (double)var20, (double)var21);
var12.addVertexWithUV((double)(var13 - var14), (double)(1.4F - var16), (double)var17, (double)var22, (double)var21);
var12.addVertexWithUV((double) (var13 - var14), (double) (0.0F - var16), (double) var17, (double) var22, (double) var23);
var12.addVertexWithUV((double) (-var13 - var14), (double) (0.0F - var16), (double) var17, (double) var20, (double) var23);
var12.addVertexWithUV((double) (-var13 - var14), (double) (1.4F - var16), (double) var17, (double) var20, (double) var21);
var12.addVertexWithUV((double) (var13 - var14), (double) (1.4F - var16), (double) var17, (double) var22, (double) var21);
var15 -= 0.45F;
var16 -= 0.45F;
var13 *= 0.9F;
@@ -95,56 +102,54 @@ public abstract class Render
EaglerAdapter.glEnable(EaglerAdapter.GL_LIGHTING);
}
private static final TextureLocation shadow = new TextureLocation("%clamp%/misc/shadow.png");
/**
* Renders the entity shadows at the position, shadow alpha and partialTickTime. Args: entity, x, y, z, shadowAlpha,
* partialTickTime
* Renders the entity shadows at the position, shadow alpha and partialTickTime.
* Args: entity, x, y, z, shadowAlpha, partialTickTime
*/
private void renderShadow(Entity par1Entity, double par2, double par4, double par6, float par8, float par9)
{
private void renderShadow(Entity par1Entity, double par2, double par4, double par6, float par8, float par9) {
EaglerAdapter.glEnable(EaglerAdapter.GL_BLEND);
EaglerAdapter.glDisable(EaglerAdapter.GL_ALPHA_TEST);
EaglerAdapter.glBlendFunc(EaglerAdapter.GL_SRC_ALPHA, EaglerAdapter.GL_ONE_MINUS_SRC_ALPHA);
shadowTextures.bindTexture();
shadow.bindTexture();
EaglerAdapter.glTexParameteri(EaglerAdapter.GL_TEXTURE_2D, EaglerAdapter.GL_TEXTURE_WRAP_S, EaglerAdapter.GL_CLAMP);
EaglerAdapter.glTexParameteri(EaglerAdapter.GL_TEXTURE_2D, EaglerAdapter.GL_TEXTURE_WRAP_T, EaglerAdapter.GL_CLAMP);
World var10 = this.getWorldFromRenderManager();
EaglerAdapter.glDepthMask(false);
float var11 = this.shadowSize;
if (par1Entity instanceof EntityLiving)
{
EntityLiving var12 = (EntityLiving)par1Entity;
if (par1Entity instanceof EntityLiving) {
EntityLiving var12 = (EntityLiving) par1Entity;
var11 *= var12.getRenderSizeModifier();
if (var12.isChild())
{
if (var12.isChild()) {
var11 *= 0.5F;
}
}
double var35 = par1Entity.lastTickPosX + (par1Entity.posX - par1Entity.lastTickPosX) * (double)par9;
double var14 = par1Entity.lastTickPosY + (par1Entity.posY - par1Entity.lastTickPosY) * (double)par9 + (double)par1Entity.getShadowSize();
double var16 = par1Entity.lastTickPosZ + (par1Entity.posZ - par1Entity.lastTickPosZ) * (double)par9;
int var18 = MathHelper.floor_double(var35 - (double)var11);
int var19 = MathHelper.floor_double(var35 + (double)var11);
int var20 = MathHelper.floor_double(var14 - (double)var11);
double var35 = par1Entity.lastTickPosX + (par1Entity.posX - par1Entity.lastTickPosX) * (double) par9;
double var14 = par1Entity.lastTickPosY + (par1Entity.posY - par1Entity.lastTickPosY) * (double) par9 + (double) par1Entity.getShadowSize();
double var16 = par1Entity.lastTickPosZ + (par1Entity.posZ - par1Entity.lastTickPosZ) * (double) par9;
int var18 = MathHelper.floor_double(var35 - (double) var11);
int var19 = MathHelper.floor_double(var35 + (double) var11);
int var20 = MathHelper.floor_double(var14 - (double) var11);
int var21 = MathHelper.floor_double(var14);
int var22 = MathHelper.floor_double(var16 - (double)var11);
int var23 = MathHelper.floor_double(var16 + (double)var11);
int var22 = MathHelper.floor_double(var16 - (double) var11);
int var23 = MathHelper.floor_double(var16 + (double) var11);
double var24 = par2 - var35;
double var26 = par4 - var14;
double var28 = par6 - var16;
Tessellator var30 = Tessellator.instance;
var30.startDrawingQuads();
for (int var31 = var18; var31 <= var19; ++var31)
{
for (int var32 = var20; var32 <= var21; ++var32)
{
for (int var33 = var22; var33 <= var23; ++var33)
{
for (int var31 = var18; var31 <= var19; ++var31) {
for (int var32 = var20; var32 <= var21; ++var32) {
for (int var33 = var22; var33 <= var23; ++var33) {
int var34 = var10.getBlockId(var31, var32 - 1, var33);
if (var34 > 0 && var10.getBlockLightValue(var31, var32, var33) > 3)
{
this.renderShadowOnBlock(Block.blocksList[var34], par2, par4 + (double)par1Entity.getShadowSize(), par6, var31, var32, var33, par8, var11, var24, var26 + (double)par1Entity.getShadowSize(), var28);
if (var34 > 0 && var10.getBlockLightValue(var31, var32, var33) > 3) {
this.renderShadowOnBlock(Block.blocksList[var34], par2, par4 + (double) par1Entity.getShadowSize(), par6, var31, var32, var33, par8, var11, var24, var26 + (double) par1Entity.getShadowSize(), var28);
}
}
}
@@ -153,60 +158,57 @@ public abstract class Render
var30.draw();
EaglerAdapter.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
EaglerAdapter.glDisable(EaglerAdapter.GL_BLEND);
EaglerAdapter.glEnable(EaglerAdapter.GL_ALPHA_TEST);
EaglerAdapter.glDepthMask(true);
}
/**
* Returns the render manager's world object
*/
private World getWorldFromRenderManager()
{
private World getWorldFromRenderManager() {
return this.renderManager.worldObj;
}
/**
* Renders a shadow projected down onto the specified block. Brightness of the block plus how far away on the Y axis
* determines the alpha of the shadow. Args: block, centerX, centerY, centerZ, blockX, blockY, blockZ, baseAlpha,
* Renders a shadow projected down onto the specified block. Brightness of the
* block plus how far away on the Y axis determines the alpha of the shadow.
* Args: block, centerX, centerY, centerZ, blockX, blockY, blockZ, baseAlpha,
* shadowSize, xOffset, yOffset, zOffset
*/
private void renderShadowOnBlock(Block par1Block, double par2, double par4, double par6, int par8, int par9, int par10, float par11, float par12, double par13, double par15, double par17)
{
private void renderShadowOnBlock(Block par1Block, double par2, double par4, double par6, int par8, int par9, int par10, float par11, float par12, double par13, double par15, double par17) {
Tessellator var19 = Tessellator.instance;
if (par1Block.renderAsNormalBlock())
{
double var20 = ((double)par11 - (par4 - ((double)par9 + par15)) / 2.0D) * 0.5D * (double)this.getWorldFromRenderManager().getLightBrightness(par8, par9, par10);
if (par1Block.renderAsNormalBlock()) {
double var20 = ((double) par11 - (par4 - ((double) par9 + par15)) / 2.0D) * 0.5D * (double) this.getWorldFromRenderManager().getLightBrightness(par8, par9, par10);
if (var20 >= 0.0D)
{
if (var20 > 1.0D)
{
if (var20 >= 0.0D) {
if (var20 > 1.0D) {
var20 = 1.0D;
}
var19.setColorRGBA_F(1.0F, 1.0F, 1.0F, (float)var20);
double var22 = (double)par8 + par1Block.getBlockBoundsMinX() + par13;
double var24 = (double)par8 + par1Block.getBlockBoundsMaxX() + par13;
double var26 = (double)par9 + par1Block.getBlockBoundsMinY() + par15 + 0.015625D;
double var28 = (double)par10 + par1Block.getBlockBoundsMinZ() + par17;
double var30 = (double)par10 + par1Block.getBlockBoundsMaxZ() + par17;
float var32 = (float)((par2 - var22) / 2.0D / (double)par12 + 0.5D);
float var33 = (float)((par2 - var24) / 2.0D / (double)par12 + 0.5D);
float var34 = (float)((par6 - var28) / 2.0D / (double)par12 + 0.5D);
float var35 = (float)((par6 - var30) / 2.0D / (double)par12 + 0.5D);
var19.addVertexWithUV(var22, var26, var28, (double)var32, (double)var34);
var19.addVertexWithUV(var22, var26, var30, (double)var32, (double)var35);
var19.addVertexWithUV(var24, var26, var30, (double)var33, (double)var35);
var19.addVertexWithUV(var24, var26, var28, (double)var33, (double)var34);
var19.setColorRGBA_F(1.0F, 1.0F, 1.0F, (float) var20);
double var22 = (double) par8 + par1Block.getBlockBoundsMinX() + par13;
double var24 = (double) par8 + par1Block.getBlockBoundsMaxX() + par13;
double var26 = (double) par9 + par1Block.getBlockBoundsMinY() + par15 + 0.015625D;
double var28 = (double) par10 + par1Block.getBlockBoundsMinZ() + par17;
double var30 = (double) par10 + par1Block.getBlockBoundsMaxZ() + par17;
float var32 = (float) ((par2 - var22) / 2.0D / (double) par12 + 0.5D);
float var33 = (float) ((par2 - var24) / 2.0D / (double) par12 + 0.5D);
float var34 = (float) ((par6 - var28) / 2.0D / (double) par12 + 0.5D);
float var35 = (float) ((par6 - var30) / 2.0D / (double) par12 + 0.5D);
var19.addVertexWithUV(var22, var26, var28, (double) var32, (double) var34);
var19.addVertexWithUV(var22, var26, var30, (double) var32, (double) var35);
var19.addVertexWithUV(var24, var26, var30, (double) var33, (double) var35);
var19.addVertexWithUV(var24, var26, var28, (double) var33, (double) var34);
}
}
}
/**
* Renders a white box with the bounds of the AABB translated by the offset. Args: aabb, x, y, z
* Renders a white box with the bounds of the AABB translated by the offset.
* Args: aabb, x, y, z
*/
public static void renderOffsetAABB(AxisAlignedBB par0AxisAlignedBB, double par1, double par3, double par5)
{
public static void renderOffsetAABB(AxisAlignedBB par0AxisAlignedBB, double par1, double par3, double par5) {
EaglerAdapter.glDisable(EaglerAdapter.GL_TEXTURE_2D);
Tessellator var7 = Tessellator.instance;
EaglerAdapter.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
@@ -250,8 +252,7 @@ public abstract class Render
/**
* Adds to the tesselator a box using the aabb for the bounds. Args: aabb
*/
public static void renderAABB(AxisAlignedBB par0AxisAlignedBB)
{
public static void renderAABB(AxisAlignedBB par0AxisAlignedBB) {
Tessellator var1 = Tessellator.instance;
var1.startDrawingQuads();
var1.addVertex(par0AxisAlignedBB.minX, par0AxisAlignedBB.maxY, par0AxisAlignedBB.minZ);
@@ -284,29 +285,25 @@ public abstract class Render
/**
* Sets the RenderManager.
*/
public void setRenderManager(RenderManager par1RenderManager)
{
public void setRenderManager(RenderManager par1RenderManager) {
this.renderManager = par1RenderManager;
}
/**
* Renders the entity's shadow and fire (if its on fire). Args: entity, x, y, z, yaw, partialTickTime
* Renders the entity's shadow and fire (if its on fire). Args: entity, x, y, z,
* yaw, partialTickTime
*/
public void doRenderShadowAndFire(Entity par1Entity, double par2, double par4, double par6, float par8, float par9)
{
if (this.renderManager.options.fancyGraphics && this.shadowSize > 0.0F && !par1Entity.isInvisible())
{
public void doRenderShadowAndFire(Entity par1Entity, double par2, double par4, double par6, float par8, float par9) {
if (this.renderManager.options.fancyGraphics && this.shadowSize > 0.0F && !par1Entity.isInvisible()) {
double var10 = this.renderManager.getDistanceToCamera(par1Entity.posX, par1Entity.posY, par1Entity.posZ);
float var12 = (float)((1.0D - var10 / 256.0D) * (double)this.shadowOpaque);
float var12 = (float) ((1.0D - var10 / 256.0D) * (double) this.shadowOpaque);
if (var12 > 0.0F)
{
if (var12 > 0.0F) {
this.renderShadow(par1Entity, par2, par4, par6, var12, par9);
}
}
if (par1Entity.canRenderOnFire())
{
if (par1Entity.canRenderOnFire()) {
this.renderEntityOnFire(par1Entity, par2, par4, par6, par9);
}
}
@@ -314,10 +311,10 @@ public abstract class Render
/**
* Returns the font renderer from the set render manager
*/
public FontRenderer getFontRendererFromRenderManager()
{
public FontRenderer getFontRendererFromRenderManager() {
return this.renderManager.getFontRenderer();
}
public void updateIcons(IconRegister par1IconRegister) {}
public void updateIcons(IconRegister par1IconRegister) {
}
}

1
src/main/java/net/minecraft/src/RenderEngine.java
View File

@@ -10,7 +10,6 @@ import net.lax1dude.eaglercraft.EaglerAdapter;
import net.lax1dude.eaglercraft.EaglerImage;
import net.lax1dude.eaglercraft.TextureLocation;
import net.lax1dude.eaglercraft.TextureTerrainMap;
import net.minecraft.src.Minecraft;
public class RenderEngine {
private HashMap textureMap = new HashMap();

2
src/main/java/net/minecraft/src/SaveFormatOld.java
View File

@@ -23,7 +23,7 @@ public class SaveFormatOld implements ISaveFormat
this.savesDirectory = par1File;
}
public List getSaveList() throws AnvilConverterException
public List getSaveList() throws Exception
{
ArrayList var1 = new ArrayList();

1
src/main/java/net/minecraft/src/TextureManager.java
View File

@@ -6,7 +6,6 @@ import java.util.List;
import net.lax1dude.eaglercraft.EaglerAdapter;
import net.lax1dude.eaglercraft.EaglerImage;
import net.minecraft.src.Minecraft;
public class TextureManager {
private static TextureManager instance;

9
src/main/java/net/minecraft/src/TextureMap.java
View File

@@ -10,7 +10,6 @@ import java.util.Map;
import net.lax1dude.eaglercraft.EaglerAdapter;
import net.lax1dude.eaglercraft.EaglerImage;
import net.lax1dude.eaglercraft.TextureLocation;
import net.minecraft.src.Minecraft;
public class TextureMap implements IconRegister {
public static final TextureLocation locationBlocksTexture = new TextureLocation("textures/atlas/blocks.png");
@@ -129,7 +128,7 @@ public class TextureMap implements IconRegister {
String var13 = this.basePath + var29 + ".txt";
ITexturePack var14 = Minecraft.getMinecraft().texturePackList.getSelectedTexturePack();
boolean var15 = !var14.func_98138_b("/" + this.basePath + var29 + ".png", false);
if(var14.func_98138_b("/" + var13, false)) {
System.out.println("Found animation info for: " + var13);
var11.readAnimationInfo("/" + var13);
@@ -170,14 +169,14 @@ public class TextureMap implements IconRegister {
if (par1Str == null) {
(new RuntimeException("Don\'t register null!")).printStackTrace();
}
TextureStitched var2 = (TextureStitched) this.textureStichedMap.get(par1Str);
if (var2 == null) {
var2 = TextureStitched.makeTextureStitched(par1Str);
this.textureStichedMap.put(par1Str, var2);
}
return var2;
}
}