Package net.minecraft.server.level

Class ChunkMap

java.lang.Object

net.minecraft.world.level.chunk.storage.ChunkStorage

net.minecraft.server.level.ChunkMap

All Implemented Interfaces:

AutoCloseable, ChunkHolder.PlayerProvider, GeneratingChunkMap

public class ChunkMap
extends ChunkStorage
implements ChunkHolder.PlayerProvider, GeneratingChunkMap

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
(package private) class	ChunkMap.DistanceManager
(package private) class	ChunkMap.TrackedEntity

Field Summary

Fields

Modifier and Type	Field	Description
private final AtomicInteger	activeChunkWrites
private static final int	CHUNK_SAVED_EAGERLY_PER_TICK
private static final int	CHUNK_SAVED_PER_TICK
private static final byte	CHUNK_TYPE_FULL
private static final byte	CHUNK_TYPE_REPLACEABLE
private static final byte	CHUNK_TYPE_UNKNOWN
private final ChunkGeneratorStructureState	chunkGeneratorState
private final ChunkStatusUpdateListener	chunkStatusListener
private final it.unimi.dsi.fastutil.longs.LongSet	chunksToEagerlySave
private final it.unimi.dsi.fastutil.longs.Long2ByteMap	chunkTypeCache
private final ChunkMap.DistanceManager	distanceManager
private static final int	EAGER_CHUNK_SAVE_COOLDOWN_IN_MILLIS
private final it.unimi.dsi.fastutil.ints.Int2ObjectMap<ChunkMap.TrackedEntity>	entityMap
static final int	FORCED_TICKET_LEVEL
(package private) final ServerLevel	level
private final ThreadedLevelLightEngine	lightEngine
private final ChunkTaskDispatcher	lightTaskDispatcher
private static final org.slf4j.Logger	LOGGER
private final BlockableEventLoop<Runnable>	mainThreadExecutor
private static final int	MAX_ACTIVE_CHUNK_WRITES
static final int	MAX_VIEW_DISTANCE
static final int	MIN_VIEW_DISTANCE
private boolean	modified	True if changes have been made to invalid reference #loadedChunks and thus a new copy of the collection has to be made into invalid reference #immutableLoadedChunks .
private final it.unimi.dsi.fastutil.longs.Long2LongMap	nextChunkSaveTime
private final Supplier<DimensionDataStorage>	overworldDataStorage
private final List<ChunkGenerationTask>	pendingGenerationTasks
private final it.unimi.dsi.fastutil.longs.Long2ObjectLinkedOpenHashMap<ChunkHolder>	pendingUnloads
private final PlayerMap	playerMap
private final PoiManager	poiManager
private final RandomState	randomState
private int	serverViewDistance
private final String	storageName
private final TicketStorage	ticketStorage
(package private) final it.unimi.dsi.fastutil.longs.LongSet	toDrop	Chunks that have been requested to be unloaded, but haven't been unloaded yet.
private static final CompletableFuture<ChunkResult<List<ChunkAccess>>>	UNLOADED_CHUNK_LIST_FUTURE
private static final ChunkResult<List<ChunkAccess>>	UNLOADED_CHUNK_LIST_RESULT
private final Queue<Runnable>	unloadQueue
private final it.unimi.dsi.fastutil.longs.Long2ObjectLinkedOpenHashMap<ChunkHolder>	updatingChunkMap	Chunks in memory.
private it.unimi.dsi.fastutil.longs.Long2ObjectLinkedOpenHashMap<ChunkHolder>	visibleChunkMap	Same as invalid reference #loadedChunks , but immutable for access from other threads.
private final WorldGenContext	worldGenContext
private final ChunkTaskDispatcher	worldgenTaskDispatcher

Fields inherited from class net.minecraft.world.level.chunk.storage.ChunkStorage

fixerUpper, LAST_MONOLYTH_STRUCTURE_DATA_VERSION

Constructor Summary

Constructors

Constructor

Description

