Java AnvilChunkLoader类代码示例

import net.minecraft.world.chunk.storage.AnvilChunkLoader; //导入依赖的package包/类
public static void queueChunkLoad(World world, AnvilChunkLoader loader, ChunkProviderServer provider, int x, int z, Runnable runnable)
{
    QueuedChunk key = new QueuedChunk(x, z, world);
    ChunkIOProvider task = tasks.get(key);
    if (task == null)
    {
        task = new ChunkIOProvider(key, loader, provider);
        task.addCallback(runnable); // Add before calling execute for thread safety
        tasks.put(key, task);
        pool.execute(task);
    }
    else
    {
        task.addCallback(runnable);
    }
}
 

import net.minecraft.world.chunk.storage.AnvilChunkLoader; //导入依赖的package包/类
public Chunk callStage1(QueuedChunk queuedChunk) throws RuntimeException {
	AnvilChunkLoader loader = queuedChunk.loader;
	Object[] data = null;
	try {
		data = loader.loadChunk__Async(queuedChunk.world, queuedChunk.x, queuedChunk.z);
	} catch (IOException e) {
		e.printStackTrace();
	}

	if (data != null) {
		queuedChunk.compound = (net.minecraft.nbt.NBTTagCompound) data[1];
		return (net.minecraft.world.chunk.Chunk) data[0];
	}

	return null;
}
 

import net.minecraft.world.chunk.storage.AnvilChunkLoader; //导入依赖的package包/类
public File getSaveFile(ISaveHandler saveHandler, World world, String name, boolean backup) {
	File worldDir = new File(saveHandler.getWorldDirectoryName());
	IChunkLoader loader = saveHandler.getChunkLoader(world.provider);
	if((loader instanceof AnvilChunkLoader)) {
		worldDir = ((AnvilChunkLoader) loader).chunkSaveLocation;
	}
	File file = new File(worldDir, name + (backup ? ".bak" : ""));
	if(!file.exists()) {
		try {
			file.createNewFile();
		} catch(Exception e) {
			e.printStackTrace();
		}
	}
	return file;
}
 

import net.minecraft.world.chunk.storage.AnvilChunkLoader; //导入依赖的package包/类
public Entity getCachedEntity()
{
    if (this.cachedEntity == null)
    {
        this.cachedEntity = AnvilChunkLoader.readWorldEntity(this.randomEntity.getNbt(), this.getSpawnerWorld(), false);

        if (this.randomEntity.getNbt().getSize() == 1 && this.randomEntity.getNbt().hasKey("id", 8) && this.cachedEntity instanceof EntityLiving)
        {
            ((EntityLiving)this.cachedEntity).onInitialSpawn(this.getSpawnerWorld().getDifficultyForLocation(new BlockPos(this.cachedEntity)), (IEntityLivingData)null);
        }
    }

    return this.cachedEntity;
}
 

import net.minecraft.world.chunk.storage.AnvilChunkLoader; //导入依赖的package包/类
public static Chunk syncChunkLoad(World world, AnvilChunkLoader loader, ChunkProviderServer provider, int x, int z)
{
    QueuedChunk key = new QueuedChunk(x, z, world);
    ChunkIOProvider task = tasks.remove(key); // Remove task because we will call the sync callbacks directly
    if (task != null)
    {
        if (!pool.remove(task)) // If it wasn't in the pool, and run hasn't finished, then wait for the async thread.
        {
            synchronized(task)
            {
                while (!task.runFinished())
                {
                    try
                    {
                        task.wait();
                    }
                    catch (InterruptedException e)
                    {
                        e.printStackTrace(); // Something happened? Log it?
                    }
                }
            }
        }
        else
        {
            // If the task was not run yet we still need to load the chunk
            task.run();
        }
    }
    else
    {
        task = new ChunkIOProvider(key, loader, provider);
        task.run();
    }
    task.syncCallback();
    return task.getChunk();
}
 

