Java ChunkProviderServer类代码示例

import net.minecraft.world.gen.ChunkProviderServer; //导入依赖的package包/类
private static void logLoadOnRequest(ChunkProviderServer provider, int x, int z)
{
    long currentTick = MinecraftServer.getServer().getTickCounter();
    long lastAccessed = provider.lastAccessed(x, z);
    long diff = currentTick - lastAccessed;
    logInfo(" Last accessed: {0, number} Current Tick: {1, number} [{2, number}]", lastAccessed, currentTick, diff);
    logInfo(" Finding Spawn Point: {0}", provider.worldObj.findingSpawnPoint);
    logInfo(" Load chunk on request: {0}", provider.loadChunkOnProvideRequest);
    logInfo(" Calling Forge Tick: {0}", MinecraftServer.callingForgeTick);
    logInfo(" Load chunk on forge tick: {0}", MinecraftServer.cauldronConfig.loadChunkOnForgeTick.getValue());
    long providerTickDiff = currentTick - provider.initialTick;
    if (providerTickDiff <= 100)
    {
        logInfo(" Current Tick - Initial Tick: {0, number}", providerTickDiff);
    }
}
 

import net.minecraft.world.gen.ChunkProviderServer; //导入依赖的package包/类
public boolean unloadChunk(ItemStack stack) {
	if (!stack.hasTagCompound()) return false;
	NBTTagCompound tag = stack.getTagCompound();
	if (tag.getBoolean("ignoreClick")) {
		tag.removeTag("ignoreClick");
		stack.setTagCompound(tag);
		return false;
	}
	
	int worldId = tag.getInteger("world");
	int x = tag.getInteger("x");
	int z = tag.getInteger("z");
	World world = DimensionManager.getWorld(worldId);
	if (world==null) return false;
	
	IChunkProvider provider = world.getChunkProvider();
	Chunk chunk = provider.getLoadedChunk(x, z);
	if (chunk==null) return false;
	if (provider instanceof ChunkProviderServer) {
		((ChunkProviderServer) provider).queueUnload(chunk);
		return true;
	} else {
		return false;
	}
}
 

import net.minecraft.world.gen.ChunkProviderServer; //导入依赖的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.gen.ChunkProviderServer; //导入依赖的package包/类
@Override
public void invalidate()
{
    super.invalidate();
    if (this.reference != null)
    {
        ChunkProviderServer provider = this.reference.getChunkProvider();
        int sX = this.getStart().getX() / 16 - GEN_RANGE;
        int sZ = this.getStart().getZ() / 16 - GEN_RANGE;
        int eX = this.getEnd().getX() / 16 + GEN_RANGE;
        int eZ = this.getEnd().getZ() / 16 + GEN_RANGE;
        for (int x = sX; x <= eX; x++)
            for (int z = sZ; z <= eZ; z++)
                if (provider.chunkExists(x, z))
                    provider.unload(provider.getLoadedChunk(x, z));
    }
}
 

import net.minecraft.world.gen.ChunkProviderServer; //导入依赖的package包/类
public void loadChunks()
{
    if (this.worldObj.isRemote)
        return;

    this.reference = DimensionManager.getWorld(VoidUtils.DIM);
    if (this.reference == null)
    {
        DimensionManager.initDimension(VoidUtils.DIM);
        this.reference = DimensionManager.getWorld(VoidUtils.DIM);
    }

    //We need to load the chunk, and the chunks around it before we start copying, so that the chunk gets decorated.
    ChunkProviderServer provider = this.reference.getChunkProvider();
    int sX = this.getStart().getX() / 16 - GEN_RANGE;
    int sZ = this.getStart().getZ() / 16 - GEN_RANGE;
    int eX = this.getEnd().getX() / 16 + GEN_RANGE;
    int eZ = this.getEnd().getZ() / 16 + GEN_RANGE;
    for (int x = sX; x <= eX; x++)
        for (int z = sZ; z <= eZ; z++)
            provider.loadChunk(x, z);
}
 

import net.minecraft.world.gen.ChunkProviderServer; //导入依赖的package包/类
private void loadChunksAround(int x, int z, int i, ChunkProviderServer cp)
{
    cp.loadChunk(x >> 4, z >> 4);
    if ((x + i) >> 4 != x >> 4)
    {
        cp.loadChunk((x + i) >> 4, z >> 4);
        if ((z + i) >> 4 != z >> 4)
        {
            cp.loadChunk(x >> 4, (z + i) >> 4);
            cp.loadChunk((x + i) >> 4, (z + i) >> 4);
        }
    }
    else if ((z + i) >> 4 != z >> 4)
    {
        cp.loadChunk(x >> 4, (z + i) >> 4);
    }
}
 

import net.minecraft.world.gen.ChunkProviderServer; //导入依赖的package包/类
public boolean providePlayerChunk(boolean canGenerate) {
    if (!this.loading) {
        if (this.providingChunk != null) {
            return true;
        } else {
            ChunkProviderServer chunkProvider = this.blockSystem.getChunkProvider();
            int x = this.chunkPosition.chunkXPos;
            int z = this.chunkPosition.chunkZPos;
            if (canGenerate) {
                this.providingChunk = (BlockSystemChunk) chunkProvider.provideChunk(x, z);
            } else {
                this.providingChunk = (BlockSystemChunk) chunkProvider.loadChunk(x, z);
            }
        }
    }
    return false;
}
 