ChunkMap(ServerLevel pLevel, LevelStorageSource.LevelStorageAccess pStorageSource, com.mojang.datafixers.DataFixer pFixerUpper, StructureTemplateManager pStructureManager, Executor pDispatcher, BlockableEventLoop<Runnable> pMainThreadExecutor, LightChunkGetter pLightChunk, ChunkGenerator pGenerator, ChunkStatusUpdateListener pChunkStatusListener, Supplier<DimensionDataStorage> pOverworldDataStorage, TicketStorage pTicketStorage, int pServerViewDistance, boolean pSync)

Method Summary

Modifier and Type	Method	Description
GenerationChunkHolder	acquireGeneration(long p_347661_)
protected void	addEntity(Entity pEntity)
(package private) Stream<ChunkHolder>	allChunksWithAtLeastStatus(ChunkStatus pStatus)
(package private) boolean	anyPlayerCloseEnoughForSpawning(ChunkPos pChunkPos)
private boolean	anyPlayerCloseEnoughForSpawningInternal(ChunkPos pChunkPos)
private void	applyChunkTrackingView(ServerPlayer pPlayer, ChunkTrackingView pChunkTrackingView)
CompletableFuture<ChunkAccess>	applyStep(GenerationChunkHolder p_347627_, ChunkStep p_347638_, StaticCache2D<GenerationChunkHolder> p_347552_)
void	close()
(package private) void	collectForceTickingChunks(List<LevelChunk> list)
(package private) void	collectSpawningChunks(List<LevelChunk> pOutput)
private ChunkAccess	createEmptyChunk(ChunkPos pChunkPos)
ReportedException	debugFuturesAndCreateReportedException(IllegalStateException pException, String pDetails)
private static void	dropChunk(ServerPlayer pPlayer, ChunkPos pChunkPos)
(package private) void	dumpChunks(Writer pWriter)
private static double	euclideanDistanceSquared(ChunkPos pChunkPos, Vec3 pPos)
(package private) void	forEachBlockTickingChunk(Consumer<LevelChunk> pAction)
void	forEachEntityTrackedBy(ServerPlayer pPlayer, Consumer<Entity> pAction)
void	forEachReadyToSendChunk(Consumer<LevelChunk> pAction)
protected ChunkGenerator	generator()
protected ChunkGeneratorStructureState	generatorState()
String	getChunkDebugData(ChunkPos pPos)
protected IntSupplier	getChunkQueueLevel(long pChunkPos)
(package private) CompletableFuture<ChunkResult<List<ChunkAccess>>>	getChunkRangeFuture(ChunkHolder pChunkHolder, int pRange, IntFunction<ChunkStatus> pStatusGetter)
LevelChunk	getChunkToSend(long pChunkPos)
DistanceManager	getDistanceManager()
ChunkStatus	getLatestStatus(long pChunkPos)
protected ThreadedLevelLightEngine	getLightEngine()
List<ServerPlayer>	getPlayers(ChunkPos p_183801_, boolean p_183802_)	Returns the players tracking the given chunk.
List<ServerPlayer>	getPlayersCloseForSpawning(ChunkPos pChunkPos)
List<ServerPlayer>	getPlayersWatching(Entity entity)
(package private) int	getPlayerViewDistance(ServerPlayer pPlayer)
protected PoiManager	getPoiManager()
String	getStorageName()
ChunkHolder	getUpdatingChunkIfPresent(long pChunkPos)
ChunkHolder	getVisibleChunkIfPresent(long pChunkPos)
private ChunkAccess	handleChunkLoadFailure(Throwable pException, ChunkPos pChunkPos)
boolean	hasWork()
private boolean	isChunkOnTrackedBorder(ServerPlayer pPlayer, int pX, int pZ)	Checks if a chunk is on the edge of the player's view distance.
boolean	isChunkTracked(ServerPlayer pPlayer, int pX, int pZ)	Checks if a chunk is within a player's view distance.
private boolean	isExistingChunkFull(ChunkPos pChunkPos)
boolean	isTrackedByAnyPlayer(Entity pEntity)
private static void	markChunkPendingToSend(ServerPlayer pPlayer, LevelChunk pChunk)
private void	markChunkPendingToSend(ServerPlayer pPlayer, ChunkPos pChunkPos)
private byte	markPosition(ChunkPos pChunkPos, ChunkType pChunkType)
private void	markPositionReplaceable(ChunkPos pChunkPos)
void	move(ServerPlayer pPlayer)
private void	onChunkReadyToSend(ChunkHolder pChunkHolder, LevelChunk pChunk)
(package private) void	onFullChunkStatusChange(ChunkPos pChunkPos, FullChunkStatus pFullChunkStatus)
private void	onLevelChange(ChunkPos pChunkPos, IntSupplier pQueueLevelGetter, int pTicketLevel, IntConsumer pQueueLevelSetter)
private boolean	playerIsCloseEnoughForSpawning(ServerPlayer pPlayer, ChunkPos pChunkPos)
CompletableFuture<ChunkResult<LevelChunk>>	prepareAccessibleChunk(ChunkHolder pChunk)
CompletableFuture<ChunkResult<LevelChunk>>	prepareEntityTickingChunk(ChunkHolder pChunk)
CompletableFuture<ChunkResult<LevelChunk>>	prepareTickingChunk(ChunkHolder pHolder)
private static String	printFuture(CompletableFuture<ChunkResult<LevelChunk>> pFuture)
private void	processUnloads(BooleanSupplier pHasMoreTime)
protected boolean	promoteChunkMap()
protected RandomState	randomState()
private CompletableFuture<Optional<CompoundTag>>	readChunk(ChunkPos pPos)
void	releaseGeneration(GenerationChunkHolder p_347698_)
protected void	removeEntity(Entity pEntity)
void	resendBiomesForChunks(List<ChunkAccess> pChunks)
private void	runGenerationTask(ChunkGenerationTask pTask)
void	runGenerationTasks()
private boolean	save(ChunkAccess pChunk)
protected void	saveAllChunks(boolean pFlush)
private boolean	saveChunkIfNeeded(ChunkHolder pChunk, long pGametime)
private void	saveChunksEagerly(BooleanSupplier pHasMoreTime)
private CompletableFuture<ChunkAccess>	scheduleChunkLoad(ChunkPos pChunkPos)
ChunkGenerationTask	scheduleGenerationTask(ChunkStatus p_347605_, ChunkPos p_347675_)
void	scheduleOnMainThreadMailbox(Runnable runnable)	Neo: PR #937 This is for mainly pre-generation usage such as Neoforge's generate command.
private void	scheduleUnload(long pChunkPos, ChunkHolder pChunkHolder)
void	sendToTrackingPlayers(Entity pEntity, Packet<? super ClientGamePacketListener> pPacket)
protected void	sendToTrackingPlayersAndSelf(Entity pEntity, Packet<? super ClientGamePacketListener> pPacket)
void	sendToTrackingPlayersFiltered(Entity pEntity, Packet<? super ClientGamePacketListener> pPacket, Predicate<ServerPlayer> pFilter)
private void	setChunkUnsaved(ChunkPos pChunkPos)
protected void	setServerViewDistance(int pViewDistance)
int	size()
private boolean	skipPlayer(ServerPlayer pPlayer)
protected void	tick()
protected void	tick(BooleanSupplier pHasMoreTime)
(package private) ChunkHolder	updateChunkScheduling(long pChunkPos, int pNewLevel, ChunkHolder pHolder, int pOldLevel)	Sets level and loads/unloads chunk.
private void	updateChunkTracking(ServerPlayer pPlayer)
private void	updatePlayerPos(ServerPlayer pPlayer)
(package private) void	updatePlayerStatus(ServerPlayer pPlayer, boolean pTrack)
private CompoundTag	upgradeChunkTag(CompoundTag pTag)
void	waitForLightBeforeSending(ChunkPos pChunkPos, int pRange)