import net.minecraft.world.chunk.storage.AnvilChunkLoader; //导入依赖的package包/类
@SideOnly(Side.CLIENT)
public Entity getCachedEntity()
{
    if (this.cachedEntity == null)
    {
        this.cachedEntity = AnvilChunkLoader.readWorldEntity(this.randomEntity.getNbt(), this.getSpawnerWorld(), false);

        if (this.randomEntity.getNbt().getSize() == 1 && this.randomEntity.getNbt().hasKey("id", 8) && this.cachedEntity instanceof EntityLiving)
        {
            ((EntityLiving)this.cachedEntity).onInitialSpawn(this.getSpawnerWorld().getDifficultyForLocation(new BlockPos(this.cachedEntity)), (IEntityLivingData)null);
        }
    }

    return this.cachedEntity;
}
 

import net.minecraft.world.chunk.storage.AnvilChunkLoader; //导入依赖的package包/类
@Nullable
public static File getWorldDirectory(World world)
{
    IChunkProvider chunkProvider = world.getChunkProvider();

    if (chunkProvider instanceof ChunkProviderServer)
    {
        ChunkProviderServer chunkProviderServer = (ChunkProviderServer) chunkProvider;
        IChunkLoader chunkLoader = chunkProviderServer.chunkLoader;

        if (chunkLoader instanceof AnvilChunkLoader)
        {
            return ((AnvilChunkLoader) chunkLoader).chunkSaveLocation;
        }

        return null;
    }
    // If this method gets called before ChunkProviderServer has been set yet,
    // then we mimic the vanilla code in AnvilSaveHandler#getChunkLoader() to get the directory.
    else
    {
        File mainWorldDir = world.getSaveHandler().getWorldDirectory();
        String dimensionDir = world.provider.getSaveFolder();

        if (dimensionDir != null)
        {
            mainWorldDir = new File(mainWorldDir, dimensionDir);
            mainWorldDir.mkdirs();
        }

        return mainWorldDir;
    }
}
 

import net.minecraft.world.chunk.storage.AnvilChunkLoader; //导入依赖的package包/类
public QueuedChunk(int x, int z, AnvilChunkLoader loader, World world, ChunkProviderServer provider) {
    this.x = x;
    this.z = z;
    this.loader = loader;
    this.world = world;
    this.provider = provider;
}
 

import net.minecraft.world.chunk.storage.AnvilChunkLoader; //导入依赖的package包/类
/**
 * @author jamierocks - 30th October 2016
 * @reason Use the Canary directory structure
 */
@Overwrite
public IChunkLoader getChunkLoader(WorldProvider provider) {
    if (provider instanceof WorldProviderHell) {
        return new AnvilChunkLoader(new File(this.getWorldDirectory(), this.getWorldDirectoryName() + "_" + DimensionType.NETHER.getName()));
    } else if (provider instanceof WorldProviderEnd) {
        return new AnvilChunkLoader(new File(this.getWorldDirectory(), this.getWorldDirectoryName() + "_" + DimensionType.END.getName()));
    } else {
        return new AnvilChunkLoader(new File(this.getWorldDirectory(), this.getWorldDirectoryName() + "_" + DimensionType.NORMAL.getName()));
    }
}
 

import net.minecraft.world.chunk.storage.AnvilChunkLoader; //导入依赖的package包/类
/** Load the previously saved TileEntities and add them to the Chunk **/
public static void importTileEntities( Chunk chunk )
{
	File chunkSaveLocation = (File) Reflexion.stealField( AnvilChunkLoader.class, File.class ).get(chunkLoader);
	DataInputStream dis = RegionFileCache.getChunkInputStream( chunkSaveLocation, chunk.xPosition, chunk.zPosition );
	try
	{
		NBTTagCompound chunkNBT = CompressedStreamTools.read( dis );
		NBTTagCompound levelNBT = chunkNBT.getCompoundTag( "Level" );
		// The official code checks if the chunk is in the right location. Should I too?.
		NBTTagList tileEntitiesNBT = levelNBT.getTagList( "TileEntities" );
		for( int i = 0; i < tileEntitiesNBT.tagCount(); i++ )
		{
			NBTTagCompound tileEntityNBT = (NBTTagCompound) tileEntitiesNBT.tagAt( i );
			TileEntity te = TileEntity.createAndLoadEntity( tileEntityNBT );
			String entityType = getTEName(te);
			if(( isImportableTileEntity( te ) ))
			{
			  if( ! newTileEntities.contains( new ChunkPosition( te.xCoord, te.yCoord, te.zCoord ) ) )
			  {
			  	wc.setBlockTileEntity( te.xCoord, te.yCoord, te.zCoord, te );
			  	chatDebug("Loaded TE: " + entityType + " at " + te.xCoord + " " + te.yCoord + " " + te.zCoord );
			  }
			  else
				{
			  	chatDebug( "Dropping old TE: " + entityType + " at " + te.xCoord + " " + te.yCoord + " " + te.zCoord );
				}
			}
			else 
			{
				chatDebug( "TE is not importable: " + entityType + " at " + te.xCoord + " " + te.yCoord + " " + te.zCoord );
			}
		}
	}
	catch ( Exception e ) { } // Couldn't load the old chunk. Nothing unusual. Happens with every not downloaded chunk.
}
 