import net.minecraft.world.gen.ChunkProviderServer; //导入依赖的package包/类
private void nucleusLoadChunkForce(int x, int z) {
    Chunk chunk = this.loadChunkFromFile(x, z);

    if (chunk == null)
    {
        long i = ChunkPos.chunkXZ2Int(x, z);

        try
        {
            chunk = this.chunkGenerator.provideChunk(x, z);
        }
        catch (Throwable throwable)
        {
            CrashReport crashreport = CrashReport.makeCrashReport(throwable, "Exception generating new chunk");
            CrashReportCategory crashreportcategory = crashreport.makeCategory("Chunk to be generated");
            crashreportcategory.addCrashSection("Location", String.format("%d,%d", new Object[] {Integer.valueOf(x), Integer.valueOf(z)}));
            crashreportcategory.addCrashSection("Position hash", Long.valueOf(i));
            crashreportcategory.addCrashSection("Generator", this.chunkGenerator);
            throw new ReportedException(crashreport);
        }
    }

    this.id2ChunkMap.put(ChunkPos.chunkXZ2Int(x, z), chunk);
    chunk.onChunkLoad();
    chunk.populateChunk((ChunkProviderServer)(Object) this, this.chunkGenerator);
}
 

import net.minecraft.world.gen.ChunkProviderServer; //导入依赖的package包/类
private static void saveChunkData(ChunkProviderServer chunkProviderServer, Chunk chunkIn)
{
    try
    {
        chunkIn.setLastSaveTime(chunkIn.getWorld().getTotalWorldTime());
        chunkProviderServer.chunkLoader.saveChunk(chunkIn.getWorld(), chunkIn);
    }
    catch (IOException ioexception)
    {
        //LOGGER.error((String)"Couldn\'t save chunk", (Throwable)ioexception);
    }
    catch (MinecraftException minecraftexception)
    {
        //LOGGER.error((String)"Couldn\'t save chunk; already in use by another instance of Minecraft?", (Throwable)minecraftexception);
    }
    try
    {
        chunkProviderServer.chunkLoader.saveExtraChunkData(chunkIn.getWorld(), chunkIn);
    }
    catch (Exception exception)
    {
        //LOGGER.error((String)"Couldn\'t save entities", (Throwable)exception);
    }
}
 

import net.minecraft.world.gen.ChunkProviderServer; //导入依赖的package包/类
@Override
public void populate(IChunkProvider chunkprovider, int chunkX, int chunkZ) {
	checkUnpopulatedQueue(chunkprovider);
	
	if (chunkprovider instanceof ChunkProviderServer) {
		// Don't populate if not all direct neighbours have been populated
		// Instead put on queue
		if(!shouldPopulate((ChunkProviderServer)chunkprovider, chunkX, chunkZ)) {
			synchronized (VCraftWorld.instance.unpopulatedChunks) {
				VCraftWorld.instance.unpopulatedChunks.add(new BlockPos(chunkX, 0, chunkZ));	
			}
			
			VCraftWorld.instance.setChunkNBT(chunkX, chunkZ, "vcraftpopulated", false);	
			return;
		}

		populateNow(chunkprovider, chunkX, chunkZ);
	}
}
 

import net.minecraft.world.gen.ChunkProviderServer; //导入依赖的package包/类
@Override
public Coord findNearestStructure(VanillaStructure type, Coord pos) {
	
	ChunkProviderServer chunkProvider = ((WorldServer)world).getChunkProvider();
	String structureName = VanillaStructure.getName(type);
	
	BlockPos structurebp = null;
	
	try{
		structurebp = chunkProvider.getNearestStructurePos(world, structureName, pos.getBlockPos(), false);	
	} catch(NullPointerException e){
		// happens for some reason if structure type is disabled in Chunk Generator Settings
	}
	
	if(structurebp == null) return null;
	
	return new Coord(structurebp);		
}
 

import net.minecraft.world.gen.ChunkProviderServer; //导入依赖的package包/类
public static void logChunkLoad(ChunkProviderServer provider, String msg, int x, int z, boolean logLoadOnRequest)
{
    if (MinecraftServer.cauldronConfig.chunkLoadLogging.getValue())
    {
        logInfo("{0} Chunk At [{1}] ({2}, {3})", msg, provider.worldObj.provider.dimensionId, x, z);
        if (logLoadOnRequest)
        {
            logLoadOnRequest(provider, x, z);
        }
        logStack();
    }
}
 

import net.minecraft.world.gen.ChunkProviderServer; //导入依赖的package包/类
public static void logChunkUnload(ChunkProviderServer provider, int x, int z, String msg)
{
    if (MinecraftServer.cauldronConfig.chunkUnloadLogging.getValue())
    {
        logInfo("{0} [{1}] ({2}, {3})", msg, provider.worldObj.provider.dimensionId, x, z);
        long currentTick = MinecraftServer.getServer().getTickCounter();
        long lastAccessed = provider.lastAccessed(x, z);
        long diff = currentTick - lastAccessed;
        logInfo(" Last accessed: {0, number} Current Tick: {1, number} [{2, number}]", lastAccessed, currentTick, diff);
    }
}
 

import net.minecraft.world.gen.ChunkProviderServer; //导入依赖的package包/类
/**
 * Creates the chunk provider for this world. Called in the constructor. Retrieves provider from worldProvider?
 */
protected IChunkProvider createChunkProvider()
{
    IChunkLoader ichunkloader = this.saveHandler.getChunkLoader(this.provider);
    this.theChunkProviderServer = new ChunkProviderServer(this, ichunkloader, this.provider.createChunkGenerator());
    return this.theChunkProviderServer;
}
 

import net.minecraft.world.gen.ChunkProviderServer; //导入依赖的package包/类
@Override
public ChunkProviderServer getChunkProvider() {
	if (m_proxyWorld != null && Util.isPrefixInCallStack(m_modPrefix)) {
		return m_proxyWorld.getChunkProvider();
	} else if (m_realWorld != null) {
		return m_realWorld.getChunkProvider();
	} else {
		return super.getChunkProvider();
	}
}