Methods inherited from class net.minecraft.world.level.chunk.storage.ChunkStorage

chunkScanner, flushWorker, getVersion, handleLegacyStructureIndex, injectDatafixingContext, isOldChunkAround, read, storageInfo, upgradeChunkTag, write

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Details

UNLOADED_CHUNK_LIST_RESULT

private static final ChunkResult<List<ChunkAccess>> UNLOADED_CHUNK_LIST_RESULT

UNLOADED_CHUNK_LIST_FUTURE

private static final CompletableFuture<ChunkResult<List<ChunkAccess>>> UNLOADED_CHUNK_LIST_FUTURE

CHUNK_TYPE_REPLACEABLE

private static final byte CHUNK_TYPE_REPLACEABLE

See Also:

• Constant Field Values

CHUNK_TYPE_UNKNOWN

private static final byte CHUNK_TYPE_UNKNOWN

See Also:

• Constant Field Values

CHUNK_TYPE_FULL

private static final byte CHUNK_TYPE_FULL

See Also:

• Constant Field Values

LOGGER

private static final org.slf4j.Logger LOGGER

CHUNK_SAVED_PER_TICK

private static final int CHUNK_SAVED_PER_TICK

See Also:

• Constant Field Values

CHUNK_SAVED_EAGERLY_PER_TICK