import net.minecraft.world.chunk.storage.AnvilChunkLoader; //导入依赖的package包/类
public IChunkLoader func_75763_a(WorldProvider p_75763_1_) {
   File var2 = this.func_75765_b();
   File var3;
   if(p_75763_1_ instanceof WorldProviderHell) {
      var3 = new File(var2, "DIM-1");
      var3.mkdirs();
      return new AnvilChunkLoader(var3);
   } else if(p_75763_1_ instanceof WorldProviderEnd) {
      var3 = new File(var2, "DIM1");
      var3.mkdirs();
      return new AnvilChunkLoader(var3);
   } else {
      return new AnvilChunkLoader(var2);
   }
}
 

import net.minecraft.world.chunk.storage.AnvilChunkLoader; //导入依赖的package包/类
protected static File getWorldSaveDir(World world) {
	ISaveHandler worldSaver = world.getSaveHandler();
	if (worldSaver.getChunkLoader(world.provider) instanceof AnvilChunkLoader) {
		return ((AnvilChunkLoader) worldSaver.getChunkLoader(world.provider)).chunkSaveLocation;
	}
	return null;
}
 

import net.minecraft.world.chunk.storage.AnvilChunkLoader; //导入依赖的package包/类
private static boolean chunkIsSaved(World world, int chunkX, int chunkZ) {
	if (world.getChunkProvider() instanceof ChunkProviderServer) {
		IChunkLoader loader = ((ChunkProviderServer)world.getChunkProvider()).chunkLoader;
		if (loader instanceof AnvilChunkLoader) {
			//if (((AnvilChunkLoader) loader).chunkExists(world, chunkX, chunkZ))
			//	CustomOreGenBase.log.info("[" + chunkX + "," + chunkZ + "]: saved on disk");
			return ((AnvilChunkLoader) loader).chunkExists(world, chunkX, chunkZ);
		}
	}
	return false;
}
 

import net.minecraft.world.chunk.storage.AnvilChunkLoader; //导入依赖的package包/类
ChunkIOProvider(QueuedChunk chunk, AnvilChunkLoader loader, ChunkProviderServer provider)
{
    this.chunkInfo = chunk;
    this.loader = loader;
    this.provider = provider;
}
 

