152 private static int $worldIdCounter = 1;
154 public const Y_MAX = 320;
155 public const Y_MIN = -64;
157 public const TIME_DAY = 1000;
158 public const TIME_NOON = 6000;
159 public const TIME_SUNSET = 12000;
160 public const TIME_NIGHT = 13000;
161 public const TIME_MIDNIGHT = 18000;
162 public const TIME_SUNRISE = 23000;
164 public const TIME_FULL = 24000;
166 public const DIFFICULTY_PEACEFUL = 0;
167 public const DIFFICULTY_EASY = 1;
168 public const DIFFICULTY_NORMAL = 2;
169 public const DIFFICULTY_HARD = 3;
171 public const DEFAULT_TICKED_BLOCKS_PER_SUBCHUNK_PER_TICK = 3;
174 private const BLOCK_CACHE_SIZE_CAP = 2048;
180 private array $players = [];
186 private array $entities = [];
191 private array $entityLastKnownPositions = [];
197 private array $entitiesByChunk = [];
203 public array $updateEntities = [];
205 private bool $inDynamicStateRecalculation =
false;
210 private array $blockCache = [];
211 private int $blockCacheSize = 0;
216 private array $blockCollisionBoxCache = [];
218 private int $sendTimeTicker = 0;
220 private int $worldId;
222 private int $providerGarbageCollectionTicker = 0;
231 private array $registeredTickingChunks = [];
239 private array $validTickingChunks = [];
246 private array $recheckTickingChunks = [];
252 private array $chunkLoaders = [];
258 private array $chunkListeners = [];
263 private array $playerChunkListeners = [];
269 private array $packetBuffersByChunk = [];
275 private array $unloadQueue = [];
278 public bool $stopTime =
false;
280 private float $sunAnglePercentage = 0.0;
281 private int $skyLightReduction = 0;
283 private string $folderName;
284 private string $displayName;
290 private array $chunks = [];
296 private array $knownUngeneratedChunks = [];
302 private array $changedBlocks = [];
310 private array $scheduledBlockUpdateQueueIndex = [];
313 private \SplQueue $neighbourBlockUpdateQueue;
318 private array $neighbourBlockUpdateQueueIndex = [];
324 private array $activeChunkPopulationTasks = [];
329 private array $chunkLock = [];
330 private int $maxConcurrentChunkPopulationTasks = 2;
335 private array $chunkPopulationRequestMap = [];
340 private \SplQueue $chunkPopulationRequestQueue;
345 private array $chunkPopulationRequestQueueIndex = [];
349 private bool $autoSave =
true;
351 private int $sleepTicks = 0;
353 private int $chunkTickRadius;
354 private int $tickedBlocksPerSubchunkPerTick = self::DEFAULT_TICKED_BLOCKS_PER_SUBCHUNK_PER_TICK;
359 private array $randomTickBlocks = [];
363 public float $tickRateTime = 0;
365 private bool $doingTick =
false;
367 private bool $unloaded =
false;
372 private array $unloadCallbacks = [];
377 private \Logger $logger;
385 return morton2d_encode($x, $z);
388 private const MORTON3D_BIT_SIZE = 21;
389 private const BLOCKHASH_Y_BITS = 9;
390 private const BLOCKHASH_Y_PADDING = 64;
391 private const BLOCKHASH_Y_OFFSET = self::BLOCKHASH_Y_PADDING - self::Y_MIN;
392 private const BLOCKHASH_Y_MASK = (1 << self::BLOCKHASH_Y_BITS) - 1;
393 private const BLOCKHASH_XZ_MASK = (1 << self::MORTON3D_BIT_SIZE) - 1;
394 private const BLOCKHASH_XZ_EXTRA_BITS = (self::MORTON3D_BIT_SIZE - self::BLOCKHASH_Y_BITS) >> 1;
395 private const BLOCKHASH_XZ_EXTRA_MASK = (1 << self::BLOCKHASH_XZ_EXTRA_BITS) - 1;
396 private const BLOCKHASH_XZ_SIGN_SHIFT = 64 - self::MORTON3D_BIT_SIZE - self::BLOCKHASH_XZ_EXTRA_BITS;
397 private const BLOCKHASH_X_SHIFT = self::BLOCKHASH_Y_BITS;
398 private const BLOCKHASH_Z_SHIFT = self::BLOCKHASH_X_SHIFT + self::BLOCKHASH_XZ_EXTRA_BITS;
403 public static function blockHash(
int $x,
int $y,
int $z) : int{
404 $shiftedY = $y + self::BLOCKHASH_Y_OFFSET;
405 if(($shiftedY & (~0 << self::BLOCKHASH_Y_BITS)) !== 0){
406 throw new \InvalidArgumentException(
"Y coordinate $y is out of range!");
411 return morton3d_encode(
412 $x & self::BLOCKHASH_XZ_MASK,
414 ((($x >> self::MORTON3D_BIT_SIZE) & self::BLOCKHASH_XZ_EXTRA_MASK) << self::BLOCKHASH_X_SHIFT) |
415 ((($z >> self::MORTON3D_BIT_SIZE) & self::BLOCKHASH_XZ_EXTRA_MASK) << self::BLOCKHASH_Z_SHIFT),
416 $z & self::BLOCKHASH_XZ_MASK
424 return morton3d_encode($x, $y, $z);
433 public static function getBlockXYZ(
int $hash, ?
int &$x, ?
int &$y, ?
int &$z) : void{
434 [$baseX, $baseY, $baseZ] = morton3d_decode($hash);
436 $extraX = ((($baseY >> self::BLOCKHASH_X_SHIFT) & self::BLOCKHASH_XZ_EXTRA_MASK) << self::MORTON3D_BIT_SIZE);
437 $extraZ = ((($baseY >> self::BLOCKHASH_Z_SHIFT) & self::BLOCKHASH_XZ_EXTRA_MASK) << self::MORTON3D_BIT_SIZE);
439 $x = (($baseX & self::BLOCKHASH_XZ_MASK) | $extraX) << self::BLOCKHASH_XZ_SIGN_SHIFT >> self::BLOCKHASH_XZ_SIGN_SHIFT;
440 $y = ($baseY & self::BLOCKHASH_Y_MASK) - self::BLOCKHASH_Y_OFFSET;
441 $z = (($baseZ & self::BLOCKHASH_XZ_MASK) | $extraZ) << self::BLOCKHASH_XZ_SIGN_SHIFT >> self::BLOCKHASH_XZ_SIGN_SHIFT;
449 public static function getXZ(
int $hash, ?
int &$x, ?
int &$z) : void{
450 [$x, $z] = morton2d_decode($hash);
453 public static function getDifficultyFromString(
string $str) : int{
454 switch(strtolower(trim($str))){
458 return World::DIFFICULTY_PEACEFUL;
463 return World::DIFFICULTY_EASY;
468 return World::DIFFICULTY_NORMAL;
473 return World::DIFFICULTY_HARD;
488 $this->folderName = $name;
489 $this->worldId = self::$worldIdCounter++;
491 $this->displayName = $this->provider->getWorldData()->getName();
492 $this->logger = new \PrefixedLogger($server->getLogger(),
"World: $this->displayName");
494 $this->blockStateRegistry = RuntimeBlockStateRegistry::getInstance();
495 $this->minY = $this->provider->getWorldMinY();
496 $this->maxY = $this->provider->getWorldMaxY();
498 $this->
server->getLogger()->info($this->
server->getLanguage()->translate(KnownTranslationFactory::pocketmine_level_preparing($this->displayName)));
499 $generator = GeneratorManager::getInstance()->getGenerator($this->provider->getWorldData()->getGenerator()) ??
500 throw new AssumptionFailedError(
"WorldManager should already have checked that the generator exists");
501 $generator->validateGeneratorOptions($this->provider->getWorldData()->getGeneratorOptions());
504 worldMinY: $this->minY,
505 worldMaxY: $this->maxY,
506 generatorSeed: $this->getSeed(),
507 generatorClass: $generator->getGeneratorClass(),
508 generatorSettings: $this->provider->getWorldData()->getGeneratorOptions()
510 $this->generatorExecutor = $generator->isFast() ?
515 $executorSetupParameters,
519 $this->chunkPopulationRequestQueue = new \SplQueue();
520 $this->addOnUnloadCallback(
function() :
void{
521 $this->logger->debug(
"Cancelling unfulfilled generation requests");
523 foreach($this->chunkPopulationRequestMap as $chunkHash => $promise){
525 unset($this->chunkPopulationRequestMap[$chunkHash]);
527 if(count($this->chunkPopulationRequestMap) !== 0){
535 $this->scheduledBlockUpdateQueue->setExtractFlags(\SplPriorityQueue::EXTR_BOTH);
537 $this->neighbourBlockUpdateQueue = new \SplQueue();
539 $this->time = $this->provider->getWorldData()->getTime();
541 $cfg = $this->
server->getConfigGroup();
542 $this->chunkTickRadius = min($this->
server->getViewDistance(), max(0, $cfg->getPropertyInt(YmlServerProperties::CHUNK_TICKING_TICK_RADIUS, 4)));
543 if($cfg->getPropertyInt(
"chunk-ticking.per-tick", 40) <= 0){
545 $this->logger->warning(
"\"chunk-ticking.per-tick\" setting is deprecated, but you've used it to disable chunk ticking. Set \"chunk-ticking.tick-radius\" to 0 in \"pocketmine.yml\" instead.");
546 $this->chunkTickRadius = 0;
548 $this->tickedBlocksPerSubchunkPerTick = $cfg->getPropertyInt(YmlServerProperties::CHUNK_TICKING_BLOCKS_PER_SUBCHUNK_PER_TICK, self::DEFAULT_TICKED_BLOCKS_PER_SUBCHUNK_PER_TICK);
549 $this->maxConcurrentChunkPopulationTasks = $cfg->getPropertyInt(YmlServerProperties::CHUNK_GENERATION_POPULATION_QUEUE_SIZE, 2);
551 $this->initRandomTickBlocksFromConfig($cfg);
557 $dontTickBlocks = [];
558 $parser = StringToItemParser::getInstance();
559 foreach($cfg->getProperty(YmlServerProperties::CHUNK_TICKING_DISABLE_BLOCK_TICKING, []) as $name){
560 $name = (string) $name;
561 $item = $parser->parse($name);
563 $block = $item->getBlock();
564 }elseif(preg_match(
"/^-?\d+$/", $name) === 1){
567 $blockStateData = GlobalBlockStateHandlers::getUpgrader()->upgradeIntIdMeta((
int) $name, 0);
568 }
catch(BlockStateDeserializeException){
571 $block = $this->blockStateRegistry->fromStateId(GlobalBlockStateHandlers::getDeserializer()->deserialize($blockStateData));
577 if($block->getTypeId() !== BlockTypeIds::AIR){
578 $dontTickBlocks[$block->getTypeId()] = $name;
582 foreach($this->blockStateRegistry->getAllKnownStates() as $state){
583 $dontTickName = $dontTickBlocks[$state->getTypeId()] ??
null;
584 if($dontTickName ===
null && $state->ticksRandomly()){
585 $this->randomTickBlocks[$state->getStateId()] =
true;
590 public function getTickRateTime() : float{
591 return $this->tickRateTime;
594 public function getServer() : Server{
598 public function getLogger() : \
Logger{
599 return $this->logger;
602 final public function getProvider() : WritableWorldProvider{
603 return $this->provider;
609 final public function getId() : int{
610 return $this->worldId;
613 public function isLoaded() : bool{
614 return !$this->unloaded;
620 public function onUnload() : void{
622 throw new \LogicException(
"Tried to close a world which is already closed");
625 foreach($this->unloadCallbacks as $callback){
628 $this->unloadCallbacks = [];
630 foreach($this->chunks as $chunkHash => $chunk){
631 self::getXZ($chunkHash, $chunkX, $chunkZ);
632 $this->unloadChunk($chunkX, $chunkZ,
false);
634 $this->knownUngeneratedChunks = [];
635 foreach($this->entitiesByChunk as $chunkHash => $entities){
636 self::getXZ($chunkHash, $chunkX, $chunkZ);
639 foreach($entities as $entity){
640 if(!$entity->isFlaggedForDespawn()){
645 if($leakedEntities !== 0){
646 $this->logger->warning(
"$leakedEntities leaked entities found in ungenerated chunk $chunkX $chunkZ during unload, they won't be saved!");
652 $this->generatorExecutor->shutdown();
654 $this->provider->close();
655 $this->blockCache = [];
656 $this->blockCacheSize = 0;
657 $this->blockCollisionBoxCache = [];
659 $this->unloaded =
true;
664 $this->unloadCallbacks[spl_object_id($callback)] = $callback;
669 unset($this->unloadCallbacks[spl_object_id($callback)]);
680 private function filterViewersForPosition(
Vector3 $pos, array $allowed) : array{
681 $candidates = $this->getViewersForPosition($pos);
683 foreach($allowed as $player){
684 $k = spl_object_id($player);
685 if(isset($candidates[$k])){
686 $filtered[$k] = $candidates[$k];
697 $players ??= $this->getViewersForPosition($pos);
699 if(WorldSoundEvent::hasHandlers()){
702 if($ev->isCancelled()){
706 $sound = $ev->getSound();
707 $players = $ev->getRecipients();
710 $pk = $sound->
encode($pos);
712 if($players === $this->getViewersForPosition($pos)){
714 $this->broadcastPacketToViewers($pos, $e);
717 NetworkBroadcastUtils::broadcastPackets($this->filterViewersForPosition($pos, $players), $pk);
726 $players ??= $this->getViewersForPosition($pos);
728 if(WorldParticleEvent::hasHandlers()){
731 if($ev->isCancelled()){
735 $particle = $ev->getParticle();
736 $players = $ev->getRecipients();
739 $pk = $particle->
encode($pos);
741 if($players === $this->getViewersForPosition($pos)){
743 $this->broadcastPacketToViewers($pos, $e);
746 NetworkBroadcastUtils::broadcastPackets($this->filterViewersForPosition($pos, $players), $pk);
751 public function getAutoSave() : bool{
752 return $this->autoSave;
755 public function setAutoSave(
bool $value) : void{
756 $this->autoSave = $value;
769 return $this->playerChunkListeners[
World::chunkHash($chunkX, $chunkZ)] ?? [];
779 return $this->chunkLoaders[
World::chunkHash($chunkX, $chunkZ)] ?? [];
789 return $this->getChunkPlayers($pos->getFloorX() >>
Chunk::COORD_BIT_SIZE, $pos->getFloorZ() >>
Chunk::COORD_BIT_SIZE);
796 $this->broadcastPacketToPlayersUsingChunk($pos->getFloorX() >>
Chunk::COORD_BIT_SIZE, $pos->getFloorZ() >>
Chunk::COORD_BIT_SIZE, $packet);
799 private function broadcastPacketToPlayersUsingChunk(
int $chunkX,
int $chunkZ,
ClientboundPacket $packet) : void{
800 if(!isset($this->packetBuffersByChunk[$index =
World::chunkHash($chunkX, $chunkZ)])){
801 $this->packetBuffersByChunk[$index] = [$packet];
803 $this->packetBuffersByChunk[$index][] = $packet;
807 public function registerChunkLoader(ChunkLoader $loader,
int $chunkX,
int $chunkZ,
bool $autoLoad =
true) : void{
808 $loaderId = spl_object_id($loader);
810 if(!isset($this->chunkLoaders[$chunkHash = World::chunkHash($chunkX, $chunkZ)])){
811 $this->chunkLoaders[$chunkHash] = [];
812 }elseif(isset($this->chunkLoaders[$chunkHash][$loaderId])){
816 $this->chunkLoaders[$chunkHash][$loaderId] = $loader;
818 $this->cancelUnloadChunkRequest($chunkX, $chunkZ);
821 $this->loadChunk($chunkX, $chunkZ);
825 public function unregisterChunkLoader(ChunkLoader $loader,
int $chunkX,
int $chunkZ) : void{
826 $chunkHash = World::chunkHash($chunkX, $chunkZ);
827 $loaderId = spl_object_id($loader);
828 if(isset($this->chunkLoaders[$chunkHash][$loaderId])){
829 if(count($this->chunkLoaders[$chunkHash]) === 1){
830 unset($this->chunkLoaders[$chunkHash]);
831 $this->unloadChunkRequest($chunkX, $chunkZ,
true);
832 if(isset($this->chunkPopulationRequestMap[$chunkHash]) && !isset($this->activeChunkPopulationTasks[$chunkHash])){
833 $this->chunkPopulationRequestMap[$chunkHash]->reject();
834 unset($this->chunkPopulationRequestMap[$chunkHash]);
837 unset($this->chunkLoaders[$chunkHash][$loaderId]);
846 $hash =
World::chunkHash($chunkX, $chunkZ);
847 if(isset($this->chunkListeners[$hash])){
848 $this->chunkListeners[$hash][spl_object_id($listener)] = $listener;
850 $this->chunkListeners[$hash] = [spl_object_id($listener) => $listener];
852 if($listener instanceof
Player){
853 $this->playerChunkListeners[$hash][spl_object_id($listener)] = $listener;
863 $hash =
World::chunkHash($chunkX, $chunkZ);
864 if(isset($this->chunkListeners[$hash])){
865 if(count($this->chunkListeners[$hash]) === 1){
866 unset($this->chunkListeners[$hash]);
867 unset($this->playerChunkListeners[$hash]);
869 unset($this->chunkListeners[$hash][spl_object_id($listener)]);
870 unset($this->playerChunkListeners[$hash][spl_object_id($listener)]);
879 foreach($this->chunkListeners as $hash => $listeners){
880 World::getXZ($hash, $chunkX, $chunkZ);
881 $this->unregisterChunkListener($listener, $chunkX, $chunkZ);
892 return $this->chunkListeners[
World::chunkHash($chunkX, $chunkZ)] ?? [];
898 public function sendTime(
Player ...$targets) : void{
899 if(count($targets) === 0){
900 $targets = $this->players;
902 foreach($targets as $player){
903 $player->getNetworkSession()->syncWorldTime($this->time);
907 public function isDoingTick() : bool{
908 return $this->doingTick;
914 public function doTick(
int $currentTick) : void{
916 throw new \LogicException(
"Attempted to tick a world which has been closed");
919 $this->timings->doTick->startTiming();
920 $this->doingTick =
true;
922 $this->actuallyDoTick($currentTick);
924 $this->doingTick =
false;
925 $this->timings->doTick->stopTiming();
929 protected function actuallyDoTick(
int $currentTick) : void{
930 if(!$this->stopTime){
932 if($this->time === PHP_INT_MAX){
933 $this->time = PHP_INT_MIN;
939 $this->sunAnglePercentage = $this->computeSunAnglePercentage();
940 $this->skyLightReduction = $this->computeSkyLightReduction();
942 if(++$this->sendTimeTicker === 200){
944 $this->sendTimeTicker = 0;
947 $this->unloadChunks();
948 if(++$this->providerGarbageCollectionTicker >= 6000){
949 $this->provider->doGarbageCollection();
950 $this->providerGarbageCollectionTicker = 0;
953 $this->timings->scheduledBlockUpdates->startTiming();
955 while($this->scheduledBlockUpdateQueue->count() > 0 && $this->scheduledBlockUpdateQueue->current()[
"priority"] <= $currentTick){
957 $vec = $this->scheduledBlockUpdateQueue->extract()[
"data"];
958 unset($this->scheduledBlockUpdateQueueIndex[World::blockHash($vec->x, $vec->y, $vec->z)]);
959 if(!$this->isInLoadedTerrain($vec)){
962 $block = $this->getBlock($vec);
963 $block->onScheduledUpdate();
965 $this->timings->scheduledBlockUpdates->stopTiming();
967 $this->timings->neighbourBlockUpdates->startTiming();
969 while($this->neighbourBlockUpdateQueue->count() > 0){
970 $index = $this->neighbourBlockUpdateQueue->dequeue();
971 unset($this->neighbourBlockUpdateQueueIndex[$index]);
972 World::getBlockXYZ($index, $x, $y, $z);
973 if(!$this->isChunkLoaded($x >> Chunk::COORD_BIT_SIZE, $z >> Chunk::COORD_BIT_SIZE)){
977 $block = $this->getBlockAt($x, $y, $z);
979 if(BlockUpdateEvent::hasHandlers()){
980 $ev =
new BlockUpdateEvent($block);
982 if($ev->isCancelled()){
986 foreach($this->getNearbyEntities(AxisAlignedBB::one()->offsetCopy($x, $y, $z)) as $entity){
987 $entity->onNearbyBlockChange();
989 $block->onNearbyBlockChange();
992 $this->timings->neighbourBlockUpdates->stopTiming();
994 $this->timings->entityTick->startTiming();
996 foreach($this->updateEntities as $id => $entity){
997 if($entity->isClosed() || $entity->isFlaggedForDespawn() || !$entity->onUpdate($currentTick)){
998 unset($this->updateEntities[$id]);
1000 if($entity->isFlaggedForDespawn()){
1004 $this->timings->entityTick->stopTiming();
1006 $this->timings->randomChunkUpdates->startTiming();
1007 $this->tickChunks();
1008 $this->timings->randomChunkUpdates->stopTiming();
1010 $this->executeQueuedLightUpdates();
1012 if(count($this->changedBlocks) > 0){
1013 if(count($this->players) > 0){
1014 foreach($this->changedBlocks as $index => $blocks){
1015 if(count($blocks) === 0){
1018 World::getXZ($index, $chunkX, $chunkZ);
1019 if(!$this->isChunkLoaded($chunkX, $chunkZ)){
1023 if(count($blocks) > 512){
1024 $chunk = $this->getChunk($chunkX, $chunkZ) ??
throw new AssumptionFailedError(
"We already checked that the chunk is loaded");
1025 foreach($this->getChunkPlayers($chunkX, $chunkZ) as $p){
1026 $p->onChunkChanged($chunkX, $chunkZ, $chunk);
1029 foreach($this->createBlockUpdatePackets($blocks) as $packet){
1030 $this->broadcastPacketToPlayersUsingChunk($chunkX, $chunkZ, $packet);
1036 $this->changedBlocks = [];
1040 if($this->sleepTicks > 0 && --$this->sleepTicks <= 0){
1041 $this->checkSleep();
1044 foreach($this->packetBuffersByChunk as $index => $entries){
1045 World::getXZ($index, $chunkX, $chunkZ);
1046 $chunkPlayers = $this->getChunkPlayers($chunkX, $chunkZ);
1047 if(count($chunkPlayers) > 0){
1048 NetworkBroadcastUtils::broadcastPackets($chunkPlayers, $entries);
1052 $this->packetBuffersByChunk = [];
1055 public function checkSleep() : void{
1056 if(count($this->players) === 0){
1061 foreach($this->getPlayers() as $p){
1062 if(!$p->isSleeping()){
1069 $time = $this->getTimeOfDay();
1071 if($time >= World::TIME_NIGHT && $time < World::TIME_SUNRISE){
1072 $this->setTime($this->getTime() + World::TIME_FULL - $time);
1074 foreach($this->getPlayers() as $p){
1081 public function setSleepTicks(
int $ticks) : void{
1082 $this->sleepTicks = $ticks;
1094 $blockTranslator = TypeConverter::getInstance()->getBlockTranslator();
1096 foreach($blocks as $b){
1098 throw new \TypeError(
"Expected Vector3 in blocks array, got " . (is_object($b) ? get_class($b) : gettype($b)));
1101 $fullBlock = $this->getBlockAt($b->x, $b->y, $b->z);
1102 $blockPosition = BlockPosition::fromVector3($b);
1104 $tile = $this->getTileAt($b->x, $b->y, $b->z);
1106 $expectedClass = $fullBlock->getIdInfo()->getTileClass();
1107 if($expectedClass !==
null && $tile instanceof $expectedClass && count($fakeStateProperties = $tile->getRenderUpdateBugWorkaroundStateProperties($fullBlock)) > 0){
1108 $originalStateData = $blockTranslator->internalIdToNetworkStateData($fullBlock->getStateId());
1110 $originalStateData->getName(),
1111 array_merge($originalStateData->getStates(), $fakeStateProperties),
1112 $originalStateData->getVersion()
1114 $packets[] = UpdateBlockPacket::create(
1116 $blockTranslator->getBlockStateDictionary()->lookupStateIdFromData($fakeStateData) ??
throw new AssumptionFailedError(
"Unmapped fake blockstate data: " . $fakeStateData->toNbt()),
1117 UpdateBlockPacket::FLAG_NETWORK,
1118 UpdateBlockPacket::DATA_LAYER_NORMAL
1122 $packets[] = UpdateBlockPacket::create(
1124 $blockTranslator->internalIdToNetworkId($fullBlock->getStateId()),
1125 UpdateBlockPacket::FLAG_NETWORK,
1126 UpdateBlockPacket::DATA_LAYER_NORMAL
1130 $packets[] = BlockActorDataPacket::create($blockPosition, $tile->getSerializedSpawnCompound());
1137 public function clearCache(
bool $force =
false) : void{
1139 $this->blockCache = [];
1140 $this->blockCacheSize = 0;
1141 $this->blockCollisionBoxCache = [];
1144 $this->blockCacheSize = 0;
1145 foreach($this->blockCache as $list){
1146 $this->blockCacheSize += count($list);
1147 if($this->blockCacheSize > self::BLOCK_CACHE_SIZE_CAP){
1148 $this->blockCache = [];
1149 $this->blockCacheSize = 0;
1155 foreach($this->blockCollisionBoxCache as $list){
1156 $count += count($list);
1157 if($count > self::BLOCK_CACHE_SIZE_CAP){
1159 $this->blockCollisionBoxCache = [];
1166 private function trimBlockCache() : void{
1167 $before = $this->blockCacheSize;
1170 foreach($this->blockCache as $chunkHash => $blocks){
1171 unset($this->blockCache[$chunkHash]);
1172 $this->blockCacheSize -= count($blocks);
1173 if($this->blockCacheSize < self::BLOCK_CACHE_SIZE_CAP){
1184 return $this->randomTickBlocks;
1187 public function addRandomTickedBlock(
Block $block) : void{
1189 throw new \InvalidArgumentException(
"Cannot do random-tick on unknown block");
1191 $this->randomTickBlocks[$block->getStateId()] =
true;
1194 public function removeRandomTickedBlock(Block $block) : void{
1195 unset($this->randomTickBlocks[$block->getStateId()]);
1203 return $this->chunkTickRadius;
1211 $this->chunkTickRadius = $radius;
1222 return array_keys($this->validTickingChunks);
1230 $chunkPosHash =
World::chunkHash($chunkX, $chunkZ);
1231 $this->registeredTickingChunks[$chunkPosHash][spl_object_id($ticker)] = $ticker;
1232 $this->recheckTickingChunks[$chunkPosHash] = $chunkPosHash;
1240 $chunkHash =
World::chunkHash($chunkX, $chunkZ);
1241 $tickerId = spl_object_id($ticker);
1242 if(isset($this->registeredTickingChunks[$chunkHash][$tickerId])){
1243 if(count($this->registeredTickingChunks[$chunkHash]) === 1){
1245 $this->registeredTickingChunks[$chunkHash],
1246 $this->recheckTickingChunks[$chunkHash],
1247 $this->validTickingChunks[$chunkHash]
1250 unset($this->registeredTickingChunks[$chunkHash][$tickerId]);
1255 private function tickChunks() : void{
1256 if($this->chunkTickRadius <= 0 || count($this->registeredTickingChunks) === 0){
1260 if(count($this->recheckTickingChunks) > 0){
1261 $this->timings->randomChunkUpdatesChunkSelection->startTiming();
1263 $chunkTickableCache = [];
1265 foreach($this->recheckTickingChunks as $hash => $_){
1266 World::getXZ($hash, $chunkX, $chunkZ);
1267 if($this->isChunkTickable($chunkX, $chunkZ, $chunkTickableCache)){
1268 $this->validTickingChunks[$hash] = $hash;
1271 $this->recheckTickingChunks = [];
1273 $this->timings->randomChunkUpdatesChunkSelection->stopTiming();
1276 foreach($this->validTickingChunks as $index => $_){
1277 World::getXZ($index, $chunkX, $chunkZ);
1279 $this->tickChunk($chunkX, $chunkZ);
1289 private function isChunkTickable(
int $chunkX,
int $chunkZ, array &$cache) : bool{
1290 for($cx = -1; $cx <= 1; ++$cx){
1291 for($cz = -1; $cz <= 1; ++$cz){
1292 $chunkHash = World::chunkHash($chunkX + $cx, $chunkZ + $cz);
1293 if(isset($cache[$chunkHash])){
1294 if(!$cache[$chunkHash]){
1299 if($this->isChunkLocked($chunkX + $cx, $chunkZ + $cz)){
1300 $cache[$chunkHash] =
false;
1303 $adjacentChunk = $this->getChunk($chunkX + $cx, $chunkZ + $cz);
1304 if($adjacentChunk ===
null || !$adjacentChunk->isPopulated()){
1305 $cache[$chunkHash] =
false;
1308 $lightPopulatedState = $adjacentChunk->isLightPopulated();
1309 if($lightPopulatedState !==
true){
1310 if($lightPopulatedState ===
false){
1311 $this->orderLightPopulation($chunkX + $cx, $chunkZ + $cz);
1313 $cache[$chunkHash] =
false;
1317 $cache[$chunkHash] =
true;
1333 private function markTickingChunkForRecheck(
int $chunkX,
int $chunkZ) : void{
1334 for($cx = -1; $cx <= 1; ++$cx){
1335 for($cz = -1; $cz <= 1; ++$cz){
1336 $chunkHash = World::chunkHash($chunkX + $cx, $chunkZ + $cz);
1337 unset($this->validTickingChunks[$chunkHash]);
1338 if(isset($this->registeredTickingChunks[$chunkHash])){
1339 $this->recheckTickingChunks[$chunkHash] = $chunkHash;
1341 unset($this->recheckTickingChunks[$chunkHash]);
1347 private function orderLightPopulation(
int $chunkX,
int $chunkZ) : void{
1348 $chunkHash = World::chunkHash($chunkX, $chunkZ);
1349 $lightPopulatedState = $this->chunks[$chunkHash]->isLightPopulated();
1350 if($lightPopulatedState ===
false){
1351 $this->chunks[$chunkHash]->setLightPopulated(
null);
1352 $this->markTickingChunkForRecheck($chunkX, $chunkZ);
1354 $this->workerPool->submitTask(
new LightPopulationTask(
1355 $this->chunks[$chunkHash],
1356 function(array $blockLight, array $skyLight, array $heightMap) use ($chunkX, $chunkZ) :
void{
1363 if($this->unloaded || ($chunk = $this->getChunk($chunkX, $chunkZ)) ===
null || $chunk->isLightPopulated() ===
true){
1368 $chunk->setHeightMapArray($heightMap);
1369 foreach($blockLight as $y => $lightArray){
1370 $chunk->getSubChunk($y)->setBlockLightArray($lightArray);
1372 foreach($skyLight as $y => $lightArray){
1373 $chunk->getSubChunk($y)->setBlockSkyLightArray($lightArray);
1375 $chunk->setLightPopulated(
true);
1376 $this->markTickingChunkForRecheck($chunkX, $chunkZ);
1382 private function tickChunk(
int $chunkX,
int $chunkZ) : void{
1383 $chunk = $this->getChunk($chunkX, $chunkZ);
1384 if($chunk ===
null){
1388 foreach($this->getChunkEntities($chunkX, $chunkZ) as $entity){
1389 $entity->onRandomUpdate();
1392 $blockFactory = $this->blockStateRegistry;
1393 foreach($chunk->getSubChunks() as $Y => $subChunk){
1394 if(!$subChunk->isEmptyFast()){
1396 for($i = 0; $i < $this->tickedBlocksPerSubchunkPerTick; ++$i){
1399 $k = mt_rand(0, (1 << 60) - 1);
1401 $x = $k & SubChunk::COORD_MASK;
1402 $y = ($k >> SubChunk::COORD_BIT_SIZE) & SubChunk::COORD_MASK;
1403 $z = ($k >> (SubChunk::COORD_BIT_SIZE * 2)) & SubChunk::COORD_MASK;
1404 $k >>= (SubChunk::COORD_BIT_SIZE * 3);
1406 $state = $subChunk->getBlockStateId($x, $y, $z);
1408 if(isset($this->randomTickBlocks[$state])){
1409 $block = $blockFactory->fromStateId($state);
1410 $block->position($this, $chunkX * Chunk::EDGE_LENGTH + $x, ($Y << SubChunk::COORD_BIT_SIZE) + $y, $chunkZ * Chunk::EDGE_LENGTH + $z);
1411 $block->onRandomTick();
1425 public function save(
bool $force =
false) : bool{
1427 if(!$this->getAutoSave() && !$force){
1431 (
new WorldSaveEvent($this))->call();
1433 $timings = $this->timings->syncDataSave;
1434 $timings->startTiming();
1436 $this->provider->getWorldData()->setTime($this->time);
1437 $this->saveChunks();
1438 $this->provider->getWorldData()->save();
1440 $timings->stopTiming();
1445 public function saveChunks() : void{
1446 $this->timings->syncChunkSave->startTiming();
1448 foreach($this->chunks as $chunkHash => $chunk){
1449 self::getXZ($chunkHash, $chunkX, $chunkZ);
1450 $this->provider->saveChunk($chunkX, $chunkZ,
new ChunkData(
1451 $chunk->getSubChunks(),
1452 $chunk->isPopulated(),
1453 array_map(fn(Entity $e) => $e->saveNBT(), array_values(array_filter($this->getChunkEntities($chunkX, $chunkZ), fn(Entity $e) => $e->canSaveWithChunk()))),
1454 array_map(fn(Tile $t) => $t->saveNBT(), array_values($chunk->getTiles())),
1455 ), $chunk->getTerrainDirtyFlags());
1456 $chunk->clearTerrainDirtyFlags();
1459 $this->timings->syncChunkSave->stopTiming();
1469 !$this->isInWorld($pos->x, $pos->y, $pos->z) ||
1470 (isset($this->scheduledBlockUpdateQueueIndex[$index =
World::blockHash($pos->x, $pos->y, $pos->z)]) && $this->scheduledBlockUpdateQueueIndex[$index] <= $delay)
1474 $this->scheduledBlockUpdateQueueIndex[$index] = $delay;
1475 $this->scheduledBlockUpdateQueue->insert(
new Vector3((
int) $pos->x, (
int) $pos->y, (
int) $pos->z), $delay + $this->server->getTick());
1478 private function tryAddToNeighbourUpdateQueue(
int $x,
int $y,
int $z) : void{
1479 if($this->isInWorld($x, $y, $z)){
1480 $hash = World::blockHash($x, $y, $z);
1481 if(!isset($this->neighbourBlockUpdateQueueIndex[$hash])){
1482 $this->neighbourBlockUpdateQueue->enqueue($hash);
1483 $this->neighbourBlockUpdateQueueIndex[$hash] =
true;
1494 private function internalNotifyNeighbourBlockUpdate(
int $x,
int $y,
int $z) : void{
1495 $this->tryAddToNeighbourUpdateQueue($x, $y, $z);
1496 foreach(Facing::OFFSET as [$dx, $dy, $dz]){
1497 $this->tryAddToNeighbourUpdateQueue($x + $dx, $y + $dy, $z + $dz);
1509 $this->internalNotifyNeighbourBlockUpdate($pos->getFloorX(), $pos->getFloorY(), $pos->getFloorZ());
1517 $minX = (int) floor($bb->minX - 1);
1518 $minY = (int) floor($bb->minY - 1);
1519 $minZ = (int) floor($bb->minZ - 1);
1520 $maxX = (int) floor($bb->maxX + 1);
1521 $maxY = (int) floor($bb->maxY + 1);
1522 $maxZ = (int) floor($bb->maxZ + 1);
1526 $collisionInfo = $this->blockStateRegistry->collisionInfo;
1528 for($z = $minZ; $z <= $maxZ; ++$z){
1529 $zOverflow = $z === $minZ || $z === $maxZ;
1530 for($x = $minX; $x <= $maxX; ++$x){
1531 $zxOverflow = $zOverflow || $x === $minX || $x === $maxX;
1532 for($y = $minY; $y <= $maxY; ++$y){
1533 $overflow = $zxOverflow || $y === $minY || $y === $maxY;
1535 $stateCollisionInfo = $this->getBlockCollisionInfo($x, $y, $z, $collisionInfo);
1537 $stateCollisionInfo === RuntimeBlockStateRegistry::COLLISION_MAY_OVERFLOW && $this->getBlockAt($x, $y, $z)->collidesWithBB($bb) :
1538 match ($stateCollisionInfo) {
1539 RuntimeBlockStateRegistry::COLLISION_CUBE =>
true,
1540 RuntimeBlockStateRegistry::COLLISION_NONE =>
false,
1541 default => $this->getBlockAt($x, $y, $z)->collidesWithBB($bb)
1544 return [$this->getBlockAt($x, $y, $z)];
1551 for($z = $minZ; $z <= $maxZ; ++$z){
1552 $zOverflow = $z === $minZ || $z === $maxZ;
1553 for($x = $minX; $x <= $maxX; ++$x){
1554 $zxOverflow = $zOverflow || $x === $minX || $x === $maxX;
1555 for($y = $minY; $y <= $maxY; ++$y){
1556 $overflow = $zxOverflow || $y === $minY || $y === $maxY;
1558 $stateCollisionInfo = $this->getBlockCollisionInfo($x, $y, $z, $collisionInfo);
1560 $stateCollisionInfo === RuntimeBlockStateRegistry::COLLISION_MAY_OVERFLOW && $this->getBlockAt($x, $y, $z)->collidesWithBB($bb) :
1561 match ($stateCollisionInfo) {
1562 RuntimeBlockStateRegistry::COLLISION_CUBE =>
true,
1563 RuntimeBlockStateRegistry::COLLISION_NONE =>
false,
1564 default => $this->getBlockAt($x, $y, $z)->collidesWithBB($bb)
1567 $collides[] = $this->getBlockAt($x, $y, $z);
1581 private function getBlockCollisionInfo(
int $x,
int $y,
int $z, array $collisionInfo) : int{
1582 if(!$this->isInWorld($x, $y, $z)){
1583 return RuntimeBlockStateRegistry::COLLISION_NONE;
1585 $chunk = $this->getChunk($x >> Chunk::COORD_BIT_SIZE, $z >> Chunk::COORD_BIT_SIZE);
1586 if($chunk ===
null){
1587 return RuntimeBlockStateRegistry::COLLISION_NONE;
1590 ->getSubChunk($y >> SubChunk::COORD_BIT_SIZE)
1592 $x & SubChunk::COORD_MASK,
1593 $y & SubChunk::COORD_MASK,
1594 $z & SubChunk::COORD_MASK
1596 return $collisionInfo[$stateId];
1610 private function getBlockCollisionBoxesForCell(
int $x,
int $y,
int $z, array $collisionInfo) : array{
1611 $stateCollisionInfo = $this->getBlockCollisionInfo($x, $y, $z, $collisionInfo);
1612 $boxes = match($stateCollisionInfo){
1613 RuntimeBlockStateRegistry::COLLISION_NONE => [],
1614 RuntimeBlockStateRegistry::COLLISION_CUBE => [AxisAlignedBB::one()->offsetCopy($x, $y, $z)],
1615 default => $this->getBlockAt($x, $y, $z)->getCollisionBoxes()
1619 if($stateCollisionInfo !== RuntimeBlockStateRegistry::COLLISION_CUBE){
1621 foreach(Facing::OFFSET as [$dx, $dy, $dz]){
1622 $offsetX = $x + $dx;
1623 $offsetY = $y + $dy;
1624 $offsetZ = $z + $dz;
1625 $stateCollisionInfo = $this->getBlockCollisionInfo($offsetX, $offsetY, $offsetZ, $collisionInfo);
1626 if($stateCollisionInfo === RuntimeBlockStateRegistry::COLLISION_MAY_OVERFLOW){
1628 $cellBB ??= AxisAlignedBB::one()->offsetCopy($x, $y, $z);
1629 $extraBoxes = $this->getBlockAt($offsetX, $offsetY, $offsetZ)->getCollisionBoxes();
1630 foreach($extraBoxes as $extraBox){
1631 if($extraBox->intersectsWith($cellBB)){
1632 $boxes[] = $extraBox;
1647 $minX = (int) floor($bb->minX);
1648 $minY = (int) floor($bb->minY);
1649 $minZ = (int) floor($bb->minZ);
1650 $maxX = (int) floor($bb->maxX);
1651 $maxY = (int) floor($bb->maxY);
1652 $maxZ = (int) floor($bb->maxZ);
1656 $collisionInfo = $this->blockStateRegistry->collisionInfo;
1658 for($z = $minZ; $z <= $maxZ; ++$z){
1659 for($x = $minX; $x <= $maxX; ++$x){
1660 $chunkPosHash = World::chunkHash($x >> Chunk::COORD_BIT_SIZE, $z >> Chunk::COORD_BIT_SIZE);
1661 for($y = $minY; $y <= $maxY; ++$y){
1662 $relativeBlockHash = World::chunkBlockHash($x, $y, $z);
1664 $boxes = $this->blockCollisionBoxCache[$chunkPosHash][$relativeBlockHash] ??= $this->getBlockCollisionBoxesForCell($x, $y, $z, $collisionInfo);
1666 foreach($boxes as $blockBB){
1667 if($blockBB->intersectsWith($bb)){
1668 $collides[] = $blockBB;
1683 $timeProgress = ($this->time % self::TIME_FULL) / self::TIME_FULL;
1686 $sunProgress = $timeProgress + ($timeProgress < 0.25 ? 0.75 : -0.25);
1690 $diff = (((1 - ((cos($sunProgress * M_PI) + 1) / 2)) - $sunProgress) / 3);
1692 return $sunProgress + $diff;
1699 return $this->sunAnglePercentage;
1706 return $this->sunAnglePercentage * 2 * M_PI;
1713 return $this->sunAnglePercentage * 360.0;
1721 $percentage = max(0, min(1, -(cos($this->getSunAngleRadians()) * 2 - 0.5)));
1725 return (
int) ($percentage * 11);
1732 return $this->skyLightReduction;
1740 $floorX = $pos->getFloorX();
1741 $floorY = $pos->getFloorY();
1742 $floorZ = $pos->getFloorZ();
1743 return $this->getFullLightAt($floorX, $floorY, $floorZ);
1751 $skyLight = $this->getRealBlockSkyLightAt($x, $y, $z);
1753 return max($skyLight, $this->getBlockLightAt($x, $y, $z));
1764 return $this->getHighestAdjacentLight($x, $y, $z, $this->getFullLightAt(...));
1772 $floorX = $pos->getFloorX();
1773 $floorY = $pos->getFloorY();
1774 $floorZ = $pos->getFloorZ();
1775 return $this->getPotentialLightAt($floorX, $floorY, $floorZ);
1783 return max($this->getPotentialBlockSkyLightAt($x, $y, $z), $this->getBlockLightAt($x, $y, $z));
1791 return $this->getHighestAdjacentLight($x, $y, $z, $this->getPotentialLightAt(...));
1801 if(!$this->isInWorld($x, $y, $z)){
1802 return $y >= self::Y_MAX ? 15 : 0;
1804 if(($chunk = $this->getChunk($x >> Chunk::COORD_BIT_SIZE, $z >> Chunk::COORD_BIT_SIZE)) !==
null && $chunk->isLightPopulated() ===
true){
1805 return $chunk->getSubChunk($y >> Chunk::COORD_BIT_SIZE)->getBlockSkyLightArray()->get($x & SubChunk::COORD_MASK, $y & SubChunk::COORD_MASK, $z & SubChunk::COORD_MASK);
1816 $light = $this->getPotentialBlockSkyLightAt($x, $y, $z) - $this->skyLightReduction;
1817 return $light < 0 ? 0 : $light;
1826 if(!$this->isInWorld($x, $y, $z)){
1829 if(($chunk = $this->getChunk($x >> Chunk::COORD_BIT_SIZE, $z >> Chunk::COORD_BIT_SIZE)) !==
null && $chunk->isLightPopulated() ===
true){
1830 return $chunk->getSubChunk($y >> Chunk::COORD_BIT_SIZE)->getBlockLightArray()->get($x & SubChunk::COORD_MASK, $y & SubChunk::COORD_MASK, $z & SubChunk::COORD_MASK);
1835 public function updateAllLight(
int $x,
int $y,
int $z) : void{
1836 if(($chunk = $this->getChunk($x >> Chunk::COORD_BIT_SIZE, $z >> Chunk::COORD_BIT_SIZE)) === null || $chunk->isLightPopulated() !== true){
1840 $blockFactory = $this->blockStateRegistry;
1841 $this->timings->doBlockSkyLightUpdates->startTiming();
1842 if($this->skyLightUpdate ===
null){
1843 $this->skyLightUpdate =
new SkyLightUpdate(
new SubChunkExplorer($this), $blockFactory->lightFilter, $blockFactory->blocksDirectSkyLight);
1845 $this->skyLightUpdate->recalculateNode($x, $y, $z);
1846 $this->timings->doBlockSkyLightUpdates->stopTiming();
1848 $this->timings->doBlockLightUpdates->startTiming();
1849 if($this->blockLightUpdate ===
null){
1850 $this->blockLightUpdate =
new BlockLightUpdate(
new SubChunkExplorer($this), $blockFactory->lightFilter, $blockFactory->light);
1852 $this->blockLightUpdate->recalculateNode($x, $y, $z);
1853 $this->timings->doBlockLightUpdates->stopTiming();
1859 private function getHighestAdjacentLight(
int $x,
int $y,
int $z, \Closure $lightGetter) : int{
1861 foreach(Facing::OFFSET as [$offsetX, $offsetY, $offsetZ]){
1862 $x1 = $x + $offsetX;
1863 $y1 = $y + $offsetY;
1864 $z1 = $z + $offsetZ;
1866 !$this->isInWorld($x1, $y1, $z1) ||
1867 ($chunk = $this->getChunk($x1 >> Chunk::COORD_BIT_SIZE, $z1 >> Chunk::COORD_BIT_SIZE)) ===
null ||
1868 $chunk->isLightPopulated() !==
true
1872 $max = max($max, $lightGetter($x1, $y1, $z1));
1881 return $this->getHighestAdjacentLight($x, $y, $z, $this->getPotentialBlockSkyLightAt(...));
1889 return $this->getHighestAdjacentPotentialBlockSkyLight($x, $y, $z) - $this->skyLightReduction;
1896 return $this->getHighestAdjacentLight($x, $y, $z, $this->getBlockLightAt(...));
1899 private function executeQueuedLightUpdates() : void{
1900 if($this->blockLightUpdate !== null){
1901 $this->timings->doBlockLightUpdates->startTiming();
1902 $this->blockLightUpdate->execute();
1903 $this->blockLightUpdate =
null;
1904 $this->timings->doBlockLightUpdates->stopTiming();
1907 if($this->skyLightUpdate !==
null){
1908 $this->timings->doBlockSkyLightUpdates->startTiming();
1909 $this->skyLightUpdate->execute();
1910 $this->skyLightUpdate =
null;
1911 $this->timings->doBlockSkyLightUpdates->stopTiming();
1918 $y < $this->maxY && $y >= $this->minY &&
1934 return $this->getBlockAt((int) floor($pos->x), (int) floor($pos->y), (int) floor($pos->z), $cached, $addToCache);
1946 public function getBlockAt(
int $x,
int $y,
int $z,
bool $cached =
true,
bool $addToCache =
true) :
Block{
1947 $relativeBlockHash = null;
1948 $chunkHash = World::chunkHash($x >> Chunk::COORD_BIT_SIZE, $z >> Chunk::COORD_BIT_SIZE);
1950 if($this->isInWorld($x, $y, $z)){
1951 $relativeBlockHash = World::chunkBlockHash($x, $y, $z);
1953 if($cached && isset($this->blockCache[$chunkHash][$relativeBlockHash])){
1954 return $this->blockCache[$chunkHash][$relativeBlockHash];
1957 $chunk = $this->chunks[$chunkHash] ??
null;
1958 if($chunk !==
null){
1959 $block = $this->blockStateRegistry->fromStateId($chunk->getBlockStateId($x & Chunk::COORD_MASK, $y, $z & Chunk::COORD_MASK));
1961 $addToCache =
false;
1962 $block = VanillaBlocks::AIR();
1965 $block = VanillaBlocks::AIR();
1968 $block->position($this, $x, $y, $z);
1970 if($this->inDynamicStateRecalculation){
1974 $addToCache =
false;
1976 $this->inDynamicStateRecalculation =
true;
1977 $replacement = $block->readStateFromWorld();
1978 if($replacement !== $block){
1979 $replacement->position($this, $x, $y, $z);
1980 $block = $replacement;
1982 $this->inDynamicStateRecalculation =
false;
1985 if($addToCache && $relativeBlockHash !==
null){
1986 $this->blockCache[$chunkHash][$relativeBlockHash] = $block;
1988 if(++$this->blockCacheSize >= self::BLOCK_CACHE_SIZE_CAP){
1989 $this->trimBlockCache();
2002 $this->setBlockAt((int) floor($pos->x), (int) floor($pos->y), (int) floor($pos->z), $block, $update);
2013 public function setBlockAt(
int $x,
int $y,
int $z,
Block $block,
bool $update =
true) : void{
2014 if(!$this->isInWorld($x, $y, $z)){
2015 throw new \InvalidArgumentException(
"Pos x=$x,y=$y,z=$z is outside of the world bounds");
2017 $chunkX = $x >> Chunk::COORD_BIT_SIZE;
2018 $chunkZ = $z >> Chunk::COORD_BIT_SIZE;
2019 if($this->loadChunk($chunkX, $chunkZ) ===
null){
2020 throw new WorldException(
"Cannot set a block in un-generated terrain");
2024 $stateId = $block->getStateId();
2025 if(!$this->blockStateRegistry->hasStateId($stateId)){
2026 throw new \LogicException(
"Block state ID not known to RuntimeBlockStateRegistry (probably not registered)");
2028 if(!GlobalBlockStateHandlers::getSerializer()->isRegistered($block)){
2029 throw new \LogicException(
"Block not registered with GlobalBlockStateHandlers serializer");
2032 $this->timings->setBlock->startTiming();
2034 $this->unlockChunk($chunkX, $chunkZ,
null);
2036 $block = clone $block;
2038 $block->position($this, $x, $y, $z);
2039 $block->writeStateToWorld();
2040 $pos =
new Vector3($x, $y, $z);
2042 $chunkHash = World::chunkHash($chunkX, $chunkZ);
2043 $relativeBlockHash = World::chunkBlockHash($x, $y, $z);
2045 unset($this->blockCache[$chunkHash][$relativeBlockHash]);
2046 $this->blockCacheSize--;
2047 unset($this->blockCollisionBoxCache[$chunkHash][$relativeBlockHash]);
2050 foreach(Facing::OFFSET as [$offsetX, $offsetY, $offsetZ]){
2051 $sideChunkPosHash = World::chunkHash(($x + $offsetX) >> Chunk::COORD_BIT_SIZE, ($z + $offsetZ) >> Chunk::COORD_BIT_SIZE);
2052 $sideChunkBlockHash = World::chunkBlockHash($x + $offsetX, $y + $offsetY, $z + $offsetZ);
2053 unset($this->blockCollisionBoxCache[$sideChunkPosHash][$sideChunkBlockHash]);
2056 if(!isset($this->changedBlocks[$chunkHash])){
2057 $this->changedBlocks[$chunkHash] = [];
2059 $this->changedBlocks[$chunkHash][$relativeBlockHash] = $pos;
2061 foreach($this->getChunkListeners($chunkX, $chunkZ) as $listener){
2062 $listener->onBlockChanged($pos);
2066 $this->updateAllLight($x, $y, $z);
2067 $this->internalNotifyNeighbourBlockUpdate($x, $y, $z);
2070 $this->timings->setBlock->stopTiming();
2073 public function dropItem(Vector3 $source, Item $item, ?Vector3 $motion =
null,
int $delay = 10) : ?ItemEntity{
2074 if($item->isNull()){
2078 $itemEntity =
new ItemEntity(Location::fromObject($source, $this, Utils::getRandomFloat() * 360, 0), $item);
2080 $itemEntity->setPickupDelay($delay);
2081 $itemEntity->setMotion($motion ??
new Vector3(Utils::getRandomFloat() * 0.2 - 0.1, 0.2, Utils::getRandomFloat() * 0.2 - 0.1));
2082 $itemEntity->spawnToAll();
2096 foreach(ExperienceOrb::splitIntoOrbSizes($amount) as $split){
2097 $orb =
new ExperienceOrb(Location::fromObject($pos, $this, Utils::getRandomFloat() * 360, 0), $split);
2099 $orb->setMotion(
new Vector3((Utils::getRandomFloat() * 0.2 - 0.1) * 2, Utils::getRandomFloat() * 0.4, (Utils::getRandomFloat() * 0.2 - 0.1) * 2));
2116 public function useBreakOn(
Vector3 $vector, ?
Item &$item =
null, ?
Player $player =
null,
bool $createParticles =
false, array &$returnedItems = []) : bool{
2117 $vector = $vector->floor();
2119 $chunkX = $vector->getFloorX() >> Chunk::COORD_BIT_SIZE;
2120 $chunkZ = $vector->getFloorZ() >> Chunk::COORD_BIT_SIZE;
2121 if(!$this->isChunkLoaded($chunkX, $chunkZ) || $this->isChunkLocked($chunkX, $chunkZ)){
2125 $target = $this->getBlock($vector);
2126 $affectedBlocks = $target->getAffectedBlocks();
2129 $item = VanillaItems::AIR();
2133 if($player ===
null || $player->hasFiniteResources()){
2134 $drops = array_merge(...array_map(fn(Block $block) => $block->getDrops($item), $affectedBlocks));
2138 if($player !==
null && $player->hasFiniteResources()){
2139 $xpDrop = array_sum(array_map(fn(Block $block) => $block->getXpDropForTool($item), $affectedBlocks));
2142 if($player !==
null){
2143 $ev =
new BlockBreakEvent($player, $target, $item, $player->isCreative(), $drops, $xpDrop);
2145 if($target instanceof Air || ($player->isSurvival() && !$target->getBreakInfo()->isBreakable()) || $player->isSpectator()){
2149 if($player->isAdventure(
true) && !$ev->isCancelled()){
2151 $itemParser = LegacyStringToItemParser::getInstance();
2152 foreach($item->getCanDestroy() as $v){
2153 $entry = $itemParser->parse($v);
2154 if($entry->getBlock()->hasSameTypeId($target)){
2166 if($ev->isCancelled()){
2170 $drops = $ev->getDrops();
2171 $xpDrop = $ev->getXpDropAmount();
2173 }elseif(!$target->getBreakInfo()->isBreakable()){
2177 foreach($affectedBlocks as $t){
2178 $this->destroyBlockInternal($t, $item, $player, $createParticles, $returnedItems);
2181 $item->onDestroyBlock($target, $returnedItems);
2183 if(count($drops) > 0){
2184 $dropPos = $vector->add(0.5, 0.5, 0.5);
2185 foreach($drops as $drop){
2186 if(!$drop->isNull()){
2187 $this->dropItem($dropPos, $drop);
2193 $this->dropExperience($vector->add(0.5, 0.5, 0.5), $xpDrop);
2202 private function destroyBlockInternal(Block $target, Item $item, ?Player $player,
bool $createParticles, array &$returnedItems) : void{
2203 if($createParticles){
2204 $this->addParticle($target->getPosition()->add(0.5, 0.5, 0.5),
new BlockBreakParticle($target));
2207 $target->onBreak($item, $player, $returnedItems);
2209 $tile = $this->getTile($target->getPosition());
2211 $tile->onBlockDestroyed();
2223 $blockClicked = $this->getBlock($vector);
2224 $blockReplace = $blockClicked->getSide($face);
2226 if($clickVector ===
null){
2227 $clickVector =
new Vector3(0.0, 0.0, 0.0);
2230 min(1.0, max(0.0, $clickVector->x)),
2231 min(1.0, max(0.0, $clickVector->y)),
2232 min(1.0, max(0.0, $clickVector->z))
2236 if(!$this->isInWorld($blockReplace->getPosition()->x, $blockReplace->getPosition()->y, $blockReplace->getPosition()->z)){
2240 $chunkX = $blockReplace->getPosition()->getFloorX() >> Chunk::COORD_BIT_SIZE;
2241 $chunkZ = $blockReplace->getPosition()->getFloorZ() >> Chunk::COORD_BIT_SIZE;
2242 if(!$this->isChunkLoaded($chunkX, $chunkZ) || $this->isChunkLocked($chunkX, $chunkZ)){
2246 if($blockClicked->getTypeId() === BlockTypeIds::AIR){
2250 if($player !==
null){
2251 $ev = new PlayerInteractEvent($player, $item, $blockClicked, $clickVector, $face, PlayerInteractEvent::RIGHT_CLICK_BLOCK);
2252 if($player->isSneaking()){
2253 $ev->setUseItem(false);
2254 $ev->setUseBlock($item->isNull());
2256 if($player->isSpectator()){
2261 if(!$ev->isCancelled()){
2262 if($ev->useBlock() && $blockClicked->onInteract($item, $face, $clickVector, $player, $returnedItems)){
2267 $result = $item->onInteractBlock($player, $blockReplace, $blockClicked, $face, $clickVector, $returnedItems);
2268 if($result !== ItemUseResult::NONE){
2269 return $result === ItemUseResult::SUCCESS;
2275 }elseif($blockClicked->onInteract($item, $face, $clickVector, $player, $returnedItems)){
2279 if($item->isNull() || !$item->canBePlaced()){
2287 $item->getPlacementTransaction($blockClicked, $blockClicked, Facing::UP, $clickVector, $player) ??
2288 $item->getPlacementTransaction($blockReplace, $blockClicked, $face, $clickVector, $player);
2294 foreach($tx->getBlocks() as [$x, $y, $z, $block]){
2295 $block->position($this, $x, $y, $z);
2296 foreach($block->getCollisionBoxes() as $collisionBox){
2297 if(count($this->getCollidingEntities($collisionBox)) > 0){
2303 if($player !==
null){
2304 $ev =
new BlockPlaceEvent($player, $tx, $blockClicked, $item);
2305 if($player->isSpectator()){
2309 if($player->isAdventure(
true) && !$ev->isCancelled()){
2311 $itemParser = LegacyStringToItemParser::getInstance();
2313 $entry = $itemParser->parse($v);
2314 if($entry->getBlock()->hasSameTypeId($blockClicked)){
2326 if($ev->isCancelled()){
2335 foreach($tx->getBlocks() as [$x, $y, $z, $_]){
2336 $tile = $this->getTileAt($x, $y, $z);
2339 $tile->copyDataFromItem($item);
2342 $placed = $this->getBlockAt($x, $y, $z);
2343 $placed->onPostPlace();
2344 if($first && $playSound){
2345 $this->addSound($placed->getPosition(),
new BlockPlaceSound($placed));
2355 public function getEntity(
int $entityId) : ?Entity{
2356 return $this->entities[$entityId] ?? null;
2366 return $this->entities;
2382 foreach($this->getNearbyEntities($bb, $entity) as $ent){
2383 if($ent->canBeCollidedWith() && ($entity ===
null || $entity->canCollideWith($ent))){
2400 $minX = ((int) floor($bb->minX - 2)) >> Chunk::COORD_BIT_SIZE;
2401 $maxX = ((int) floor($bb->maxX + 2)) >> Chunk::COORD_BIT_SIZE;
2402 $minZ = ((int) floor($bb->minZ - 2)) >> Chunk::COORD_BIT_SIZE;
2403 $maxZ = ((int) floor($bb->maxZ + 2)) >> Chunk::COORD_BIT_SIZE;
2405 for($x = $minX; $x <= $maxX; ++$x){
2406 for($z = $minZ; $z <= $maxZ; ++$z){
2407 foreach($this->getChunkEntities($x, $z) as $ent){
2408 if($ent !== $entity && $ent->boundingBox->intersectsWith($bb)){
2430 assert(is_a($entityType,
Entity::class, true));
2432 $minX = ((int) floor($pos->x - $maxDistance)) >> Chunk::COORD_BIT_SIZE;
2433 $maxX = ((int) floor($pos->x + $maxDistance)) >> Chunk::COORD_BIT_SIZE;
2434 $minZ = ((int) floor($pos->z - $maxDistance)) >> Chunk::COORD_BIT_SIZE;
2435 $maxZ = ((int) floor($pos->z + $maxDistance)) >> Chunk::COORD_BIT_SIZE;
2437 $currentTargetDistSq = $maxDistance ** 2;
2443 $currentTarget =
null;
2445 for($x = $minX; $x <= $maxX; ++$x){
2446 for($z = $minZ; $z <= $maxZ; ++$z){
2447 foreach($this->getChunkEntities($x, $z) as $entity){
2448 if(!($entity instanceof $entityType) || $entity->isFlaggedForDespawn() || (!$includeDead && !$entity->isAlive())){
2451 $distSq = $entity->getPosition()->distanceSquared($pos);
2452 if($distSq < $currentTargetDistSq){
2453 $currentTargetDistSq = $distSq;
2454 $currentTarget = $entity;
2460 return $currentTarget;
2470 return $this->players;
2480 return $this->getTileAt((int) floor($pos->x), (int) floor($pos->y), (int) floor($pos->z));
2487 return ($chunk = $this->loadChunk($x >>
Chunk::COORD_BIT_SIZE, $z >>
Chunk::COORD_BIT_SIZE)) !== null ? $chunk->getTile($x &
Chunk::COORD_MASK, $y, $z &
Chunk::COORD_MASK) : null;
2490 public function getBiomeId(
int $x,
int $y,
int $z) : int{
2491 if(($chunk = $this->loadChunk($x >>
Chunk::COORD_BIT_SIZE, $z >>
Chunk::COORD_BIT_SIZE)) !== null){
2492 return $chunk->getBiomeId($x & Chunk::COORD_MASK, $y & Chunk::COORD_MASK, $z & Chunk::COORD_MASK);
2494 return BiomeIds::OCEAN;
2497 public function getBiome(
int $x,
int $y,
int $z) : Biome{
2498 return BiomeRegistry::getInstance()->getBiome($this->getBiomeId($x, $y, $z));
2501 public function setBiomeId(
int $x,
int $y,
int $z,
int $biomeId) : void{
2502 $chunkX = $x >> Chunk::COORD_BIT_SIZE;
2503 $chunkZ = $z >> Chunk::COORD_BIT_SIZE;
2504 $this->unlockChunk($chunkX, $chunkZ,
null);
2505 if(($chunk = $this->loadChunk($chunkX, $chunkZ)) !==
null){
2506 $chunk->setBiomeId($x & Chunk::COORD_MASK, $y & Chunk::COORD_MASK, $z & Chunk::COORD_MASK, $biomeId);
2509 throw new WorldException(
"Cannot set biome in a non-generated chunk");
2518 return $this->chunks;
2521 public function getChunk(
int $chunkX,
int $chunkZ) : ?
Chunk{
2522 return $this->chunks[
World::chunkHash($chunkX, $chunkZ)] ?? null;
2530 return $this->entitiesByChunk[
World::chunkHash($chunkX, $chunkZ)] ?? [];
2537 return $this->loadChunk($pos->getFloorX() >>
Chunk::COORD_BIT_SIZE, $pos->getFloorZ() >>
Chunk::COORD_BIT_SIZE);
2548 for($xx = -1; $xx <= 1; ++$xx){
2549 for($zz = -1; $zz <= 1; ++$zz){
2550 if($xx === 0 && $zz === 0){
2553 $result[World::chunkHash($xx, $zz)] = $this->loadChunk($x + $xx, $z + $zz);
2575 $chunkHash =
World::chunkHash($chunkX, $chunkZ);
2576 if(isset($this->chunkLock[$chunkHash])){
2577 throw new \InvalidArgumentException(
"Chunk $chunkX $chunkZ is already locked");
2579 $this->chunkLock[$chunkHash] = $lockId;
2580 $this->markTickingChunkForRecheck($chunkX, $chunkZ);
2592 $chunkHash =
World::chunkHash($chunkX, $chunkZ);
2593 if(isset($this->chunkLock[$chunkHash]) && ($lockId ===
null || $this->chunkLock[$chunkHash] === $lockId)){
2594 unset($this->chunkLock[$chunkHash]);
2595 $this->markTickingChunkForRecheck($chunkX, $chunkZ);
2607 return isset($this->chunkLock[
World::chunkHash($chunkX, $chunkZ)]);
2610 public function setChunk(
int $chunkX,
int $chunkZ,
Chunk $chunk) : void{
2611 foreach($chunk->getSubChunks() as $subChunk){
2612 foreach($subChunk->getBlockLayers() as $blockLayer){
2613 foreach($blockLayer->getPalette() as $blockStateId){
2614 if(!$this->blockStateRegistry->hasStateId($blockStateId)){
2615 throw new \InvalidArgumentException(
"Provided chunk contains unknown/unregistered blocks (found unknown state ID $blockStateId)");
2621 $chunkHash = World::chunkHash($chunkX, $chunkZ);
2622 $oldChunk = $this->loadChunk($chunkX, $chunkZ);
2623 if($oldChunk !==
null && $oldChunk !== $chunk){
2625 $transferredTiles = 0;
2626 foreach($oldChunk->getTiles() as $oldTile){
2627 $tilePosition = $oldTile->getPosition();
2628 $localX = $tilePosition->getFloorX() & Chunk::COORD_MASK;
2629 $localY = $tilePosition->getFloorY();
2630 $localZ = $tilePosition->getFloorZ() & Chunk::COORD_MASK;
2632 $newBlock = $this->blockStateRegistry->fromStateId($chunk->getBlockStateId($localX, $localY, $localZ));
2633 $expectedTileClass = $newBlock->getIdInfo()->getTileClass();
2635 $expectedTileClass ===
null ||
2636 !($oldTile instanceof $expectedTileClass) ||
2637 (($newTile = $chunk->getTile($localX, $localY, $localZ)) !==
null && $newTile !== $oldTile)
2642 $transferredTiles++;
2643 $chunk->addTile($oldTile);
2644 $oldChunk->removeTile($oldTile);
2647 if($deletedTiles > 0 || $transferredTiles > 0){
2648 $this->logger->debug(
"Replacement of chunk $chunkX $chunkZ caused deletion of $deletedTiles obsolete/conflicted tiles, and transfer of $transferredTiles");
2652 $this->chunks[$chunkHash] = $chunk;
2653 unset($this->knownUngeneratedChunks[$chunkHash]);
2655 $this->blockCacheSize -= count($this->blockCache[$chunkHash] ?? []);
2656 unset($this->blockCache[$chunkHash]);
2657 unset($this->blockCollisionBoxCache[$chunkHash]);
2658 unset($this->changedBlocks[$chunkHash]);
2659 $chunk->setTerrainDirty();
2660 $this->markTickingChunkForRecheck($chunkX, $chunkZ);
2662 if(!$this->isChunkInUse($chunkX, $chunkZ)){
2663 $this->unloadChunkRequest($chunkX, $chunkZ);
2666 if($oldChunk ===
null){
2667 if(ChunkLoadEvent::hasHandlers()){
2668 (
new ChunkLoadEvent($this, $chunkX, $chunkZ, $chunk,
true))->call();
2671 foreach($this->getChunkListeners($chunkX, $chunkZ) as $listener){
2672 $listener->onChunkLoaded($chunkX, $chunkZ, $chunk);
2675 foreach($this->getChunkListeners($chunkX, $chunkZ) as $listener){
2676 $listener->onChunkChanged($chunkX, $chunkZ, $chunk);
2680 for($cX = -1; $cX <= 1; ++$cX){
2681 for($cZ = -1; $cZ <= 1; ++$cZ){
2682 foreach($this->getChunkEntities($chunkX + $cX, $chunkZ + $cZ) as $entity){
2683 $entity->onNearbyBlockChange();
2696 if(($chunk = $this->loadChunk($x >>
Chunk::COORD_BIT_SIZE, $z >>
Chunk::COORD_BIT_SIZE)) !== null){
2697 return $chunk->getHighestBlockAt($x & Chunk::COORD_MASK, $z & Chunk::COORD_MASK);
2699 throw new WorldException(
"Cannot get highest block in an ungenerated chunk");
2706 return $this->isChunkLoaded($pos->getFloorX() >>
Chunk::COORD_BIT_SIZE, $pos->getFloorZ() >>
Chunk::COORD_BIT_SIZE);
2709 public function isChunkLoaded(
int $x,
int $z) : bool{
2710 return isset($this->chunks[
World::chunkHash($x, $z)]);
2713 public function isChunkGenerated(
int $x,
int $z) : bool{
2714 return $this->loadChunk($x, $z) !== null;
2717 public function isChunkPopulated(
int $x,
int $z) : bool{
2718 $chunk = $this->loadChunk($x, $z);
2719 return $chunk !==
null && $chunk->isPopulated();
2726 return
Position::fromObject($this->provider->getWorldData()->getSpawn(), $this);
2733 $previousSpawn = $this->getSpawnLocation();
2734 $this->provider->getWorldData()->setSpawn($pos);
2737 $location = Position::fromObject($pos, $this);
2738 foreach($this->players as $player){
2739 $player->getNetworkSession()->syncWorldSpawnPoint($location);
2747 if($entity->isClosed()){
2748 throw new \InvalidArgumentException(
"Attempted to add a garbage closed Entity to world");
2750 if($entity->getWorld() !== $this){
2751 throw new \InvalidArgumentException(
"Invalid Entity world");
2753 if(array_key_exists($entity->getId(), $this->entities)){
2754 if($this->entities[$entity->getId()] === $entity){
2755 throw new \InvalidArgumentException(
"Entity " . $entity->getId() .
" has already been added to this world");
2757 throw new AssumptionFailedError(
"Found two different entities sharing entity ID " . $entity->getId());
2760 if(!EntityFactory::getInstance()->isRegistered($entity::class) && !$entity instanceof Player){
2763 throw new \LogicException(
"Entity " . $entity::class .
" is not registered for a save ID in EntityFactory");
2765 $pos = $entity->getPosition()->
asVector3();
2766 $this->entitiesByChunk[World::chunkHash($pos->getFloorX() >> Chunk::COORD_BIT_SIZE, $pos->getFloorZ() >> Chunk::COORD_BIT_SIZE)][$entity->getId()] = $entity;
2767 $this->entityLastKnownPositions[$entity->getId()] = $pos;
2769 if($entity instanceof Player){
2770 $this->players[$entity->getId()] = $entity;
2772 $this->entities[$entity->getId()] = $entity;
2781 if($entity->getWorld() !== $this){
2782 throw new \InvalidArgumentException(
"Invalid Entity world");
2784 if(!array_key_exists($entity->getId(), $this->entities)){
2785 throw new \InvalidArgumentException(
"Entity is not tracked by this world (possibly already removed?)");
2787 $pos = $this->entityLastKnownPositions[$entity->getId()];
2788 $chunkHash = World::chunkHash($pos->getFloorX() >> Chunk::COORD_BIT_SIZE, $pos->getFloorZ() >> Chunk::COORD_BIT_SIZE);
2789 if(isset($this->entitiesByChunk[$chunkHash][$entity->getId()])){
2790 if(count($this->entitiesByChunk[$chunkHash]) === 1){
2791 unset($this->entitiesByChunk[$chunkHash]);
2793 unset($this->entitiesByChunk[$chunkHash][$entity->getId()]);
2796 unset($this->entityLastKnownPositions[$entity->getId()]);
2798 if($entity instanceof Player){
2799 unset($this->players[$entity->getId()]);
2800 $this->checkSleep();
2803 unset($this->entities[$entity->getId()]);
2804 unset($this->updateEntities[$entity->getId()]);
2810 public function onEntityMoved(Entity $entity) : void{
2811 if(!array_key_exists($entity->getId(), $this->entityLastKnownPositions)){
2815 $oldPosition = $this->entityLastKnownPositions[$entity->getId()];
2816 $newPosition = $entity->getPosition();
2818 $oldChunkX = $oldPosition->getFloorX() >> Chunk::COORD_BIT_SIZE;
2819 $oldChunkZ = $oldPosition->getFloorZ() >> Chunk::COORD_BIT_SIZE;
2820 $newChunkX = $newPosition->getFloorX() >> Chunk::COORD_BIT_SIZE;
2821 $newChunkZ = $newPosition->getFloorZ() >> Chunk::COORD_BIT_SIZE;
2823 if($oldChunkX !== $newChunkX || $oldChunkZ !== $newChunkZ){
2824 $oldChunkHash = World::chunkHash($oldChunkX, $oldChunkZ);
2825 if(isset($this->entitiesByChunk[$oldChunkHash][$entity->getId()])){
2826 if(count($this->entitiesByChunk[$oldChunkHash]) === 1){
2827 unset($this->entitiesByChunk[$oldChunkHash]);
2829 unset($this->entitiesByChunk[$oldChunkHash][$entity->getId()]);
2833 $newViewers = $this->getViewersForPosition($newPosition);
2834 foreach($entity->getViewers() as $player){
2835 if(!isset($newViewers[spl_object_id($player)])){
2836 $entity->despawnFrom($player);
2838 unset($newViewers[spl_object_id($player)]);
2841 foreach($newViewers as $player){
2842 $entity->spawnTo($player);
2845 $newChunkHash = World::chunkHash($newChunkX, $newChunkZ);
2846 $this->entitiesByChunk[$newChunkHash][$entity->getId()] = $entity;
2848 $this->entityLastKnownPositions[$entity->getId()] = $newPosition->asVector3();
2855 public function addTile(Tile $tile) : void{
2856 if($tile->isClosed()){
2857 throw new \InvalidArgumentException(
"Attempted to add a garbage closed Tile to world");
2859 $pos = $tile->getPosition();
2860 if(!$pos->isValid() || $pos->getWorld() !== $this){
2861 throw new \InvalidArgumentException(
"Invalid Tile world");
2863 if(!$this->isInWorld($pos->getFloorX(), $pos->getFloorY(), $pos->getFloorZ())){
2864 throw new \InvalidArgumentException(
"Tile position is outside the world bounds");
2866 if(!TileFactory::getInstance()->isRegistered($tile::class)){
2867 throw new \LogicException(
"Tile " . $tile::class .
" is not registered for a save ID in TileFactory");
2870 $chunkX = $pos->getFloorX() >> Chunk::COORD_BIT_SIZE;
2871 $chunkZ = $pos->getFloorZ() >> Chunk::COORD_BIT_SIZE;
2873 if(isset($this->chunks[$hash = World::chunkHash($chunkX, $chunkZ)])){
2874 $this->chunks[$hash]->addTile($tile);
2876 throw new \InvalidArgumentException(
"Attempted to create tile " . get_class($tile) .
" in unloaded chunk $chunkX $chunkZ");
2880 $this->scheduleDelayedBlockUpdate($pos->
asVector3(), 1);
2887 public function removeTile(Tile $tile) : void{
2889 if(!$pos->isValid() || $pos->getWorld() !== $this){
2890 throw new \InvalidArgumentException(
"Invalid Tile world");
2893 $chunkX = $pos->getFloorX() >> Chunk::COORD_BIT_SIZE;
2894 $chunkZ = $pos->getFloorZ() >> Chunk::COORD_BIT_SIZE;
2896 if(isset($this->chunks[$hash = World::chunkHash($chunkX, $chunkZ)])){
2897 $this->chunks[$hash]->removeTile($tile);
2899 foreach($this->getChunkListeners($chunkX, $chunkZ) as $listener){
2900 $listener->onBlockChanged($pos->
asVector3());
2904 public function isChunkInUse(
int $x,
int $z) : bool{
2905 return isset($this->chunkLoaders[$index = World::chunkHash($x, $z)]) && count($this->chunkLoaders[$index]) > 0;
2915 if(isset($this->chunks[$chunkHash =
World::chunkHash($x, $z)])){
2916 return $this->chunks[$chunkHash];
2918 if(isset($this->knownUngeneratedChunks[$chunkHash])){
2922 $this->timings->syncChunkLoad->startTiming();
2924 $this->cancelUnloadChunkRequest($x, $z);
2926 $this->timings->syncChunkLoadData->startTiming();
2928 $loadedChunkData =
null;
2931 $loadedChunkData = $this->provider->loadChunk($x, $z);
2932 }
catch(CorruptedChunkException $e){
2933 $this->logger->critical(
"Failed to load chunk x=$x z=$z: " . $e->getMessage());
2936 $this->timings->syncChunkLoadData->stopTiming();
2938 if($loadedChunkData ===
null){
2939 $this->timings->syncChunkLoad->stopTiming();
2940 $this->knownUngeneratedChunks[$chunkHash] =
true;
2944 $chunkData = $loadedChunkData->getData();
2945 $chunk =
new Chunk($chunkData->getSubChunks(), $chunkData->isPopulated());
2946 if(!$loadedChunkData->isUpgraded()){
2947 $chunk->clearTerrainDirtyFlags();
2949 $this->logger->debug(
"Chunk $x $z has been upgraded, will be saved at the next autosave opportunity");
2951 $this->chunks[$chunkHash] = $chunk;
2953 $this->blockCacheSize -= count($this->blockCache[$chunkHash] ?? []);
2954 unset($this->blockCache[$chunkHash]);
2955 unset($this->blockCollisionBoxCache[$chunkHash]);
2957 $this->initChunk($x, $z, $chunkData, $chunk);
2959 if(ChunkLoadEvent::hasHandlers()){
2960 (
new ChunkLoadEvent($this, $x, $z, $this->chunks[$chunkHash],
false))->call();
2963 if(!$this->isChunkInUse($x, $z)){
2964 $this->logger->debug(
"Newly loaded chunk $x $z has no loaders registered, will be unloaded at next available opportunity");
2965 $this->unloadChunkRequest($x, $z);
2967 foreach($this->getChunkListeners($x, $z) as $listener){
2968 $listener->onChunkLoaded($x, $z, $this->chunks[$chunkHash]);
2970 $this->markTickingChunkForRecheck($x, $z);
2972 $this->timings->syncChunkLoad->stopTiming();
2974 return $this->chunks[$chunkHash];
2977 private function initChunk(
int $chunkX,
int $chunkZ, ChunkData $chunkData, Chunk $chunk) : void{
2978 $logger = new \
PrefixedLogger($this->logger,
"Loading chunk $chunkX $chunkZ");
2980 if(count($chunkData->getEntityNBT()) !== 0){
2981 $this->timings->syncChunkLoadEntities->startTiming();
2982 $entityFactory = EntityFactory::getInstance();
2984 $deletedEntities = [];
2985 foreach($chunkData->getEntityNBT() as $k => $nbt){
2987 $entity = $entityFactory->createFromData($this, $nbt);
2988 }catch(SavedDataLoadingException $e){
2989 $logger->error(
"Bad entity data at list position $k: " . $e->getMessage());
2990 $logger->logException($e);
2993 if($entity === null){
2994 $saveIdTag = $nbt->getTag(
"identifier") ?? $nbt->getTag(
"id");
2995 $saveId =
"<unknown>";
2996 if($saveIdTag instanceof StringTag){
2997 $saveId = $saveIdTag->getValue();
2998 }elseif($saveIdTag instanceof IntTag){
2999 $saveId =
"legacy(" . $saveIdTag->getValue() .
")";
3001 $deletedEntities[$saveId] = ($deletedEntities[$saveId] ?? 0) + 1;
3007 foreach(Utils::promoteKeys($deletedEntities) as $saveId => $count){
3008 $logger->warning(
"Deleted unknown entity type $saveId x$count");
3010 $this->timings->syncChunkLoadEntities->stopTiming();
3013 if(count($chunkData->getTileNBT()) !== 0){
3014 $this->timings->syncChunkLoadTileEntities->startTiming();
3015 $tileFactory = TileFactory::getInstance();
3018 foreach($chunkData->getTileNBT() as $k => $nbt){
3020 $tile = $tileFactory->createFromData($this, $nbt);
3021 }catch(SavedDataLoadingException $e){
3022 $logger->error(
"Bad tile entity data at list position $k: " . $e->getMessage());
3023 $logger->logException($e);
3027 $saveId = $nbt->getString(
"id",
"<unknown>");
3028 $deletedTiles[$saveId] = ($deletedTiles[$saveId] ?? 0) + 1;
3032 $tilePosition = $tile->getPosition();
3033 if(!$this->isChunkLoaded($tilePosition->getFloorX() >> Chunk::COORD_BIT_SIZE, $tilePosition->getFloorZ() >> Chunk::COORD_BIT_SIZE)){
3034 $logger->error(
"Found tile saved on wrong chunk - unable to fix due to correct chunk not loaded");
3035 }elseif(!$this->isInWorld($tilePosition->getFloorX(), $tilePosition->getFloorY(), $tilePosition->getFloorZ())){
3036 $logger->error(
"Cannot add tile with position outside the world bounds: x=$tilePosition->x,y=$tilePosition->y,z=$tilePosition->z");
3037 }elseif($this->getTile($tilePosition) !== null){
3038 $logger->error(
"Cannot add tile at x=$tilePosition->x,y=$tilePosition->y,z=$tilePosition->z: Another tile is already at that position");
3040 $this->addTile($tile);
3042 $expectedStateId = $chunk->getBlockStateId($tilePosition->getFloorX() & Chunk::COORD_MASK, $tilePosition->getFloorY(), $tilePosition->getFloorZ() & Chunk::COORD_MASK);
3043 $actualStateId = $this->getBlock($tilePosition)->getStateId();
3044 if($expectedStateId !== $actualStateId){
3049 $chunk->setBlockStateId($tilePosition->getFloorX() & Chunk::COORD_MASK, $tilePosition->getFloorY(), $tilePosition->getFloorZ() & Chunk::COORD_MASK, $actualStateId);
3050 $this->logger->debug(
"Tile " . $tile::class .
" at x=$tilePosition->x,y=$tilePosition->y,z=$tilePosition->z updated block state ID from $expectedStateId to $actualStateId");
3054 foreach(Utils::promoteKeys($deletedTiles) as $saveId => $count){
3055 $logger->warning(
"Deleted unknown tile entity type $saveId x$count");
3058 $this->timings->syncChunkLoadTileEntities->stopTiming();
3062 private function queueUnloadChunk(
int $x,
int $z) : void{
3063 $this->unloadQueue[World::chunkHash($x, $z)] = microtime(true);
3066 public function unloadChunkRequest(
int $x,
int $z,
bool $safe =
true) : bool{
3067 if(($safe && $this->isChunkInUse($x, $z)) || $this->isSpawnChunk($x, $z)){
3071 $this->queueUnloadChunk($x, $z);
3076 public function cancelUnloadChunkRequest(
int $x,
int $z) : void{
3077 unset($this->unloadQueue[World::chunkHash($x, $z)]);
3080 public function unloadChunk(
int $x,
int $z,
bool $safe =
true,
bool $trySave =
true) : bool{
3081 if($safe && $this->isChunkInUse($x, $z)){
3085 if(!$this->isChunkLoaded($x, $z)){
3089 $this->timings->doChunkUnload->startTiming();
3091 $chunkHash = World::chunkHash($x, $z);
3093 $chunk = $this->chunks[$chunkHash] ??
null;
3095 if($chunk !==
null){
3096 if(ChunkUnloadEvent::hasHandlers()){
3097 $ev =
new ChunkUnloadEvent($this, $x, $z, $chunk);
3099 if($ev->isCancelled()){
3100 $this->timings->doChunkUnload->stopTiming();
3106 if($trySave && $this->getAutoSave()){
3107 $this->timings->syncChunkSave->startTiming();
3109 $this->provider->saveChunk($x, $z,
new ChunkData(
3110 $chunk->getSubChunks(),
3111 $chunk->isPopulated(),
3112 array_map(fn(Entity $e) => $e->saveNBT(), array_values(array_filter($this->getChunkEntities($x, $z), fn(Entity $e) => $e->canSaveWithChunk()))),
3113 array_map(fn(Tile $t) => $t->saveNBT(), array_values($chunk->getTiles())),
3114 ), $chunk->getTerrainDirtyFlags());
3116 $this->timings->syncChunkSave->stopTiming();
3120 foreach($this->getChunkListeners($x, $z) as $listener){
3121 $listener->onChunkUnloaded($x, $z, $chunk);
3124 foreach($this->getChunkEntities($x, $z) as $entity){
3125 if($entity instanceof Player){
3134 unset($this->chunks[$chunkHash]);
3135 $this->blockCacheSize -= count($this->blockCache[$chunkHash] ?? []);
3136 unset($this->blockCache[$chunkHash]);
3137 unset($this->blockCollisionBoxCache[$chunkHash]);
3138 unset($this->changedBlocks[$chunkHash]);
3139 unset($this->registeredTickingChunks[$chunkHash]);
3140 $this->markTickingChunkForRecheck($x, $z);
3142 if(array_key_exists($chunkHash, $this->chunkPopulationRequestMap)){
3143 $this->logger->debug(
"Rejecting population promise for chunk $x $z");
3144 $this->chunkPopulationRequestMap[$chunkHash]->reject();
3145 unset($this->chunkPopulationRequestMap[$chunkHash]);
3146 if(isset($this->activeChunkPopulationTasks[$chunkHash])){
3147 $this->logger->debug(
"Marking population task for chunk $x $z as orphaned");
3148 $this->activeChunkPopulationTasks[$chunkHash] =
false;
3152 $this->timings->doChunkUnload->stopTiming();
3161 $spawn = $this->getSpawnLocation();
3162 $spawnX = $spawn->x >> Chunk::COORD_BIT_SIZE;
3163 $spawnZ = $spawn->z >> Chunk::COORD_BIT_SIZE;
3165 return abs($X - $spawnX) <= 1 && abs($Z - $spawnZ) <= 1;
3178 $spawn ??= $this->getSpawnLocation();
3183 $this->requestChunkPopulation($spawn->getFloorX() >> Chunk::COORD_BIT_SIZE, $spawn->getFloorZ() >> Chunk::COORD_BIT_SIZE,
null)->onCompletion(
3184 function() use ($spawn, $resolver) :
void{
3185 $spawn = $this->getSafeSpawn($spawn);
3186 $resolver->resolve($spawn);
3188 function() use ($resolver) : void{
3189 $resolver->reject();
3193 return $resolver->getPromise();
3203 if(!($spawn instanceof
Vector3) || $spawn->y <= $this->minY){
3204 $spawn = $this->getSpawnLocation();
3208 $v = $spawn->floor();
3209 $chunk = $this->getOrLoadChunkAtPosition($v);
3210 if($chunk ===
null){
3211 throw new WorldException(
"Cannot find a safe spawn point in non-generated terrain");
3215 $y = (int) min($max - 2, $v->y);
3216 $wasAir = $this->getBlockAt($x, $y - 1, $z)->getTypeId() === BlockTypeIds::AIR;
3217 for(; $y > $this->minY; --$y){
3218 if($this->getBlockAt($x, $y, $z)->isFullCube()){
3228 for(; $y >= $this->minY && $y < $max; ++$y){
3229 if(!$this->getBlockAt($x, $y + 1, $z)->isFullCube()){
3230 if(!$this->getBlockAt($x, $y, $z)->isFullCube()){
3231 return new Position($spawn->x, $y === (
int) $spawn->y ? $spawn->y : $y, $spawn->z, $this);
3238 return new Position($spawn->x, $y, $spawn->z, $this);
3252 return $this->time % self::TIME_FULL;
3260 return $this->displayName;
3269 $this->displayName = $name;
3270 $this->provider->getWorldData()->setName($name);
3277 return $this->folderName;
3284 $this->time = $time;
3292 $this->stopTime = true;
3300 $this->stopTime = false;
3308 return $this->provider->getWorldData()->getSeed();
3319 public function getDifficulty() : int{
3320 return $this->provider->getWorldData()->getDifficulty();
3323 public function setDifficulty(
int $difficulty) : void{
3324 if($difficulty < 0 || $difficulty > 3){
3325 throw new \InvalidArgumentException(
"Invalid difficulty level $difficulty");
3327 (
new WorldDifficultyChangeEvent($this, $this->getDifficulty(), $difficulty))->call();
3328 $this->provider->getWorldData()->setDifficulty($difficulty);
3330 foreach($this->players as $player){
3331 $player->getNetworkSession()->syncWorldDifficulty($this->getDifficulty());
3335 private function addChunkHashToPopulationRequestQueue(
int $chunkHash) : void{
3336 if(!isset($this->chunkPopulationRequestQueueIndex[$chunkHash])){
3337 $this->chunkPopulationRequestQueue->enqueue($chunkHash);
3338 $this->chunkPopulationRequestQueueIndex[$chunkHash] =
true;
3345 private function enqueuePopulationRequest(
int $chunkX,
int $chunkZ, ?ChunkLoader $associatedChunkLoader) : Promise{
3346 $chunkHash = World::chunkHash($chunkX, $chunkZ);
3347 $this->addChunkHashToPopulationRequestQueue($chunkHash);
3349 $resolver = $this->chunkPopulationRequestMap[$chunkHash] =
new PromiseResolver();
3350 if($associatedChunkLoader ===
null){
3351 $temporaryLoader =
new ChunkLoader();
3352 $this->registerChunkLoader($temporaryLoader, $chunkX, $chunkZ);
3353 $resolver->getPromise()->onCompletion(
3354 fn() => $this->unregisterChunkLoader($temporaryLoader, $chunkX, $chunkZ),
3355 static function() :
void{}
3358 return $resolver->getPromise();
3361 private function drainPopulationRequestQueue() : void{
3363 while(count($this->activeChunkPopulationTasks) < $this->maxConcurrentChunkPopulationTasks && !$this->chunkPopulationRequestQueue->isEmpty()){
3364 $nextChunkHash = $this->chunkPopulationRequestQueue->dequeue();
3365 unset($this->chunkPopulationRequestQueueIndex[$nextChunkHash]);
3366 World::getXZ($nextChunkHash, $nextChunkX, $nextChunkZ);
3367 if(isset($this->chunkPopulationRequestMap[$nextChunkHash])){
3368 assert(!($this->activeChunkPopulationTasks[$nextChunkHash] ??
false),
"Population for chunk $nextChunkX $nextChunkZ already running");
3370 !$this->orderChunkPopulation($nextChunkX, $nextChunkZ,
null)->isResolved() &&
3371 !isset($this->activeChunkPopulationTasks[$nextChunkHash])
3373 $failed[] = $nextChunkHash;
3380 foreach($failed as $hash){
3381 $this->addChunkHashToPopulationRequestQueue($hash);
3390 private function checkChunkPopulationPreconditions(
int $chunkX,
int $chunkZ) : array{
3391 $chunkHash = World::chunkHash($chunkX, $chunkZ);
3392 $resolver = $this->chunkPopulationRequestMap[$chunkHash] ??
null;
3393 if($resolver !==
null && isset($this->activeChunkPopulationTasks[$chunkHash])){
3395 return [$resolver,
false];
3398 $temporaryChunkLoader =
new ChunkLoader();
3399 $this->registerChunkLoader($temporaryChunkLoader, $chunkX, $chunkZ);
3400 $chunk = $this->loadChunk($chunkX, $chunkZ);
3401 $this->unregisterChunkLoader($temporaryChunkLoader, $chunkX, $chunkZ);
3402 if($chunk !==
null && $chunk->isPopulated()){
3404 $resolver ??=
new PromiseResolver();
3405 unset($this->chunkPopulationRequestMap[$chunkHash]);
3406 $resolver->resolve($chunk);
3407 return [$resolver,
false];
3409 return [$resolver,
true];
3424 [$resolver, $proceedWithPopulation] = $this->checkChunkPopulationPreconditions($chunkX, $chunkZ);
3425 if(!$proceedWithPopulation){
3426 return $resolver?->getPromise() ?? $this->enqueuePopulationRequest($chunkX, $chunkZ, $associatedChunkLoader);
3429 if(count($this->activeChunkPopulationTasks) >= $this->maxConcurrentChunkPopulationTasks){
3431 return $resolver?->getPromise() ?? $this->enqueuePopulationRequest($chunkX, $chunkZ, $associatedChunkLoader);
3433 return $this->internalOrderChunkPopulation($chunkX, $chunkZ, $associatedChunkLoader, $resolver);
3447 [$resolver, $proceedWithPopulation] = $this->checkChunkPopulationPreconditions($chunkX, $chunkZ);
3448 if(!$proceedWithPopulation){
3449 return $resolver?->getPromise() ?? $this->enqueuePopulationRequest($chunkX, $chunkZ, $associatedChunkLoader);
3452 return $this->internalOrderChunkPopulation($chunkX, $chunkZ, $associatedChunkLoader, $resolver);
3459 private function internalOrderChunkPopulation(
int $chunkX,
int $chunkZ, ?ChunkLoader $associatedChunkLoader, ?
PromiseResolver $resolver) :
Promise{
3460 $chunkHash =
World::chunkHash($chunkX, $chunkZ);
3462 $timings = $this->timings->chunkPopulationOrder;
3463 $timings->startTiming();
3466 for($xx = -1; $xx <= 1; ++$xx){
3467 for($zz = -1; $zz <= 1; ++$zz){
3468 if($this->isChunkLocked($chunkX + $xx, $chunkZ + $zz)){
3470 return $resolver?->
getPromise() ?? $this->enqueuePopulationRequest($chunkX, $chunkZ, $associatedChunkLoader);
3475 $this->activeChunkPopulationTasks[$chunkHash] =
true;
3476 if($resolver ===
null){
3477 $resolver =
new PromiseResolver();
3478 $this->chunkPopulationRequestMap[$chunkHash] = $resolver;
3481 $chunkPopulationLockId =
new ChunkLockId();
3483 $temporaryChunkLoader =
new ChunkLoader();
3484 for($xx = -1; $xx <= 1; ++$xx){
3485 for($zz = -1; $zz <= 1; ++$zz){
3486 $this->lockChunk($chunkX + $xx, $chunkZ + $zz, $chunkPopulationLockId);
3487 $this->registerChunkLoader($temporaryChunkLoader, $chunkX + $xx, $chunkZ + $zz);
3491 $centerChunk = $this->loadChunk($chunkX, $chunkZ);
3492 $adjacentChunks = $this->getAdjacentChunks($chunkX, $chunkZ);
3494 $this->generatorExecutor->populate(
3499 function(Chunk $centerChunk, array $adjacentChunks) use ($chunkPopulationLockId, $chunkX, $chunkZ, $temporaryChunkLoader) :
void{
3500 if(!$this->isLoaded()){
3504 $this->generateChunkCallback($chunkPopulationLockId, $chunkX, $chunkZ, $centerChunk, $adjacentChunks, $temporaryChunkLoader);
3510 $timings->stopTiming();
3518 private function generateChunkCallback(ChunkLockId $chunkLockId,
int $x,
int $z, Chunk $chunk, array $adjacentChunks, ChunkLoader $temporaryChunkLoader) : void{
3519 $timings = $this->timings->chunkPopulationCompletion;
3520 $timings->startTiming();
3523 for($xx = -1; $xx <= 1; ++$xx){
3524 for($zz = -1; $zz <= 1; ++$zz){
3525 $this->unregisterChunkLoader($temporaryChunkLoader, $x + $xx, $z + $zz);
3526 if(!$this->unlockChunk($x + $xx, $z + $zz, $chunkLockId)){
3532 $index = World::chunkHash($x, $z);
3533 if(!isset($this->activeChunkPopulationTasks[$index])){
3534 throw new AssumptionFailedError(
"This should always be set, regardless of whether the task was orphaned or not");
3536 if(!$this->activeChunkPopulationTasks[$index]){
3537 $this->logger->debug(
"Discarding orphaned population result for chunk x=$x,z=$z");
3538 unset($this->activeChunkPopulationTasks[$index]);
3540 if($dirtyChunks === 0){
3541 $oldChunk = $this->loadChunk($x, $z);
3542 $this->setChunk($x, $z, $chunk);
3544 foreach($adjacentChunks as $relativeChunkHash => $adjacentChunk){
3545 World::getXZ($relativeChunkHash, $relativeX, $relativeZ);
3546 if($relativeX < -1 || $relativeX > 1 || $relativeZ < -1 || $relativeZ > 1){
3547 throw new AssumptionFailedError(
"Adjacent chunks should be in range -1 ... +1 coordinates");
3549 $this->setChunk($x + $relativeX, $z + $relativeZ, $adjacentChunk);
3552 if(($oldChunk ===
null || !$oldChunk->isPopulated()) && $chunk->isPopulated()){
3553 if(ChunkPopulateEvent::hasHandlers()){
3554 (
new ChunkPopulateEvent($this, $x, $z, $chunk))->call();
3557 foreach($this->getChunkListeners($x, $z) as $listener){
3558 $listener->onChunkPopulated($x, $z, $chunk);
3562 $this->logger->debug(
"Discarding population result for chunk x=$x,z=$z - terrain was modified on the main thread before async population completed");
3571 unset($this->activeChunkPopulationTasks[$index]);
3573 if($dirtyChunks === 0){
3574 $promise = $this->chunkPopulationRequestMap[$index] ??
null;
3575 if($promise !==
null){
3576 unset($this->chunkPopulationRequestMap[$index]);
3577 $promise->resolve($chunk);
3580 $this->logger->debug(
"Unable to resolve population promise for chunk x=$x,z=$z - populated chunk was forcibly unloaded while setting modified chunks");
3586 $this->addChunkHashToPopulationRequestQueue($index);
3589 $this->drainPopulationRequestQueue();
3591 $timings->stopTiming();
3594 public function doChunkGarbageCollection() : void{
3595 $this->timings->doChunkGC->startTiming();
3597 foreach($this->chunks as $index => $chunk){
3598 if(!isset($this->unloadQueue[$index])){
3599 World::getXZ($index, $X, $Z);
3600 if(!$this->isSpawnChunk($X, $Z)){
3601 $this->unloadChunkRequest($X, $Z,
true);
3604 $chunk->collectGarbage();
3607 $this->provider->doGarbageCollection();
3609 $this->timings->doChunkGC->stopTiming();
3612 public function unloadChunks(
bool $force =
false) : void{
3613 if(count($this->unloadQueue) > 0){
3615 $now = microtime(
true);
3616 foreach($this->unloadQueue as $index => $time){
3617 World::getXZ($index, $X, $Z);
3620 if($maxUnload <= 0){
3622 }elseif($time > ($now - 30)){
3628 if($this->unloadChunk($X, $Z,
true)){
3629 unset($this->unloadQueue[$index]);