private static final int CHUNK_SAVED_EAGERLY_PER_TICK

See Also:

• Constant Field Values

EAGER_CHUNK_SAVE_COOLDOWN_IN_MILLIS

private static final int EAGER_CHUNK_SAVE_COOLDOWN_IN_MILLIS

See Also:

• Constant Field Values

MAX_ACTIVE_CHUNK_WRITES

private static final int MAX_ACTIVE_CHUNK_WRITES

See Also:

• Constant Field Values

MIN_VIEW_DISTANCE

public static final int MIN_VIEW_DISTANCE

See Also:

• Constant Field Values

MAX_VIEW_DISTANCE

public static final int MAX_VIEW_DISTANCE

See Also:

• Constant Field Values

FORCED_TICKET_LEVEL

public static final int FORCED_TICKET_LEVEL

updatingChunkMap

private final it.unimi.dsi.fastutil.longs.Long2ObjectLinkedOpenHashMap<ChunkHolder> updatingChunkMap

Chunks in memory. This should only ever be manipulated by the main thread.

visibleChunkMap

private volatile it.unimi.dsi.fastutil.longs.Long2ObjectLinkedOpenHashMap<ChunkHolder> visibleChunkMap

Same as

invalid reference

#loadedChunks

, but immutable for access from other threads. This should never be mutated.

pendingUnloads

private final it.unimi.dsi.fastutil.longs.Long2ObjectLinkedOpenHashMap<ChunkHolder> pendingUnloads

pendingGenerationTasks

private final List<ChunkGenerationTask> pendingGenerationTasks

level

final ServerLevel level

lightEngine

private final ThreadedLevelLightEngine lightEngine

mainThreadExecutor

private final BlockableEventLoop<Runnable> mainThreadExecutor

randomState

private final RandomState randomState

chunkGeneratorState

private final ChunkGeneratorStructureState chunkGeneratorState

overworldDataStorage

private final Supplier<DimensionDataStorage> overworldDataStorage

ticketStorage

private final TicketStorage ticketStorage

poiManager

private final PoiManager poiManager

toDrop

final it.unimi.dsi.fastutil.longs.LongSet toDrop

Chunks that have been requested to be unloaded, but haven't been unloaded yet.

modified

private boolean modified

True if changes have been made to

invalid reference

#loadedChunks

and thus a new copy of the collection has to be made into

invalid reference

#immutableLoadedChunks

.

worldgenTaskDispatcher

private final ChunkTaskDispatcher worldgenTaskDispatcher

lightTaskDispatcher

private final ChunkTaskDispatcher lightTaskDispatcher

chunkStatusListener

private final ChunkStatusUpdateListener chunkStatusListener

distanceManager

private final ChunkMap.DistanceManager distanceManager

storageName

private final String storageName

playerMap

private final PlayerMap playerMap

entityMap

private final it.unimi.dsi.fastutil.ints.Int2ObjectMap<ChunkMap.TrackedEntity> entityMap

chunkTypeCache