import net.minecraft.world.chunk.storage.AnvilChunkLoader; //导入依赖的package包/类
public static DataFixer createFixer()
{
    DataFixer datafixer = new DataFixer(512);
    WorldInfo.registerFixes(datafixer);
    EntityPlayer.registerFixesPlayer(datafixer);
    AnvilChunkLoader.registerFixes(datafixer);
    ItemStack.registerFixes(datafixer);
    EntityArmorStand.registerFixesArmorStand(datafixer);
    EntityArrow.registerFixesArrow(datafixer);
    EntityBat.registerFixesBat(datafixer);
    EntityBlaze.registerFixesBlaze(datafixer);
    EntityCaveSpider.registerFixesCaveSpider(datafixer);
    EntityChicken.registerFixesChicken(datafixer);
    EntityCow.registerFixesCow(datafixer);
    EntityCreeper.registerFixesCreeper(datafixer);
    EntityDragonFireball.registerFixesDragonFireball(datafixer);
    EntityDragon.registerFixesDragon(datafixer);
    EntityEnderman.registerFixesEnderman(datafixer);
    EntityEndermite.registerFixesEndermite(datafixer);
    EntityFallingBlock.registerFixesFallingBlock(datafixer);
    EntityLargeFireball.registerFixesLargeFireball(datafixer);
    EntityFireworkRocket.registerFixesFireworkRocket(datafixer);
    EntityGhast.registerFixesGhast(datafixer);
    EntityGiantZombie.registerFixesGiantZombie(datafixer);
    EntityGuardian.registerFixesGuardian(datafixer);
    EntityHorse.registerFixesHorse(datafixer);
    EntityItem.registerFixesItem(datafixer);
    EntityItemFrame.registerFixesItemFrame(datafixer);
    EntityMagmaCube.registerFixesMagmaCube(datafixer);
    EntityMinecartChest.registerFixesMinecartChest(datafixer);
    EntityMinecartCommandBlock.registerFixesMinecartCommand(datafixer);
    EntityMinecartFurnace.registerFixesMinecartFurnace(datafixer);
    EntityMinecartHopper.registerFixesMinecartHopper(datafixer);
    EntityMinecartEmpty.registerFixesMinecartEmpty(datafixer);
    EntityMinecartMobSpawner.registerFixesMinecartMobSpawner(datafixer);
    EntityMinecartTNT.registerFixesMinecartTNT(datafixer);
    EntityLiving.registerFixesMob(datafixer);
    EntityMob.registerFixesMonster(datafixer);
    EntityMooshroom.registerFixesMooshroom(datafixer);
    EntityOcelot.registerFixesOcelot(datafixer);
    EntityPig.registerFixesPig(datafixer);
    EntityPigZombie.registerFixesPigZombie(datafixer);
    EntityRabbit.registerFixesRabbit(datafixer);
    EntitySheep.registerFixesSheep(datafixer);
    EntityShulker.registerFixesShulker(datafixer);
    EntitySilverfish.registerFixesSilverfish(datafixer);
    EntitySkeleton.registerFixesSkeleton(datafixer);
    EntitySlime.registerFixesSlime(datafixer);
    EntitySmallFireball.registerFixesSmallFireball(datafixer);
    EntitySnowman.registerFixesSnowman(datafixer);
    EntitySnowball.registerFixesSnowball(datafixer);
    EntitySpectralArrow.registerFixesSpectralArrow(datafixer);
    EntitySpider.registerFixesSpider(datafixer);
    EntitySquid.registerFixesSquid(datafixer);
    EntityEgg.registerFixesEgg(datafixer);
    EntityEnderPearl.registerFixesEnderPearl(datafixer);
    EntityExpBottle.registerFixesExpBottle(datafixer);
    EntityPotion.registerFixesPotion(datafixer);
    EntityTippedArrow.registerFixesTippedArrow(datafixer);
    EntityVillager.registerFixesVillager(datafixer);
    EntityIronGolem.registerFixesIronGolem(datafixer);
    EntityWitch.registerFixesWitch(datafixer);
    EntityWither.registerFixesWither(datafixer);
    EntityWitherSkull.registerFixesWitherSkull(datafixer);
    EntityWolf.registerFixesWolf(datafixer);
    EntityZombie.registerFixesZombie(datafixer);
    TileEntityPiston.registerFixesPiston(datafixer);
    TileEntityFlowerPot.registerFixesFlowerPot(datafixer);
    TileEntityFurnace.registerFixesFurnace(datafixer);
    TileEntityChest.registerFixesChest(datafixer);
    TileEntityDispenser.registerFixes(datafixer);
    TileEntityDropper.registerFixesDropper(datafixer);
    TileEntityBrewingStand.registerFixesBrewingStand(datafixer);
    TileEntityHopper.registerFixesHopper(datafixer);
    BlockJukebox.registerFixesJukebox(datafixer);
    TileEntityMobSpawner.registerFixesMobSpawner(datafixer);
    registerFixes(datafixer);
    return datafixer;
}