private final it.unimi.dsi.fastutil.longs.Long2ByteMap chunkTypeCache

nextChunkSaveTime

private final it.unimi.dsi.fastutil.longs.Long2LongMap nextChunkSaveTime

chunksToEagerlySave

private final it.unimi.dsi.fastutil.longs.LongSet chunksToEagerlySave

unloadQueue

private final Queue<Runnable> unloadQueue

activeChunkWrites

private final AtomicInteger activeChunkWrites

serverViewDistance

private int serverViewDistance

worldGenContext

private final WorldGenContext worldGenContext

Constructor Details

ChunkMap

public ChunkMap(ServerLevel pLevel,
 LevelStorageSource.LevelStorageAccess pStorageSource,
 com.mojang.datafixers.DataFixer pFixerUpper,
 StructureTemplateManager pStructureManager,
 Executor pDispatcher,
 BlockableEventLoop<Runnable> pMainThreadExecutor,
 LightChunkGetter pLightChunk,
 ChunkGenerator pGenerator,
 ChunkStatusUpdateListener pChunkStatusListener,
 Supplier<DimensionDataStorage> pOverworldDataStorage,
 TicketStorage pTicketStorage,
 int pServerViewDistance,
 boolean pSync)

Method Details

setChunkUnsaved

private void setChunkUnsaved(ChunkPos pChunkPos)

generator

protected ChunkGenerator generator()

generatorState

protected ChunkGeneratorStructureState generatorState()

randomState

protected RandomState randomState()

isChunkTracked

public boolean isChunkTracked(ServerPlayer pPlayer,
 int pX,
 int pZ)

Checks if a chunk is within a player's view distance.

isChunkOnTrackedBorder

private boolean isChunkOnTrackedBorder(ServerPlayer pPlayer,
 int pX,
 int pZ)

Checks if a chunk is on the edge of the player's view distance.

getLightEngine

protected ThreadedLevelLightEngine getLightEngine()

getUpdatingChunkIfPresent

@Nullable
public ChunkHolder getUpdatingChunkIfPresent(long pChunkPos)

getVisibleChunkIfPresent

@Nullable
public ChunkHolder getVisibleChunkIfPresent(long pChunkPos)

getLatestStatus

@Nullable
public ChunkStatus getLatestStatus(long pChunkPos)

getChunkQueueLevel

protected IntSupplier getChunkQueueLevel(long pChunkPos)

getChunkDebugData

public String getChunkDebugData(ChunkPos pPos)

getChunkRangeFuture

CompletableFuture<ChunkResult<List<ChunkAccess>>> getChunkRangeFuture(ChunkHolder pChunkHolder,
 int pRange,
 IntFunction<ChunkStatus> pStatusGetter)

debugFuturesAndCreateReportedException

public ReportedException debugFuturesAndCreateReportedException(IllegalStateException pException,
 String pDetails)

prepareEntityTickingChunk

public CompletableFuture<ChunkResult<LevelChunk>> prepareEntityTickingChunk(ChunkHolder pChunk)

updateChunkScheduling

@Nullable
ChunkHolder updateChunkScheduling(long pChunkPos,
 int pNewLevel,
 @Nullable
 ChunkHolder pHolder,
 int pOldLevel)

Sets level and loads/unloads chunk.

Parameters:

pHolder - The ChunkHolder of the chunk if it is loaded, and null otherwise.

onLevelChange

private void onLevelChange(ChunkPos pChunkPos,
 IntSupplier pQueueLevelGetter,
 int pTicketLevel,
 IntConsumer pQueueLevelSetter)

close

public void close()
           throws IOException

Specified by:

close in interface AutoCloseable

Overrides:

close in class ChunkStorage

Throws:

IOException

saveAllChunks

protected void saveAllChunks(boolean pFlush)

tick

protected void tick(BooleanSupplier pHasMoreTime)

hasWork

public boolean hasWork()

processUnloads

private void processUnloads(BooleanSupplier pHasMoreTime)

saveChunksEagerly

private void saveChunksEagerly(BooleanSupplier pHasMoreTime)

scheduleUnload

private void scheduleUnload(long pChunkPos,
 ChunkHolder pChunkHolder)

promoteChunkMap

protected boolean promoteChunkMap()

scheduleChunkLoad

private CompletableFuture<ChunkAccess> scheduleChunkLoad(ChunkPos pChunkPos)

handleChunkLoadFailure

private ChunkAccess handleChunkLoadFailure(Throwable pException,
 ChunkPos pChunkPos)

createEmptyChunk

private ChunkAccess createEmptyChunk(ChunkPos pChunkPos)

markPositionReplaceable

private void markPositionReplaceable(ChunkPos pChunkPos)

markPosition

private byte markPosition(ChunkPos pChunkPos,
 ChunkType pChunkType)

acquireGeneration

public GenerationChunkHolder acquireGeneration(long p_347661_)

Specified by:

acquireGeneration in interface GeneratingChunkMap

releaseGeneration

public void releaseGeneration(GenerationChunkHolder p_347698_)

Specified by:

releaseGeneration in interface GeneratingChunkMap

applyStep

public CompletableFuture<ChunkAccess> applyStep(GenerationChunkHolder p_347627_,
 ChunkStep p_347638_,
 StaticCache2D<GenerationChunkHolder> p_347552_)

Specified by:

applyStep in interface GeneratingChunkMap

scheduleGenerationTask

public ChunkGenerationTask scheduleGenerationTask(ChunkStatus p_347605_,
 ChunkPos p_347675_)

Specified by:

scheduleGenerationTask in interface GeneratingChunkMap

runGenerationTask

private void runGenerationTask(ChunkGenerationTask pTask)

runGenerationTasks

public void runGenerationTasks()

Specified by:

runGenerationTasks in interface GeneratingChunkMap

prepareTickingChunk

public CompletableFuture<ChunkResult<LevelChunk>> prepareTickingChunk(ChunkHolder pHolder)

onChunkReadyToSend

private void onChunkReadyToSend(ChunkHolder pChunkHolder,
 LevelChunk pChunk)

prepareAccessibleChunk

public CompletableFuture<ChunkResult<LevelChunk>> prepareAccessibleChunk(ChunkHolder pChunk)

allChunksWithAtLeastStatus

Stream<ChunkHolder> allChunksWithAtLeastStatus(ChunkStatus pStatus)

saveChunkIfNeeded

private boolean saveChunkIfNeeded(ChunkHolder pChunk,
 long pGametime)

save

private boolean save(ChunkAccess pChunk)

isExistingChunkFull

private boolean isExistingChunkFull(ChunkPos pChunkPos)

setServerViewDistance

protected void setServerViewDistance(int pViewDistance)

getPlayerViewDistance

int getPlayerViewDistance(ServerPlayer pPlayer)

markChunkPendingToSend

private void markChunkPendingToSend(ServerPlayer pPlayer,
 ChunkPos pChunkPos)

markChunkPendingToSend

private static void markChunkPendingToSend(ServerPlayer pPlayer,
 LevelChunk pChunk)

dropChunk

private static void dropChunk(ServerPlayer pPlayer,
 ChunkPos pChunkPos)

getChunkToSend

@Nullable
public LevelChunk getChunkToSend(long pChunkPos)

size

public int size()

getDistanceManager

public DistanceManager getDistanceManager()

dumpChunks

void dumpChunks(Writer pWriter)
         throws IOException

Throws:

IOException

printFuture

private static String printFuture(CompletableFuture<ChunkResult<LevelChunk>> pFuture)

readChunk

private CompletableFuture<Optional<CompoundTag>> readChunk(ChunkPos pPos)

upgradeChunkTag

private CompoundTag upgradeChunkTag(CompoundTag pTag)

collectSpawningChunks

void collectSpawningChunks(List<LevelChunk> pOutput)

forEachBlockTickingChunk

void forEachBlockTickingChunk(Consumer<LevelChunk> pAction)

anyPlayerCloseEnoughForSpawning

boolean anyPlayerCloseEnoughForSpawning(ChunkPos pChunkPos)

collectForceTickingChunks

void collectForceTickingChunks(List<LevelChunk> list)

anyPlayerCloseEnoughForSpawningInternal

private boolean anyPlayerCloseEnoughForSpawningInternal(ChunkPos pChunkPos)

getPlayersCloseForSpawning

public List<ServerPlayer> getPlayersCloseForSpawning(ChunkPos pChunkPos)

playerIsCloseEnoughForSpawning

private boolean playerIsCloseEnoughForSpawning(ServerPlayer pPlayer,
 ChunkPos pChunkPos)

euclideanDistanceSquared

private static double euclideanDistanceSquared(ChunkPos pChunkPos,
 Vec3 pPos)

skipPlayer

private boolean skipPlayer(ServerPlayer pPlayer)

updatePlayerStatus

void updatePlayerStatus(ServerPlayer pPlayer,
 boolean pTrack)

updatePlayerPos

private void updatePlayerPos(ServerPlayer pPlayer)

move

public void move(ServerPlayer pPlayer)

updateChunkTracking

private void updateChunkTracking(ServerPlayer pPlayer)

applyChunkTrackingView

private void applyChunkTrackingView(ServerPlayer pPlayer,
 ChunkTrackingView pChunkTrackingView)

getPlayers

public List<ServerPlayer> getPlayers(ChunkPos p_183801_,
 boolean p_183802_)

Description copied from interface: ChunkHolder.PlayerProvider

Returns the players tracking the given chunk.

Specified by:

getPlayers in interface ChunkHolder.PlayerProvider

addEntity

protected void addEntity(Entity pEntity)

removeEntity

protected void removeEntity(Entity pEntity)

tick

protected void tick()

sendToTrackingPlayers

public void sendToTrackingPlayers(Entity pEntity,
 Packet<? super ClientGamePacketListener> pPacket)

sendToTrackingPlayersFiltered

public void sendToTrackingPlayersFiltered(Entity pEntity,
 Packet<? super ClientGamePacketListener> pPacket,
 Predicate<ServerPlayer> pFilter)

sendToTrackingPlayersAndSelf

protected void sendToTrackingPlayersAndSelf(Entity pEntity,
 Packet<? super ClientGamePacketListener> pPacket)

isTrackedByAnyPlayer

public boolean isTrackedByAnyPlayer(Entity pEntity)

forEachEntityTrackedBy

public void forEachEntityTrackedBy(ServerPlayer pPlayer,
 Consumer<Entity> pAction)

resendBiomesForChunks

public void resendBiomesForChunks(List<ChunkAccess> pChunks)

getPoiManager

protected PoiManager getPoiManager()

getStorageName

public String getStorageName()

onFullChunkStatusChange

void onFullChunkStatusChange(ChunkPos pChunkPos,
 FullChunkStatus pFullChunkStatus)

waitForLightBeforeSending

public void waitForLightBeforeSending(ChunkPos pChunkPos,
 int pRange)

forEachReadyToSendChunk

public void forEachReadyToSendChunk(Consumer<LevelChunk> pAction)

getPlayersWatching

public List<ServerPlayer> getPlayersWatching(Entity entity)

scheduleOnMainThreadMailbox

public void scheduleOnMainThreadMailbox(Runnable runnable)

Neo: PR #937 This is for mainly pre-generation usage such as Neoforge's generate command. Use this to schedule chunk load tasks into ChunkTaskPriorityQueueSorter so a chunk is fully finished all of their tasks before scheduling more chunks to load. Reason for this is when scheduling a huge ton of Full Status chunk tasks to the server (to load chunks), you could cause the server to only process those loading tasks and never reach the two chunk tasks that are automatically scheduled to run after the chunk is loaded to Full. As a result of flooding the system with Full Status chunk tasks, the queue for the two kind of successor chunk tasks will grow and become a memory leak of lambdas and chunk references. Use this method to schedule tasks for loading chunks in your whenCompleteAsync method call so the tasks gets processed properly over time and not leak. See GenerationTask.enqueueChunks(it.unimi.dsi.fastutil.longs.LongList) as an example usage of this method.