Player.php

<?php
 
/*
 *
 *  ____            _        _   __  __ _                  __  __ ____
 * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \
 * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
 * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/
 * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_|
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * @author PocketMine Team
 * @link http://www.pocketmine.net/
 *
 *
 */
 
declare(strict_types=1);
 
namespace pocketmine\player;
 
use DateTimeImmutable;
use pocketmine\block\BaseSign;
use pocketmine\block\Bed;
use pocketmine\block\BlockTypeTags;
use pocketmine\block\RespawnAnchor;
use pocketmine\block\UnknownBlock;
use pocketmine\block\VanillaBlocks;
use pocketmine\command\CommandSender;
use pocketmine\crafting\CraftingGrid;
use pocketmine\data\java\GameModeIdMap;
use pocketmine\entity\animation\Animation;
use pocketmine\entity\animation\ArmSwingAnimation;
use pocketmine\entity\animation\CriticalHitAnimation;
use pocketmine\entity\Attribute;
use pocketmine\entity\effect\VanillaEffects;
use pocketmine\entity\Entity;
use pocketmine\entity\Human;
use pocketmine\entity\Living;
use pocketmine\entity\Location;
use pocketmine\entity\NeverSavedWithChunkEntity;
use pocketmine\entity\object\ItemEntity;
use pocketmine\entity\projectile\Arrow;
use pocketmine\entity\Skin;
use pocketmine\event\entity\EntityDamageByEntityEvent;
use pocketmine\event\entity\EntityDamageEvent;
use pocketmine\event\entity\EntityExhaustEvent;
use pocketmine\event\entity\EntityExtinguishEvent;
use pocketmine\event\inventory\InventoryCloseEvent;
use pocketmine\event\inventory\InventoryOpenEvent;
use pocketmine\event\player\PlayerBedEnterEvent;
use pocketmine\event\player\PlayerBedLeaveEvent;
use pocketmine\event\player\PlayerBlockPickEvent;
use pocketmine\event\player\PlayerChangeSkinEvent;
use pocketmine\event\player\PlayerChatEvent;
use pocketmine\event\player\PlayerDeathEvent;
use pocketmine\event\player\PlayerDisplayNameChangeEvent;
use pocketmine\event\player\PlayerDropItemEvent;
use pocketmine\event\player\PlayerEmoteEvent;
use pocketmine\event\player\PlayerEntityInteractEvent;
use pocketmine\event\player\PlayerEntityPickEvent;
use pocketmine\event\player\PlayerGameModeChangeEvent;
use pocketmine\event\player\PlayerInteractEvent;
use pocketmine\event\player\PlayerItemConsumeEvent;
use pocketmine\event\player\PlayerItemHeldEvent;
use pocketmine\event\player\PlayerItemUseEvent;
use pocketmine\event\player\PlayerJoinEvent;
use pocketmine\event\player\PlayerJumpEvent;
use pocketmine\event\player\PlayerKickEvent;
use pocketmine\event\player\PlayerMissSwingEvent;
use pocketmine\event\player\PlayerMoveEvent;
use pocketmine\event\player\PlayerPostChunkSendEvent;
use pocketmine\event\player\PlayerQuitEvent;
use pocketmine\event\player\PlayerRespawnEvent;
use pocketmine\event\player\PlayerToggleFlightEvent;
use pocketmine\event\player\PlayerToggleGlideEvent;
use pocketmine\event\player\PlayerToggleSneakEvent;
use pocketmine\event\player\PlayerToggleSprintEvent;
use pocketmine\event\player\PlayerToggleSwimEvent;
use pocketmine\event\player\PlayerTransferEvent;
use pocketmine\event\player\PlayerViewDistanceChangeEvent;
use pocketmine\form\Form;
use pocketmine\form\FormValidationException;
use pocketmine\inventory\CallbackInventoryListener;
use pocketmine\inventory\CreativeInventory;
use pocketmine\inventory\Inventory;
use pocketmine\inventory\SimpleInventory;
use pocketmine\inventory\transaction\action\DropItemAction;
use pocketmine\inventory\transaction\InventoryTransaction;
use pocketmine\inventory\transaction\TransactionBuilder;
use pocketmine\inventory\transaction\TransactionCancelledException;
use pocketmine\inventory\transaction\TransactionValidationException;
use pocketmine\item\ConsumableItem;
use pocketmine\item\Durable;
use pocketmine\item\enchantment\EnchantmentInstance;
use pocketmine\item\enchantment\MeleeWeaponEnchantment;
use pocketmine\item\Item;
use pocketmine\item\ItemUseResult;
use pocketmine\item\Releasable;
use pocketmine\lang\KnownTranslationFactory;
use pocketmine\lang\Language;
use pocketmine\lang\Translatable;
use pocketmine\math\AxisAlignedBB;
use pocketmine\math\Facing;
use pocketmine\math\Vector3;
use pocketmine\nbt\tag\CompoundTag;
use pocketmine\nbt\tag\IntTag;
use pocketmine\network\mcpe\NetworkSession;
use pocketmine\network\mcpe\protocol\AnimatePacket;
use pocketmine\network\mcpe\protocol\MovePlayerPacket;
use pocketmine\network\mcpe\protocol\SetActorMotionPacket;
use pocketmine\network\mcpe\protocol\types\BlockPosition;
use pocketmine\network\mcpe\protocol\types\DimensionIds;
use pocketmine\network\mcpe\protocol\types\entity\EntityMetadataCollection;
use pocketmine\network\mcpe\protocol\types\entity\EntityMetadataFlags;
use pocketmine\network\mcpe\protocol\types\entity\EntityMetadataProperties;
use pocketmine\network\mcpe\protocol\types\entity\PlayerMetadataFlags;
use pocketmine\permission\DefaultPermissionNames;
use pocketmine\permission\DefaultPermissions;
use pocketmine\permission\PermissibleBase;
use pocketmine\permission\PermissibleDelegateTrait;
use pocketmine\player\chat\StandardChatFormatter;
use pocketmine\Server;
use pocketmine\ServerProperties;
use pocketmine\timings\Timings;
use pocketmine\utils\AssumptionFailedError;
use pocketmine\utils\TextFormat;
use pocketmine\world\ChunkListener;
use pocketmine\world\ChunkListenerNoOpTrait;
use pocketmine\world\ChunkLoader;
use pocketmine\world\ChunkTicker;
use pocketmine\world\format\Chunk;
use pocketmine\world\Position;
use pocketmine\world\sound\EntityAttackNoDamageSound;
use pocketmine\world\sound\EntityAttackSound;
use pocketmine\world\sound\FireExtinguishSound;
use pocketmine\world\sound\ItemBreakSound;
use pocketmine\world\sound\RespawnAnchorDepleteSound;
use pocketmine\world\sound\Sound;
use pocketmine\world\World;
use pocketmine\YmlServerProperties;
use Ramsey\Uuid\UuidInterface;
use function abs;
use function array_filter;
use function array_shift;
use function assert;
use function count;
use function explode;
use function floor;
use function get_class;
use function max;
use function mb_strlen;
use function microtime;
use function min;
use function preg_match;
use function spl_object_id;
use function sqrt;
use function str_starts_with;
use function strlen;
use function strtolower;
use function substr;
use function trim;
use const M_PI;
use const M_SQRT3;
use const PHP_INT_MAX;
 
class Player extends Human implements CommandSender, ChunkListener, IPlayer, NeverSavedWithChunkEntity{
    use PermissibleDelegateTrait;
 
    private const MOVES_PER_TICK = 2;
    private const MOVE_BACKLOG_SIZE = 100 * self::MOVES_PER_TICK; //100 ticks backlog (5 seconds)
 
    private const MAX_CHAT_CHAR_LENGTH = 512;
    private const MAX_CHAT_BYTE_LENGTH = self::MAX_CHAT_CHAR_LENGTH * 4;
    private const MAX_REACH_DISTANCE_CREATIVE = 13;
    private const MAX_REACH_DISTANCE_SURVIVAL = 7;
    private const MAX_REACH_DISTANCE_ENTITY_INTERACTION = 8;
 
    public const DEFAULT_FLIGHT_SPEED_MULTIPLIER = 0.05;
 
    public const TAG_FIRST_PLAYED = "firstPlayed"; //TAG_Long
    public const TAG_LAST_PLAYED = "lastPlayed"; //TAG_Long
    private const TAG_GAME_MODE = "playerGameType"; //TAG_Int
    private const TAG_SPAWN_WORLD = "SpawnLevel"; //TAG_String
    private const TAG_SPAWN_X = "SpawnX"; //TAG_Int
    private const TAG_SPAWN_Y = "SpawnY"; //TAG_Int
    private const TAG_SPAWN_Z = "SpawnZ"; //TAG_Int
    private const TAG_DEATH_WORLD = "DeathLevel"; //TAG_String
    private const TAG_DEATH_X = "DeathPositionX"; //TAG_Int
    private const TAG_DEATH_Y = "DeathPositionY"; //TAG_Int
    private const TAG_DEATH_Z = "DeathPositionZ"; //TAG_Int
    public const TAG_LEVEL = "Level"; //TAG_String
    public const TAG_LAST_KNOWN_XUID = "LastKnownXUID"; //TAG_String
 
    public static function isValidUserName(?string $name) : bool{
        if($name === null){
            return false;
        }
 
        $lname = strtolower($name);
        $len = strlen($name);
        return $lname !== "rcon" && $lname !== "console" && $len >= 1 && $len <= 16 && preg_match("/[^A-Za-z0-9_ ]/", $name) === 0;
    }
 
    protected ?NetworkSession $networkSession;
 
    public bool $spawned = false;
 
    protected string $username;
    protected string $displayName;
    protected string $xuid = "";
    protected bool $authenticated;
    protected PlayerInfo $playerInfo;
 
    protected ?InventoryWindow $currentWindow = null;
    protected array $permanentWindows = [];
    protected Inventory $cursorInventory;
    protected CraftingGrid $craftingGrid;
    protected CreativeInventory $creativeInventory;
 
    protected int $messageCounter = 2;
 
    protected DateTimeImmutable $firstPlayed;
    protected DateTimeImmutable $lastPlayed;
    protected GameMode $gamemode;
 
    protected array $usedChunks = [];
    private array $activeChunkGenerationRequests = [];
    protected array $loadQueue = [];
    protected int $nextChunkOrderRun = 5;
 
    private array $tickingChunks = [];
 
    protected int $viewDistance = -1;
    protected int $spawnThreshold;
    protected int $spawnChunkLoadCount = 0;
    protected int $chunksPerTick;
    protected ChunkSelector $chunkSelector;
    protected ChunkLoader $chunkLoader;
    protected ChunkTicker $chunkTicker;
 
    protected array $hiddenPlayers = [];
 
    protected float $moveRateLimit = 10 * self::MOVES_PER_TICK;
    protected ?float $lastMovementProcess = null;
 
    protected int $inAirTicks = 0;
 
    protected float $stepHeight = 0.6;
 
    protected ?Vector3 $sleeping = null;
    private ?Position $spawnPosition = null;
 
    private bool $respawnLocked = false;
 
    private ?Position $deathPosition = null;
 
    //TODO: Abilities
    protected bool $autoJump = true;
    protected bool $allowFlight = false;
    protected bool $blockCollision = true;
    protected bool $flying = false;
 
    protected float $flightSpeedMultiplier = self::DEFAULT_FLIGHT_SPEED_MULTIPLIER;
 
    protected ?int $lineHeight = null;
    protected string $locale = "en_US";
 
    protected int $startAction = -1;
 
    protected array $usedItemsCooldown = [];
 
    private int $lastEmoteTick = 0;
 
    protected int $formIdCounter = 0;
    protected array $forms = [];
 
    protected \Logger $logger;
 
    protected ?SurvivalBlockBreakHandler $blockBreakHandler = null;
 
    public function __construct(Server $server, NetworkSession $session, PlayerInfo $playerInfo, bool $authenticated, Location $spawnLocation, ?CompoundTag $namedtag){
        $username = TextFormat::clean($playerInfo->getUsername());
        $this->logger = new \PrefixedLogger($server->getLogger(), "Player: $username");
 
        $this->server = $server;
        $this->networkSession = $session;
        $this->playerInfo = $playerInfo;
        $this->authenticated = $authenticated;
 
        $this->username = $username;
        $this->displayName = $this->username;
        $this->locale = $this->playerInfo->getLocale();
 
        $this->uuid = $this->playerInfo->getUuid();
        $this->xuid = $this->playerInfo instanceof XboxLivePlayerInfo ? $this->playerInfo->getXuid() : "";
 
        $this->creativeInventory = CreativeInventory::getInstance();
 
        $rootPermissions = [DefaultPermissions::ROOT_USER => true];
        if($this->server->isOp($this->username)){
            $rootPermissions[DefaultPermissions::ROOT_OPERATOR] = true;
        }
        $this->perm = new PermissibleBase($rootPermissions);
        $this->chunksPerTick = $this->server->getConfigGroup()->getPropertyInt(YmlServerProperties::CHUNK_SENDING_PER_TICK, 4);
        $this->spawnThreshold = (int) (($this->server->getConfigGroup()->getPropertyInt(YmlServerProperties::CHUNK_SENDING_SPAWN_RADIUS, 4) ** 2) * M_PI);
        $this->chunkSelector = new ChunkSelector();
 
        $this->chunkLoader = new ChunkLoader();
        $this->chunkTicker = new ChunkTicker();
        $world = $spawnLocation->getWorld();
        //load the spawn chunk so we can see the terrain
        $xSpawnChunk = $spawnLocation->getFloorX() >> Chunk::COORD_BIT_SIZE;
        $zSpawnChunk = $spawnLocation->getFloorZ() >> Chunk::COORD_BIT_SIZE;
        $world->registerChunkLoader($this->chunkLoader, $xSpawnChunk, $zSpawnChunk, true);
        $world->registerChunkListener($this, $xSpawnChunk, $zSpawnChunk);
        $this->usedChunks[World::chunkHash($xSpawnChunk, $zSpawnChunk)] = UsedChunkStatus::NEEDED;
 
        parent::__construct($spawnLocation, $this->playerInfo->getSkin(), $namedtag);
    }
 
    protected function initHumanData(CompoundTag $nbt) : void{
        $this->setNameTag($this->username);
    }
 
    private function callDummyItemHeldEvent() : void{
        $slot = $this->hotbar->getSelectedIndex();
 
        $event = new PlayerItemHeldEvent($this, $this->inventory->getItem($slot), $slot);
        $event->call();
        //TODO: this event is actually cancellable, but cancelling it here has no meaningful result, so we
        //just ignore it. We fire this only because the content of the held slot changed, not because the
        //held slot index changed. We can't prevent that from here, and nor would it be sensible to.
    }
 
    protected function initEntity(CompoundTag $nbt) : void{
        parent::initEntity($nbt);
        $this->addDefaultWindows();
 
        $this->inventory->getListeners()->add(new CallbackInventoryListener(
            function(Inventory $unused, int $slot) : void{
                if($slot === $this->hotbar->getSelectedIndex()){
                    $this->setUsingItem(false);
 
                    $this->callDummyItemHeldEvent();
                }
            },
            function() : void{
                $this->setUsingItem(false);
                $this->callDummyItemHeldEvent();
            }
        ));
 
        $now = (int) (microtime(true) * 1000);
        $createDateTimeImmutable = static function(string $tag) use ($nbt, $now) : DateTimeImmutable{
            return new DateTimeImmutable('@' . $nbt->getLong($tag, $now) / 1000);
        };
        $this->firstPlayed = $createDateTimeImmutable(self::TAG_FIRST_PLAYED);
        $this->lastPlayed = $createDateTimeImmutable(self::TAG_LAST_PLAYED);
 
        if(!$this->server->getForceGamemode() && ($gameModeTag = $nbt->getTag(self::TAG_GAME_MODE)) instanceof IntTag){
            $this->internalSetGameMode(GameModeIdMap::getInstance()->fromId($gameModeTag->getValue()) ?? GameMode::SURVIVAL); //TODO: bad hack here to avoid crashes on corrupted data
        }else{
            $this->internalSetGameMode($this->server->getGamemode());
        }
 
        $this->keepMovement = true;
 
        $this->setNameTagVisible();
        $this->setNameTagAlwaysVisible();
        $this->setCanClimb();
 
        if(($world = $this->server->getWorldManager()->getWorldByName($nbt->getString(self::TAG_SPAWN_WORLD, ""))) instanceof World){
            $this->spawnPosition = new Position($nbt->getInt(self::TAG_SPAWN_X), $nbt->getInt(self::TAG_SPAWN_Y), $nbt->getInt(self::TAG_SPAWN_Z), $world);
        }
        if(($world = $this->server->getWorldManager()->getWorldByName($nbt->getString(self::TAG_DEATH_WORLD, ""))) instanceof World){
            $this->deathPosition = new Position($nbt->getInt(self::TAG_DEATH_X), $nbt->getInt(self::TAG_DEATH_Y), $nbt->getInt(self::TAG_DEATH_Z), $world);
        }
    }
 
    public function getLeaveMessage() : Translatable|string{
        if($this->spawned){
            return KnownTranslationFactory::multiplayer_player_left($this->getDisplayName())->prefix(TextFormat::YELLOW);
        }
 
        return "";
    }
 
    public function isAuthenticated() : bool{
        return $this->authenticated;
    }
 
    public function getPlayerInfo() : PlayerInfo{ return $this->playerInfo; }
 
    public function getXuid() : string{
        return $this->xuid;
    }
 
    public function getUniqueId() : UuidInterface{
        return parent::getUniqueId();
    }
 
    public function getFirstPlayed() : ?DateTimeImmutable{
        return $this->firstPlayed;
    }
 
    public function getLastPlayed() : ?DateTimeImmutable{
        return $this->lastPlayed;
    }
 
    public function hasPlayedBefore() : bool{
        return ((int) $this->firstPlayed->diff($this->lastPlayed)->format('%s')) > 1;
    }
 
    public function setAllowFlight(bool $value) : void{
        if($this->allowFlight !== $value){
            $this->allowFlight = $value;
            $this->getNetworkSession()->syncAbilities($this);
        }
    }
 
    public function getAllowFlight() : bool{
        return $this->allowFlight;
    }
 
    public function setHasBlockCollision(bool $value) : void{
        if($this->blockCollision !== $value){
            $this->blockCollision = $value;
            $this->getNetworkSession()->syncAbilities($this);
        }
    }
 
    public function hasBlockCollision() : bool{
        return $this->blockCollision;
    }
 
    public function setFlying(bool $value) : void{
        if($this->flying !== $value){
            $this->flying = $value;
            $this->resetFallDistance();
            $this->getNetworkSession()->syncAbilities($this);
        }
    }
 
    public function isFlying() : bool{
        return $this->flying;
    }
 
    public function setFlightSpeedMultiplier(float $flightSpeedMultiplier) : void{
        if($this->flightSpeedMultiplier !== $flightSpeedMultiplier){
            $this->flightSpeedMultiplier = $flightSpeedMultiplier;
            $this->getNetworkSession()->syncAbilities($this);
        }
    }
 
    public function getFlightSpeedMultiplier() : float{
        return $this->flightSpeedMultiplier;
    }
 
    public function setAutoJump(bool $value) : void{
        if($this->autoJump !== $value){
            $this->autoJump = $value;
            $this->getNetworkSession()->syncAdventureSettings();
        }
    }
 
    public function hasAutoJump() : bool{
        return $this->autoJump;
    }
 
    public function spawnTo(Player $player) : void{
        if($this->isAlive() && $player->isAlive() && $player->canSee($this) && !$this->isSpectator()){
            parent::spawnTo($player);
        }
    }
 
    public function getServer() : Server{
        return $this->server;
    }
 
    public function getScreenLineHeight() : int{
        return $this->lineHeight ?? 7;
    }
 
    public function setScreenLineHeight(?int $height) : void{
        if($height !== null && $height < 1){
            throw new \InvalidArgumentException("Line height must be at least 1");
        }
        $this->lineHeight = $height;
    }
 
    public function canSee(Player $player) : bool{
        return !isset($this->hiddenPlayers[$player->getUniqueId()->getBytes()]);
    }
 
    public function hidePlayer(Player $player) : void{
        if($player === $this){
            return;
        }
        $this->hiddenPlayers[$player->getUniqueId()->getBytes()] = true;
        $player->despawnFrom($this);
    }
 
    public function showPlayer(Player $player) : void{
        if($player === $this){
            return;
        }
        unset($this->hiddenPlayers[$player->getUniqueId()->getBytes()]);
        if($player->isOnline()){
            $player->spawnTo($this);
        }
    }
 
    public function canCollideWith(Entity $entity) : bool{
        return false;
    }
 
    public function canBeCollidedWith() : bool{
        return !$this->isSpectator() && parent::canBeCollidedWith();
    }
 
    public function resetFallDistance() : void{
        parent::resetFallDistance();
        $this->inAirTicks = 0;
    }
 
    public function getViewDistance() : int{
        return $this->viewDistance;
    }
 
    public function setViewDistance(int $distance) : void{
        $newViewDistance = $this->server->getAllowedViewDistance($distance);
 
        if($newViewDistance !== $this->viewDistance){
            $ev = new PlayerViewDistanceChangeEvent($this, $this->viewDistance, $newViewDistance);
            $ev->call();
        }
 
        $this->viewDistance = $newViewDistance;
 
        $this->spawnThreshold = (int) (min($this->viewDistance, $this->server->getConfigGroup()->getPropertyInt(YmlServerProperties::CHUNK_SENDING_SPAWN_RADIUS, 4)) ** 2 * M_PI);
 
        $this->nextChunkOrderRun = 0;
 
        $this->getNetworkSession()->syncViewAreaRadius($this->viewDistance);
 
        $this->logger->debug("Setting view distance to " . $this->viewDistance . " (requested " . $distance . ")");
    }
 
    public function isOnline() : bool{
        return $this->isConnected();
    }
 
    public function isConnected() : bool{
        return $this->networkSession !== null && $this->networkSession->isConnected();
    }
 
    public function getNetworkSession() : NetworkSession{
        if($this->networkSession === null){
            throw new \LogicException("Player is not connected");
        }
        return $this->networkSession;
    }
 
    public function getName() : string{
        return $this->username;
    }
 
    public function getDisplayName() : string{
        return $this->displayName;
    }
 
    public function setDisplayName(string $name) : void{
        $ev = new PlayerDisplayNameChangeEvent($this, $this->displayName, $name);
        $ev->call();
 
        $this->displayName = $ev->getNewName();
    }
 
    public function canBeRenamed() : bool{
        return false;
    }
 
    public function getLocale() : string{
        return $this->locale;
    }
 
    public function getLanguage() : Language{
        return $this->server->getLanguage();
    }
 
    public function changeSkin(Skin $skin, string $newSkinName, string $oldSkinName) : bool{
        $ev = new PlayerChangeSkinEvent($this, $this->getSkin(), $skin);
        $ev->call();
 
        if($ev->isCancelled()){
            $this->sendSkin([$this]);
            return true;
        }
 
        $this->setSkin($ev->getNewSkin());
        $this->sendSkin($this->server->getOnlinePlayers());
        return true;
    }
 
    public function sendSkin(?array $targets = null) : void{
        parent::sendSkin($targets ?? $this->server->getOnlinePlayers());
    }
 
    public function isUsingItem() : bool{
        return $this->startAction > -1;
    }
 
    public function setUsingItem(bool $value) : void{
        $this->startAction = $value ? $this->server->getTick() : -1;
        $this->networkPropertiesDirty = true;
    }
 
    public function getItemUseDuration() : int{
        return $this->startAction === -1 ? -1 : ($this->server->getTick() - $this->startAction);
    }
 
    public function getItemCooldownExpiry(Item $item) : int{
        $this->checkItemCooldowns();
        return $this->usedItemsCooldown[$item->getCooldownTag() ?? $item->getStateId()] ?? 0;
    }
 
    public function hasItemCooldown(Item $item) : bool{
        $this->checkItemCooldowns();
        return isset($this->usedItemsCooldown[$item->getCooldownTag() ?? $item->getStateId()]);
    }
 
    public function resetItemCooldown(Item $item, ?int $ticks = null) : void{
        $ticks = $ticks ?? $item->getCooldownTicks();
        if($ticks > 0){
            $this->usedItemsCooldown[$item->getCooldownTag() ?? $item->getStateId()] = $this->server->getTick() + $ticks;
            $this->getNetworkSession()->onItemCooldownChanged($item, $ticks);
        }
    }
 
    protected function checkItemCooldowns() : void{
        $serverTick = $this->server->getTick();
        foreach($this->usedItemsCooldown as $itemId => $cooldownUntil){
            if($cooldownUntil <= $serverTick){
                unset($this->usedItemsCooldown[$itemId]);
            }
        }
    }
 
    protected function setPosition(Vector3 $pos) : bool{
        $oldWorld = $this->location->isValid() ? $this->location->getWorld() : null;
        if(parent::setPosition($pos)){
            $newWorld = $this->getWorld();
            if($oldWorld !== $newWorld){
                if($oldWorld !== null){
                    foreach($this->usedChunks as $index => $status){
                        World::getXZ($index, $X, $Z);
                        $this->unloadChunk($X, $Z, $oldWorld);
                    }
                }
 
                $this->usedChunks = [];
                $this->loadQueue = [];
                $this->getNetworkSession()->onEnterWorld();
            }
 
            return true;
        }
 
        return false;
    }
 
    protected function unloadChunk(int $x, int $z, ?World $world = null) : void{
        $world = $world ?? $this->getWorld();
        $index = World::chunkHash($x, $z);
        if(isset($this->usedChunks[$index])){
            foreach($world->getChunkEntities($x, $z) as $entity){
                if($entity !== $this){
                    $entity->despawnFrom($this);
                }
            }
            $this->getNetworkSession()->stopUsingChunk($x, $z);
            unset($this->usedChunks[$index]);
            unset($this->activeChunkGenerationRequests[$index]);
        }
        $world->unregisterChunkLoader($this->chunkLoader, $x, $z);
        $world->unregisterChunkListener($this, $x, $z);
        unset($this->loadQueue[$index]);
        $world->unregisterTickingChunk($this->chunkTicker, $x, $z);
        unset($this->tickingChunks[$index]);
    }
 
    protected function spawnEntitiesOnAllChunks() : void{
        foreach($this->usedChunks as $chunkHash => $status){
            if($status === UsedChunkStatus::SENT){
                World::getXZ($chunkHash, $chunkX, $chunkZ);
                $this->spawnEntitiesOnChunk($chunkX, $chunkZ);
            }
        }
    }
 
    protected function spawnEntitiesOnChunk(int $chunkX, int $chunkZ) : void{
        foreach($this->getWorld()->getChunkEntities($chunkX, $chunkZ) as $entity){
            if($entity !== $this && !$entity->isFlaggedForDespawn()){
                $entity->spawnTo($this);
            }
        }
    }
 
    protected function requestChunks() : void{
        if(!$this->isConnected()){
            return;
        }
 
        Timings::$playerChunkSend->startTiming();
 
        $count = 0;
        $world = $this->getWorld();
 
        $limit = $this->chunksPerTick - count($this->activeChunkGenerationRequests);
        foreach($this->loadQueue as $index => $distance){
            if($count >= $limit){
                break;
            }
 
            $X = null;
            $Z = null;
            World::getXZ($index, $X, $Z);
 
            ++$count;
 
            $this->usedChunks[$index] = UsedChunkStatus::REQUESTED_GENERATION;
            $this->activeChunkGenerationRequests[$index] = true;
            unset($this->loadQueue[$index]);
            $world->registerChunkLoader($this->chunkLoader, $X, $Z, true);
            $world->registerChunkListener($this, $X, $Z);
            if(isset($this->tickingChunks[$index])){
                $world->registerTickingChunk($this->chunkTicker, $X, $Z);
            }
 
            $world->requestChunkPopulation($X, $Z, $this->chunkLoader)->onCompletion(
                function() use ($X, $Z, $index, $world) : void{
                    if(!$this->isConnected() || !isset($this->usedChunks[$index]) || $world !== $this->getWorld()){
                        return;
                    }
                    if($this->usedChunks[$index] !== UsedChunkStatus::REQUESTED_GENERATION){
                        //We may have previously requested this, decided we didn't want it, and then decided we did want
                        //it again, all before the generation request got executed. In that case, the promise would have
                        //multiple callbacks for this player. In that case, only the first one matters.
                        return;
                    }
                    unset($this->activeChunkGenerationRequests[$index]);
                    $this->usedChunks[$index] = UsedChunkStatus::REQUESTED_SENDING;
 
                    $this->getNetworkSession()->startUsingChunk($X, $Z, function() use ($X, $Z, $index) : void{
                        $this->usedChunks[$index] = UsedChunkStatus::SENT;
                        if($this->spawnChunkLoadCount === -1){
                            $this->spawnEntitiesOnChunk($X, $Z);
                        }elseif($this->spawnChunkLoadCount++ === $this->spawnThreshold){
                            $this->spawnChunkLoadCount = -1;
 
                            $this->spawnEntitiesOnAllChunks();
 
                            $this->getNetworkSession()->notifyTerrainReady();
                        }
                        (new PlayerPostChunkSendEvent($this, $X, $Z))->call();
                    });
                },
                static function() : void{
                    //NOOP: we'll re-request this if it fails anyway
                }
            );
        }
 
        Timings::$playerChunkSend->stopTiming();
    }
 
    private function recheckBroadcastPermissions() : void{
        foreach([
            DefaultPermissionNames::BROADCAST_ADMIN => Server::BROADCAST_CHANNEL_ADMINISTRATIVE,
            DefaultPermissionNames::BROADCAST_USER => Server::BROADCAST_CHANNEL_USERS
        ] as $permission => $channel){
            if($this->hasPermission($permission)){
                $this->server->subscribeToBroadcastChannel($channel, $this);
            }else{
                $this->server->unsubscribeFromBroadcastChannel($channel, $this);
            }
        }
    }
 
    public function doFirstSpawn() : void{
        if($this->spawned){
            return;
        }
        $this->spawned = true;
        $this->recheckBroadcastPermissions();
        $this->getPermissionRecalculationCallbacks()->add(function(array $changedPermissionsOldValues) : void{
            if(isset($changedPermissionsOldValues[Server::BROADCAST_CHANNEL_ADMINISTRATIVE]) || isset($changedPermissionsOldValues[Server::BROADCAST_CHANNEL_USERS])){
                $this->recheckBroadcastPermissions();
            }
        });
 
        $ev = new PlayerJoinEvent($this,
            KnownTranslationFactory::multiplayer_player_joined($this->getDisplayName())->prefix(TextFormat::YELLOW)
        );
        $ev->call();
        if($ev->getJoinMessage() !== ""){
            $this->server->broadcastMessage($ev->getJoinMessage());
        }
 
        $this->noDamageTicks = 60;
 
        $this->spawnToAll();
 
        if($this->getHealth() <= 0){
            $this->logger->debug("Quit while dead, forcing respawn");
            $this->actuallyRespawn();
        }
    }
 
    private function updateTickingChunkRegistrations(array $oldTickingChunks, array $newTickingChunks) : void{
        $world = $this->getWorld();
        foreach($oldTickingChunks as $hash => $_){
            if(!isset($newTickingChunks[$hash]) && !isset($this->loadQueue[$hash])){
                //we are (probably) still using this chunk, but it's no longer within ticking range
                World::getXZ($hash, $tickingChunkX, $tickingChunkZ);
                $world->unregisterTickingChunk($this->chunkTicker, $tickingChunkX, $tickingChunkZ);
            }
        }
        foreach($newTickingChunks as $hash => $_){
            if(!isset($oldTickingChunks[$hash]) && !isset($this->loadQueue[$hash])){
                //we were already using this chunk, but it is now within ticking range
                World::getXZ($hash, $tickingChunkX, $tickingChunkZ);
                $world->registerTickingChunk($this->chunkTicker, $tickingChunkX, $tickingChunkZ);
            }
        }
    }
 
    protected function orderChunks() : void{
        if(!$this->isConnected() || $this->viewDistance === -1){
            return;
        }
 
        Timings::$playerChunkOrder->startTiming();
 
        $newOrder = [];
        $tickingChunks = [];
        $unloadChunks = $this->usedChunks;
 
        $world = $this->getWorld();
        $tickingChunkRadius = $world->getChunkTickRadius();
 
        foreach($this->chunkSelector->selectChunks(
            $this->server->getAllowedViewDistance($this->viewDistance),
            $this->location->getFloorX() >> Chunk::COORD_BIT_SIZE,
            $this->location->getFloorZ() >> Chunk::COORD_BIT_SIZE
        ) as $radius => $hash){
            if(!isset($this->usedChunks[$hash]) || $this->usedChunks[$hash] === UsedChunkStatus::NEEDED){
                $newOrder[$hash] = true;
            }
            if($radius < $tickingChunkRadius){
                $tickingChunks[$hash] = true;
            }
            unset($unloadChunks[$hash]);
        }
 
        foreach($unloadChunks as $index => $status){
            World::getXZ($index, $X, $Z);
            $this->unloadChunk($X, $Z);
        }
 
        $this->loadQueue = $newOrder;
 
        $this->updateTickingChunkRegistrations($this->tickingChunks, $tickingChunks);
        $this->tickingChunks = $tickingChunks;
 
        if(count($this->loadQueue) > 0 || count($unloadChunks) > 0){
            $this->getNetworkSession()->syncViewAreaCenterPoint($this->location, $this->viewDistance);
        }
 
        Timings::$playerChunkOrder->stopTiming();
    }
 
    public function isUsingChunk(int $chunkX, int $chunkZ) : bool{
        return isset($this->usedChunks[World::chunkHash($chunkX, $chunkZ)]);
    }
 
    public function getUsedChunks() : array{
        return $this->usedChunks;
    }
 
    public function getUsedChunkStatus(int $chunkX, int $chunkZ) : ?UsedChunkStatus{
        return $this->usedChunks[World::chunkHash($chunkX, $chunkZ)] ?? null;
    }
 
    public function hasReceivedChunk(int $chunkX, int $chunkZ) : bool{
        $status = $this->usedChunks[World::chunkHash($chunkX, $chunkZ)] ?? null;
        return $status === UsedChunkStatus::SENT;
    }
 
    public function doChunkRequests() : void{
        if($this->nextChunkOrderRun !== PHP_INT_MAX && $this->nextChunkOrderRun-- <= 0){
            $this->nextChunkOrderRun = PHP_INT_MAX;
            $this->orderChunks();
        }
 
        if(count($this->loadQueue) > 0){
            $this->requestChunks();
        }
    }
 
    public function getDeathPosition() : ?Position{
        if($this->deathPosition !== null && !$this->deathPosition->isValid()){
            $this->deathPosition = null;
        }
        return $this->deathPosition;
    }
 
    public function setDeathPosition(?Vector3 $pos) : void{
        if($pos !== null){
            if($pos instanceof Position && $pos->world !== null){
                $world = $pos->world;
            }else{
                $world = $this->getWorld();
            }
            $this->deathPosition = new Position($pos->x, $pos->y, $pos->z, $world);
        }else{
            $this->deathPosition = null;
        }
        $this->networkPropertiesDirty = true;
    }
 
    public function getSpawn(){
        if($this->hasValidCustomSpawn()){
            return $this->spawnPosition;
        }else{
            $world = $this->server->getWorldManager()->getDefaultWorld();
 
            return $world->getSpawnLocation();
        }
    }
 
    public function hasValidCustomSpawn() : bool{
        return $this->spawnPosition !== null && $this->spawnPosition->isValid();
    }
 
    public function setSpawn(?Vector3 $pos) : void{
        if($pos !== null){
            if(!($pos instanceof Position)){
                $world = $this->getWorld();
            }else{
                $world = $pos->getWorld();
            }
            $this->spawnPosition = new Position($pos->x, $pos->y, $pos->z, $world);
        }else{
            $this->spawnPosition = null;
        }
        $this->getNetworkSession()->syncPlayerSpawnPoint($this->getSpawn());
    }
 
    public function isSleeping() : bool{
        return $this->sleeping !== null;
    }
 
    public function sleepOn(Vector3 $pos) : bool{
        $pos = $pos->floor();
        $b = $this->getWorld()->getBlock($pos);
 
        $ev = new PlayerBedEnterEvent($this, $b);
        $ev->call();
        if($ev->isCancelled()){
            return false;
        }
 
        if($b instanceof Bed){
            $b->setOccupied();
            $this->getWorld()->setBlock($pos, $b);
        }
 
        $this->sleeping = $pos;
        $this->networkPropertiesDirty = true;
 
        $this->setSpawn($pos);
 
        $this->getWorld()->setSleepTicks(60);
 
        return true;
    }
 
    public function stopSleep() : void{
        if($this->sleeping instanceof Vector3){
            $b = $this->getWorld()->getBlock($this->sleeping);
            if($b instanceof Bed){
                $b->setOccupied(false);
                $this->getWorld()->setBlock($this->sleeping, $b);
            }
            (new PlayerBedLeaveEvent($this, $b))->call();
 
            $this->sleeping = null;
            $this->networkPropertiesDirty = true;
 
            $this->getWorld()->setSleepTicks(0);
 
            $this->getNetworkSession()->sendDataPacket(AnimatePacket::create($this->getId(), AnimatePacket::ACTION_STOP_SLEEP));
        }
    }
 
    public function getGamemode() : GameMode{
        return $this->gamemode;
    }
 
    protected function internalSetGameMode(GameMode $gameMode) : void{
        $this->gamemode = $gameMode;
 
        $this->allowFlight = $this->gamemode === GameMode::CREATIVE;
        $this->hungerManager->setEnabled($this->isSurvival());
 
        if($this->isSpectator()){
            $this->setFlying(true);
            $this->setHasBlockCollision(false);
            $this->setSilent();
            $this->onGround = false;
 
            //TODO: HACK! this syncs the onground flag with the client so that flying works properly
            //this is a yucky hack but we don't have any other options :(
            $this->sendPosition($this->location, null, null, MovePlayerPacket::MODE_TELEPORT);
        }else{
            if($this->isSurvival()){
                $this->setFlying(false);
            }
            $this->setHasBlockCollision(true);
            $this->setSilent(false);
            $this->checkGroundState(0, 0, 0, 0, 0, 0);
        }
    }
 
    public function setGamemode(GameMode $gm) : bool{
        if($this->gamemode === $gm){
            return false;
        }
 
        $ev = new PlayerGameModeChangeEvent($this, $gm);
        $ev->call();
        if($ev->isCancelled()){
            return false;
        }
 
        $this->internalSetGameMode($gm);
 
        if($this->isSpectator()){
            $this->despawnFromAll();
        }else{
            $this->spawnToAll();
        }
 
        $this->getNetworkSession()->syncGameMode($this->gamemode);
        return true;
    }
 
    public function isSurvival(bool $literal = false) : bool{
        return $this->gamemode === GameMode::SURVIVAL || (!$literal && $this->gamemode === GameMode::ADVENTURE);
    }
 
    public function isCreative(bool $literal = false) : bool{
        return $this->gamemode === GameMode::CREATIVE || (!$literal && $this->gamemode === GameMode::SPECTATOR);
    }
 
    public function isAdventure(bool $literal = false) : bool{
        return $this->gamemode === GameMode::ADVENTURE || (!$literal && $this->gamemode === GameMode::SPECTATOR);
    }
 
    public function isSpectator() : bool{
        return $this->gamemode === GameMode::SPECTATOR;
    }
 
    public function hasFiniteResources() : bool{
        return $this->gamemode !== GameMode::CREATIVE;
    }
 
    public function getDrops() : array{
        if($this->hasFiniteResources()){
            return parent::getDrops();
        }
 
        return [];
    }
 
    public function getXpDropAmount() : int{
        if($this->hasFiniteResources()){
            return parent::getXpDropAmount();
        }
 
        return 0;
    }
 
    protected function checkGroundState(float $wantedX, float $wantedY, float $wantedZ, float $dx, float $dy, float $dz) : void{
        if($this->gamemode === GameMode::SPECTATOR){
            $this->onGround = false;
        }else{
            //TODO: AxisAlignedBB::withComponents() would be nice here
            $bb = new AxisAlignedBB(
                $this->boundingBox->minX,
                $this->location->y - 0.2,
                $this->boundingBox->minZ,
                $this->boundingBox->maxX,
                $this->location->y + 0.2,
                $this->boundingBox->maxZ
            );
 
            //we're already at the new position at this point; check if there are blocks we might have landed on between
            //the old and new positions (running down stairs necessitates this)
            $bb = $bb->addCoord(-$dx, -$dy, -$dz);
 
            $this->onGround = $this->isCollided = count($this->getWorld()->getCollisionBlocks($bb, true)) > 0;
        }
    }
 
    public function canBeMovedByCurrents() : bool{
        return false; //currently has no server-side movement
    }
 
    protected function checkNearEntities() : void{
        foreach($this->getWorld()->getNearbyEntities($this->boundingBox->expandedCopy(1, 0.5, 1), $this) as $entity){
            $entity->scheduleUpdate();
 
            if(!$entity->isAlive() || $entity->isFlaggedForDespawn()){
                continue;
            }
 
            $entity->onCollideWithPlayer($this);
        }
    }
 
    public function getInAirTicks() : int{
        return $this->inAirTicks;
    }
 
    public function handleMovement(Vector3 $newPos) : void{
        Timings::$playerMove->startTiming();
        try{
            $this->actuallyHandleMovement($newPos);
        }finally{
            Timings::$playerMove->stopTiming();
        }
    }
 
    private function actuallyHandleMovement(Vector3 $newPos) : void{
        $this->moveRateLimit--;
        if($this->moveRateLimit < 0){
            return;
        }
 
        $oldPos = $this->location;
        $distanceSquared = $newPos->distanceSquared($oldPos);
 
        $revert = false;
 
        if($distanceSquared > 225){ //15 blocks
            //TODO: this is probably too big if we process every movement
            /* !!! BEWARE YE WHO ENTER HERE !!!
             *
             * This is NOT an anti-cheat check. It is a safety check.
             * Without it hackers can teleport with freedom on their own and cause lots of undesirable behaviour, like
             * freezes, lag spikes and memory exhaustion due to sync chunk loading and collision checks across large distances.
             * Not only that, but high-latency players can trigger such behaviour innocently.
             *
             * If you must tamper with this code, be aware that this can cause very nasty results. Do not waste our time
             * asking for help if you suffer the consequences of messing with this.
             */
            $this->logger->debug("Moved too fast (" . sqrt($distanceSquared) . " blocks in 1 movement), reverting movement");
            $this->logger->debug("Old position: " . $oldPos->asVector3() . ", new position: " . $newPos);
            $revert = true;
        }elseif(!$this->getWorld()->isInLoadedTerrain($newPos)){
            $revert = true;
            $this->nextChunkOrderRun = 0;
        }
 
        if(!$revert && $distanceSquared !== 0.0){
            $dx = $newPos->x - $oldPos->x;
            $dy = $newPos->y - $oldPos->y;
            $dz = $newPos->z - $oldPos->z;
 
            $this->move($dx, $dy, $dz);
        }
 
        if($revert){
            $this->revertMovement($oldPos);
        }
    }
 
    protected function processMostRecentMovements() : void{
        $now = microtime(true);
        $multiplier = $this->lastMovementProcess !== null ? ($now - $this->lastMovementProcess) * 20 : 1;
        $exceededRateLimit = $this->moveRateLimit < 0;
        $this->moveRateLimit = min(self::MOVE_BACKLOG_SIZE, max(0, $this->moveRateLimit) + self::MOVES_PER_TICK * $multiplier);
        $this->lastMovementProcess = $now;
 
        $from = clone $this->lastLocation;
        $to = clone $this->location;
 
        $delta = $to->distanceSquared($from);
        $deltaAngle = abs($this->lastLocation->yaw - $to->yaw) + abs($this->lastLocation->pitch - $to->pitch);
 
        if($delta > 0.0001 || $deltaAngle > 1.0){
            if(PlayerMoveEvent::hasHandlers()){
                $ev = new PlayerMoveEvent($this, $from, $to);
 
                $ev->call();
 
                if($ev->isCancelled()){
                    $this->revertMovement($from);
                    return;
                }
 
                if($to->distanceSquared($ev->getTo()) > 0.01){ //If plugins modify the destination
                    $this->teleport($ev->getTo());
                    return;
                }
            }
 
            $this->lastLocation = $to;
            $this->broadcastMovement();
 
            $horizontalDistanceTravelled = sqrt((($from->x - $to->x) ** 2) + (($from->z - $to->z) ** 2));
            if($horizontalDistanceTravelled > 0){
                //TODO: check for swimming
                if($this->isSprinting()){
                    $this->hungerManager->exhaust(0.01 * $horizontalDistanceTravelled, EntityExhaustEvent::CAUSE_SPRINTING);
                }else{
                    $this->hungerManager->exhaust(0.0, EntityExhaustEvent::CAUSE_WALKING);
                }
 
                if($this->nextChunkOrderRun > 20){
                    $this->nextChunkOrderRun = 20;
                }
            }
        }
 
        if($exceededRateLimit){ //client and server positions will be out of sync if this happens
            $this->logger->debug("Exceeded movement rate limit, forcing to last accepted position");
            $this->sendPosition($this->location, $this->location->getYaw(), $this->location->getPitch(), MovePlayerPacket::MODE_RESET);
        }
    }
 
    protected function revertMovement(Location $from) : void{
        $this->setPosition($from);
        $this->sendPosition($from, $from->yaw, $from->pitch, MovePlayerPacket::MODE_RESET);
    }
 
    protected function calculateFallDamage(float $fallDistance) : float{
        return $this->flying ? 0 : parent::calculateFallDamage($fallDistance);
    }
 
    public function jump() : void{
        (new PlayerJumpEvent($this))->call();
        parent::jump();
    }
 
    public function setMotion(Vector3 $motion) : bool{
        if(parent::setMotion($motion)){
            $this->broadcastMotion();
            $this->getNetworkSession()->sendDataPacket(SetActorMotionPacket::create($this->id, $motion, tick: 0));
 
            return true;
        }
        return false;
    }
 
    protected function updateMovement(bool $teleport = false) : void{
 
    }
 
    protected function tryChangeMovement() : void{
 
    }
 
    public function onUpdate(int $currentTick) : bool{
        $tickDiff = $currentTick - $this->lastUpdate;
 
        if($tickDiff <= 0){
            return true;
        }
 
        $this->messageCounter = 2;
 
        $this->lastUpdate = $currentTick;
 
        if($this->justCreated){
            $this->onFirstUpdate($currentTick);
        }
 
        if(!$this->isAlive() && $this->spawned){
            $this->onDeathUpdate($tickDiff);
            return true;
        }
 
        $this->timings->startTiming();
 
        if($this->spawned){
            Timings::$playerMove->startTiming();
            $this->processMostRecentMovements();
            $this->motion = Vector3::zero(); //TODO: HACK! (Fixes player knockback being messed up)
            if($this->onGround){
                $this->inAirTicks = 0;
            }else{
                $this->inAirTicks += $tickDiff;
            }
            Timings::$playerMove->stopTiming();
 
            Timings::$entityBaseTick->startTiming();
            $this->entityBaseTick($tickDiff);
            Timings::$entityBaseTick->stopTiming();
 
            if($this->isCreative() && $this->fireTicks > 1){
                $this->fireTicks = 1;
            }
 
            if(!$this->isSpectator() && $this->isAlive()){
                Timings::$playerCheckNearEntities->startTiming();
                $this->checkNearEntities();
                Timings::$playerCheckNearEntities->stopTiming();
            }
 
            if($this->blockBreakHandler !== null && !$this->blockBreakHandler->update()){
                $this->blockBreakHandler = null;
            }
        }
 
        $this->timings->stopTiming();
 
        return true;
    }
 
    public function canEat() : bool{
        return $this->isCreative() || parent::canEat();
    }
 
    public function canBreathe() : bool{
        return $this->isCreative() || parent::canBreathe();
    }
 
    public function canInteract(Vector3 $pos, float $maxDistance, float $maxDiff = M_SQRT3 / 2) : bool{
        $eyePos = $this->getEyePos();
        if($eyePos->distanceSquared($pos) > $maxDistance ** 2){
            return false;
        }
 
        $dV = $this->getDirectionVector();
        $eyeDot = $dV->dot($eyePos);
        $targetDot = $dV->dot($pos);
        return ($targetDot - $eyeDot) >= -$maxDiff;
    }
 
    public function chat(string $message) : bool{
        $this->removeCurrentWindow();
 
        if($this->messageCounter <= 0){
            //the check below would take care of this (0 * (maxlen + 1) = 0), but it's better be explicit
            return false;
        }
 
        //Fast length check, to make sure we don't get hung trying to explode MBs of string ...
        $maxTotalLength = $this->messageCounter * (self::MAX_CHAT_BYTE_LENGTH + 1);
        if(strlen($message) > $maxTotalLength){
            return false;
        }
 
        $message = TextFormat::clean($message, false);
        foreach(explode("\n", $message, $this->messageCounter + 1) as $messagePart){
            if(trim($messagePart) !== "" && strlen($messagePart) <= self::MAX_CHAT_BYTE_LENGTH && mb_strlen($messagePart, 'UTF-8') <= self::MAX_CHAT_CHAR_LENGTH && $this->messageCounter-- > 0){
                if(str_starts_with($messagePart, './')){
                    $messagePart = substr($messagePart, 1);
                }
 
                if(str_starts_with($messagePart, "/")){
                    Timings::$playerCommand->startTiming();
                    $this->server->dispatchCommand($this, substr($messagePart, 1));
                    Timings::$playerCommand->stopTiming();
                }else{
                    $ev = new PlayerChatEvent($this, $messagePart, $this->server->getBroadcastChannelSubscribers(Server::BROADCAST_CHANNEL_USERS), new StandardChatFormatter());
                    $ev->call();
                    if(!$ev->isCancelled()){
                        $this->server->broadcastMessage($ev->getFormatter()->format($ev->getPlayer()->getDisplayName(), $ev->getMessage()), $ev->getRecipients());
                    }
                }
            }
        }
 
        return true;
    }
 
    public function selectHotbarSlot(int $hotbarSlot) : bool{
        if(!$this->hotbar->isHotbarSlot($hotbarSlot)){ //TODO: exception here?
            return false;
        }
        if($hotbarSlot === $this->hotbar->getSelectedIndex()){
            return true;
        }
 
        $ev = new PlayerItemHeldEvent($this, $this->inventory->getItem($hotbarSlot), $hotbarSlot);
        $ev->call();
        if($ev->isCancelled()){
            return false;
        }
 
        $this->hotbar->setSelectedIndex($hotbarSlot);
        $this->setUsingItem(false);
 
        return true;
    }
 
    private function returnItemsFromAction(Item $oldHeldItem, Item $newHeldItem, array $extraReturnedItems) : void{
        $heldItemChanged = false;
 
        if(!$newHeldItem->equalsExact($oldHeldItem) && $oldHeldItem->equalsExact($this->getMainHandItem())){
            //determine if the item was changed in some meaningful way, or just damaged/changed count
            //if it was really changed we always need to set it, whether we have finite resources or not
            $newReplica = clone $oldHeldItem;
            $newReplica->setCount($newHeldItem->getCount());
            if($newReplica instanceof Durable && $newHeldItem instanceof Durable){
                $newDamage = $newHeldItem->getDamage();
                if($newDamage >= 0 && $newDamage <= $newReplica->getMaxDurability()){
                    $newReplica->setDamage($newDamage);
                }
            }
            $damagedOrDeducted = $newReplica->equalsExact($newHeldItem);
 
            if(!$damagedOrDeducted || $this->hasFiniteResources()){
                if($newHeldItem instanceof Durable && $newHeldItem->isBroken()){
                    $this->broadcastSound(new ItemBreakSound());
                }
                $this->setMainHandItem($newHeldItem);
                $heldItemChanged = true;
            }
        }
 
        if(!$heldItemChanged){
            $newHeldItem = $oldHeldItem;
        }
 
        if($heldItemChanged && count($extraReturnedItems) > 0 && $newHeldItem->isNull()){
            $this->setMainHandItem(array_shift($extraReturnedItems));
        }
        foreach($this->inventory->addItem(...$extraReturnedItems) as $drop){
            //TODO: we can't generate a transaction for this since the items aren't coming from an inventory :(
            $ev = new PlayerDropItemEvent($this, $drop);
            if($this->isSpectator()){
                $ev->cancel();
            }
            $ev->call();
            if(!$ev->isCancelled()){
                $this->dropItem($drop);
            }
        }
    }
 
    public function useHeldItem() : bool{
        $directionVector = $this->getDirectionVector();
        $item = $this->getMainHandItem();
        $oldItem = clone $item;
 
        $ev = new PlayerItemUseEvent($this, $item, $directionVector);
        if($this->hasItemCooldown($item) || $this->isSpectator()){
            $ev->cancel();
        }
 
        $ev->call();
 
        if($ev->isCancelled()){
            return false;
        }
 
        $returnedItems = [];
        $result = $item->onClickAir($this, $directionVector, $returnedItems);
        if($result === ItemUseResult::FAIL){
            return false;
        }
 
        $this->resetItemCooldown($oldItem);
        $this->returnItemsFromAction($oldItem, $item, $returnedItems);
 
        $this->setUsingItem($item instanceof Releasable && $item->canStartUsingItem($this));
 
        return true;
    }
 
    public function consumeHeldItem() : bool{
        $slot = $this->getMainHandItem();
        if($slot instanceof ConsumableItem){
            $oldItem = clone $slot;
 
            $ev = new PlayerItemConsumeEvent($this, $slot);
            if($this->hasItemCooldown($slot)){
                $ev->cancel();
            }
            $ev->call();
 
            if($ev->isCancelled() || !$this->consumeObject($slot)){
                return false;
            }
 
            $this->setUsingItem(false);
            $this->resetItemCooldown($oldItem);
 
            $slot->pop();
            $this->returnItemsFromAction($oldItem, $slot, [$slot->getResidue()]);
 
            return true;
        }
 
        return false;
    }
 
    public function releaseHeldItem() : bool{
        try{
            $item = $this->getMainHandItem();
            if(!$this->isUsingItem() || $this->hasItemCooldown($item)){
                return false;
            }
 
            $oldItem = clone $item;
 
            $returnedItems = [];
            $result = $item->onReleaseUsing($this, $returnedItems);
            if($result === ItemUseResult::SUCCESS){
                $this->resetItemCooldown($oldItem);
                $this->returnItemsFromAction($oldItem, $item, $returnedItems);
                return true;
            }
 
            return false;
        }finally{
            $this->setUsingItem(false);
        }
    }
 
    public function pickBlock(Vector3 $pos, bool $addTileNBT) : bool{
        $block = $this->getWorld()->getBlock($pos);
        if($block instanceof UnknownBlock){
            return true;
        }
 
        $item = $block->getPickedItem($addTileNBT);
 
        $ev = new PlayerBlockPickEvent($this, $block, $item);
        $existingSlot = $this->inventory->first($item);
        if($existingSlot === -1 && $this->hasFiniteResources()){
            $ev->cancel();
        }
        $ev->call();
 
        if(!$ev->isCancelled()){
            $this->equipOrAddPickedItem($existingSlot, $item);
        }
 
        return true;
    }
 
    public function pickEntity(int $entityId) : bool{
        $entity = $this->getWorld()->getEntity($entityId);
        if($entity === null){
            return true;
        }
 
        $item = $entity->getPickedItem();
        if($item === null){
            return true;
        }
 
        $ev = new PlayerEntityPickEvent($this, $entity, $item);
        $existingSlot = $this->inventory->first($item);
        if($existingSlot === -1 && ($this->hasFiniteResources() || $this->isSpectator())){
            $ev->cancel();
        }
        $ev->call();
 
        if(!$ev->isCancelled()){
            $this->equipOrAddPickedItem($existingSlot, $item);
        }
 
        return true;
    }
 
    private function equipOrAddPickedItem(int $existingSlot, Item $item) : void{
        if($existingSlot !== -1){
            if($existingSlot < $this->hotbar->getSize()){
                $this->hotbar->setSelectedIndex($existingSlot);
            }else{
                $this->inventory->swap($this->hotbar->getSelectedIndex(), $existingSlot);
            }
        }else{
            $firstEmpty = $this->inventory->firstEmpty();
            if($firstEmpty === -1){ //full inventory
                $this->setMainHandItem($item);
            }elseif($firstEmpty < $this->hotbar->getSize()){
                $this->inventory->setItem($firstEmpty, $item);
                $this->hotbar->setSelectedIndex($firstEmpty);
            }else{
                $this->inventory->swap($this->hotbar->getSelectedIndex(), $firstEmpty);
                $this->setMainHandItem($item);
            }
        }
    }
 
    public function attackBlock(Vector3 $pos, Facing $face) : bool{
        if($pos->distanceSquared($this->location) > 10000){
            return false; //TODO: maybe this should throw an exception instead?
        }
 
        $target = $this->getWorld()->getBlock($pos);
 
        $ev = new PlayerInteractEvent($this, $this->getMainHandItem(), $target, null, $face, PlayerInteractEvent::LEFT_CLICK_BLOCK);
        if($this->isSpectator()){
            $ev->cancel();
        }
        $ev->call();
        if($ev->isCancelled()){
            return false;
        }
        $this->broadcastAnimation(new ArmSwingAnimation($this), $this->getViewers());
        if($target->onAttack($this->getMainHandItem(), $face, $this)){
            return true;
        }
 
        $block = $target->getSide($face);
        if($block->hasTypeTag(BlockTypeTags::FIRE)){
            $this->getWorld()->setBlock($block->getPosition(), VanillaBlocks::AIR());
            $this->getWorld()->addSound($block->getPosition()->add(0.5, 0.5, 0.5), new FireExtinguishSound());
            return true;
        }
 
        if(!$this->isCreative() && !$target->getBreakInfo()->breaksInstantly()){
            $this->blockBreakHandler = new SurvivalBlockBreakHandler($this, $pos, $target, $face, 16);
        }
 
        return true;
    }
 
    public function continueBreakBlock(Vector3 $pos, Facing $face) : void{
        if($this->blockBreakHandler !== null && $this->blockBreakHandler->getBlockPos()->distanceSquared($pos) < 0.0001){
            $this->blockBreakHandler->setTargetedFace($face);
        }
    }
 
    public function stopBreakBlock(Vector3 $pos) : void{
        if($this->blockBreakHandler !== null && $this->blockBreakHandler->getBlockPos()->distanceSquared($pos) < 0.0001){
            $this->blockBreakHandler = null;
        }
    }
 
    public function breakBlock(Vector3 $pos) : bool{
        $this->removeCurrentWindow();
 
        if($this->canInteract($pos->add(0.5, 0.5, 0.5), $this->isCreative() ? self::MAX_REACH_DISTANCE_CREATIVE : self::MAX_REACH_DISTANCE_SURVIVAL)){
            $this->broadcastAnimation(new ArmSwingAnimation($this), $this->getViewers());
            $this->stopBreakBlock($pos);
            $item = $this->getMainHandItem();
            $oldItem = clone $item;
            $returnedItems = [];
            if($this->getWorld()->useBreakOn($pos, $item, $this, true, $returnedItems)){
                $this->returnItemsFromAction($oldItem, $item, $returnedItems);
                $this->hungerManager->exhaust(0.005, EntityExhaustEvent::CAUSE_MINING);
                return true;
            }
        }else{
            $this->logger->debug("Cancelled block break at $pos due to not currently being interactable");
        }
 
        return false;
    }
 
    public function interactBlock(Vector3 $pos, Facing $face, Vector3 $clickOffset) : bool{
        $this->setUsingItem(false);
 
        if($this->canInteract($pos->add(0.5, 0.5, 0.5), $this->isCreative() ? self::MAX_REACH_DISTANCE_CREATIVE : self::MAX_REACH_DISTANCE_SURVIVAL)){
            $this->broadcastAnimation(new ArmSwingAnimation($this), $this->getViewers());
            $item = $this->getMainHandItem(); //this is a copy of the real item
            $oldItem = clone $item;
            $returnedItems = [];
            if($this->getWorld()->useItemOn($pos, $item, $face, $clickOffset, $this, true, $returnedItems)){
                $this->returnItemsFromAction($oldItem, $item, $returnedItems);
                return true;
            }
        }else{
            $this->logger->debug("Cancelled interaction of block at $pos due to not currently being interactable");
        }
 
        return false;
    }
 
    public function attackEntity(Entity $entity) : bool{
        if(!$entity->isAlive()){
            return false;
        }
        if($entity instanceof ItemEntity || $entity instanceof Arrow){
            $this->logger->debug("Attempted to attack non-attackable entity " . get_class($entity));
            return false;
        }
 
        $heldItem = $this->getMainHandItem();
        $oldItem = clone $heldItem;
 
        $ev = new EntityDamageByEntityEvent($this, $entity, EntityDamageEvent::CAUSE_ENTITY_ATTACK, $heldItem->getAttackPoints());
        if(!$this->canInteract($entity->getLocation(), self::MAX_REACH_DISTANCE_ENTITY_INTERACTION)){
            $this->logger->debug("Cancelled attack of entity " . $entity->getId() . " due to not currently being interactable");
            $ev->cancel();
        }elseif($this->isSpectator() || ($entity instanceof Player && !$this->server->getConfigGroup()->getConfigBool(ServerProperties::PVP))){
            $ev->cancel();
        }
 
        $meleeEnchantmentDamage = 0;
        $meleeEnchantments = [];
        foreach($heldItem->getEnchantments() as $enchantment){
            $type = $enchantment->getType();
            if($type instanceof MeleeWeaponEnchantment && $type->isApplicableTo($entity)){
                $meleeEnchantmentDamage += $type->getDamageBonus($enchantment->getLevel());
                $meleeEnchantments[] = $enchantment;
            }
        }
        $ev->setModifier($meleeEnchantmentDamage, EntityDamageEvent::MODIFIER_WEAPON_ENCHANTMENTS);
 
        if(!$this->isSprinting() && !$this->isFlying() && $this->fallDistance > 0 && !$this->effectManager->has(VanillaEffects::BLINDNESS()) && !$this->isUnderwater()){
            $ev->setModifier($ev->getFinalDamage() / 2, EntityDamageEvent::MODIFIER_CRITICAL);
        }
 
        $entity->attack($ev);
        $this->broadcastAnimation(new ArmSwingAnimation($this), $this->getViewers());
 
        $soundPos = $entity->getPosition()->add(0, $entity->size->getHeight() / 2, 0);
        if($ev->isCancelled()){
            $this->getWorld()->addSound($soundPos, new EntityAttackNoDamageSound());
            return false;
        }
        $this->getWorld()->addSound($soundPos, new EntityAttackSound());
 
        if($ev->getModifier(EntityDamageEvent::MODIFIER_CRITICAL) > 0 && $entity instanceof Living){
            $entity->broadcastAnimation(new CriticalHitAnimation($entity));
        }
 
        foreach($meleeEnchantments as $enchantment){
            $type = $enchantment->getType();
            assert($type instanceof MeleeWeaponEnchantment);
            $type->onPostAttack($this, $entity, $enchantment->getLevel());
        }
 
        if($this->isAlive()){
            //reactive damage like thorns might cause us to be killed by attacking another mob, which
            //would mean we'd already have dropped the inventory by the time we reached here
            $returnedItems = [];
            $heldItem->onAttackEntity($entity, $returnedItems);
            $this->returnItemsFromAction($oldItem, $heldItem, $returnedItems);
 
            $this->hungerManager->exhaust(0.1, EntityExhaustEvent::CAUSE_ATTACK);
        }
 
        return true;
    }
 
    public function missSwing() : void{
        $ev = new PlayerMissSwingEvent($this);
        $ev->call();
        if(!$ev->isCancelled()){
            $this->broadcastSound(new EntityAttackNoDamageSound());
            $this->broadcastAnimation(new ArmSwingAnimation($this), $this->getViewers());
        }
    }
 
    public function interactEntity(Entity $entity, Vector3 $clickPos) : bool{
        $ev = new PlayerEntityInteractEvent($this, $entity, $clickPos);
 
        if(!$this->canInteract($entity->getLocation(), self::MAX_REACH_DISTANCE_ENTITY_INTERACTION)){
            $this->logger->debug("Cancelled interaction with entity " . $entity->getId() . " due to not currently being interactable");
            $ev->cancel();
        }
 
        $ev->call();
 
        $item = $this->getMainHandItem();
        $oldItem = clone $item;
        if(!$ev->isCancelled()){
            if($item->onInteractEntity($this, $entity, $clickPos)){
                if($this->hasFiniteResources() && !$item->equalsExact($oldItem) && $oldItem->equalsExact($this->getMainHandItem())){
                    if($item instanceof Durable && $item->isBroken()){
                        $this->broadcastSound(new ItemBreakSound());
                    }
                    $this->setMainHandItem($item);
                }
            }
            return $entity->onInteract($this, $clickPos);
        }
        return false;
    }
 
    public function toggleSprint(bool $sprint) : bool{
        if($sprint === $this->sprinting){
            return true;
        }
        $ev = new PlayerToggleSprintEvent($this, $sprint);
        $ev->call();
        if($ev->isCancelled()){
            return false;
        }
        $this->setSprinting($sprint);
        return true;
    }
 
    public function toggleSneak(bool $sneak) : bool{
        if($sneak === $this->sneaking){
            return true;
        }
        $ev = new PlayerToggleSneakEvent($this, $sneak);
        $ev->call();
        if($ev->isCancelled()){
            return false;
        }
        $this->setSneaking($sneak);
        return true;
    }
 
    public function toggleFlight(bool $fly) : bool{
        if($fly === $this->flying){
            return true;
        }
        $ev = new PlayerToggleFlightEvent($this, $fly);
        if(!$this->allowFlight){
            $ev->cancel();
        }
        $ev->call();
        if($ev->isCancelled()){
            return false;
        }
        $this->setFlying($fly);
        return true;
    }
 
    public function toggleGlide(bool $glide) : bool{
        if($glide === $this->gliding){
            return true;
        }
        $ev = new PlayerToggleGlideEvent($this, $glide);
        $ev->call();
        if($ev->isCancelled()){
            return false;
        }
        $this->setGliding($glide);
        return true;
    }
 
    public function toggleSwim(bool $swim) : bool{
        if($swim === $this->swimming){
            return true;
        }
        $ev = new PlayerToggleSwimEvent($this, $swim);
        $ev->call();
        if($ev->isCancelled()){
            return false;
        }
        $this->setSwimming($swim);
        return true;
    }
 
    public function emote(string $emoteId) : void{
        $currentTick = $this->server->getTick();
        if($currentTick - $this->lastEmoteTick > 5){
            $this->lastEmoteTick = $currentTick;
            $event = new PlayerEmoteEvent($this, $emoteId);
            $event->call();
            if(!$event->isCancelled()){
                $emoteId = $event->getEmoteId();
                parent::emote($emoteId);
            }
        }
    }
 
    public function dropItem(Item $item) : void{
        $this->broadcastAnimation(new ArmSwingAnimation($this), $this->getViewers());
        $this->getWorld()->dropItem($this->location->add(0, 1.3, 0), $item, $this->getDirectionVector()->multiply(0.4), 40);
    }
 
    public function sendTitle(string $title, string $subtitle = "", int $fadeIn = -1, int $stay = -1, int $fadeOut = -1) : void{
        $this->setTitleDuration($fadeIn, $stay, $fadeOut);
        if($subtitle !== ""){
            $this->sendSubTitle($subtitle);
        }
        $this->getNetworkSession()->onTitle($title);
    }
 
    public function sendSubTitle(string $subtitle) : void{
        $this->getNetworkSession()->onSubTitle($subtitle);
    }
 
    public function sendActionBarMessage(string $message) : void{
        $this->getNetworkSession()->onActionBar($message);
    }
 
    public function removeTitles() : void{
        $this->getNetworkSession()->onClearTitle();
    }
 
    public function resetTitles() : void{
        $this->getNetworkSession()->onResetTitleOptions();
    }
 
    public function setTitleDuration(int $fadeIn, int $stay, int $fadeOut) : void{
        if($fadeIn >= 0 && $stay >= 0 && $fadeOut >= 0){
            $this->getNetworkSession()->onTitleDuration($fadeIn, $stay, $fadeOut);
        }
    }
 
    public function sendMessage(Translatable|string $message) : void{
        $this->getNetworkSession()->onChatMessage($message);
    }
 
    public function sendJukeboxPopup(Translatable|string $message) : void{
        $this->getNetworkSession()->onJukeboxPopup($message);
    }
 
    public function sendPopup(string $message) : void{
        $this->getNetworkSession()->onPopup($message);
    }
 
    public function sendTip(string $message) : void{
        $this->getNetworkSession()->onTip($message);
    }
 
    public function sendToastNotification(string $title, string $body) : void{
        $this->getNetworkSession()->onToastNotification($title, $body);
    }
 
    public function sendForm(Form $form) : void{
        $id = $this->formIdCounter++;
        if($this->getNetworkSession()->onFormSent($id, $form)){
            $this->forms[$id] = $form;
        }
    }
 
    public function onFormSubmit(int $formId, mixed $responseData) : bool{
        if(!isset($this->forms[$formId])){
            $this->logger->debug("Got unexpected response for form $formId");
            return false;
        }
 
        try{
            $this->forms[$formId]->handleResponse($this, $responseData);
        }catch(FormValidationException $e){
            $this->logger->critical("Failed to validate form " . get_class($this->forms[$formId]) . ": " . $e->getMessage());
            $this->logger->logException($e);
        }finally{
            unset($this->forms[$formId]);
        }
 
        return true;
    }
 
    public function closeAllForms() : void{
        $this->getNetworkSession()->onCloseAllForms();
    }
 
    public function transfer(string $address, int $port = 19132, Translatable|string|null $message = null) : bool{
        $ev = new PlayerTransferEvent($this, $address, $port, $message ?? KnownTranslationFactory::pocketmine_disconnect_transfer());
        $ev->call();
        if(!$ev->isCancelled()){
            $this->getNetworkSession()->transfer($ev->getAddress(), $ev->getPort(), $ev->getMessage());
            return true;
        }
 
        return false;
    }
 
    public function kick(Translatable|string $reason = "", Translatable|string|null $quitMessage = null, Translatable|string|null $disconnectScreenMessage = null) : bool{
        $ev = new PlayerKickEvent($this, $reason, $quitMessage ?? $this->getLeaveMessage(), $disconnectScreenMessage);
        $ev->call();
        if(!$ev->isCancelled()){
            $reason = $ev->getDisconnectReason();
            if($reason === ""){
                $reason = KnownTranslationFactory::disconnectionScreen_noReason();
            }
            $disconnectScreenMessage = $ev->getDisconnectScreenMessage() ?? $reason;
            if($disconnectScreenMessage === ""){
                $disconnectScreenMessage = KnownTranslationFactory::disconnectionScreen_noReason();
            }
            $this->disconnect($reason, $ev->getQuitMessage(), $disconnectScreenMessage);
 
            return true;
        }
 
        return false;
    }
 
    public function disconnect(Translatable|string $reason, Translatable|string|null $quitMessage = null, Translatable|string|null $disconnectScreenMessage = null) : void{
        if(!$this->isConnected()){
            return;
        }
 
        $this->getNetworkSession()->onPlayerDestroyed($reason, $disconnectScreenMessage ?? $reason);
        $this->onPostDisconnect($reason, $quitMessage);
    }
 
    public function onPostDisconnect(Translatable|string $reason, Translatable|string|null $quitMessage) : void{
        if($this->isConnected()){
            throw new \LogicException("Player is still connected");
        }
 
        //prevent the player receiving their own disconnect message
        $this->server->unsubscribeFromAllBroadcastChannels($this);
 
        $this->removeCurrentWindow();
 
        $ev = new PlayerQuitEvent($this, $quitMessage ?? $this->getLeaveMessage(), $reason);
        $ev->call();
        if(($quitMessage = $ev->getQuitMessage()) !== ""){
            $this->server->broadcastMessage($quitMessage);
        }
        $this->save();
 
        $this->spawned = false;
 
        $this->stopSleep();
        $this->blockBreakHandler = null;
        $this->despawnFromAll();
 
        $this->server->removeOnlinePlayer($this);
 
        foreach($this->server->getOnlinePlayers() as $player){
            if(!$player->canSee($this)){
                $player->showPlayer($this);
            }
        }
        $this->hiddenPlayers = [];
 
        if($this->location->isValid()){
            foreach($this->usedChunks as $index => $status){
                World::getXZ($index, $chunkX, $chunkZ);
                $this->unloadChunk($chunkX, $chunkZ);
            }
        }
        if(count($this->usedChunks) !== 0){
            throw new AssumptionFailedError("Previous loop should have cleared this array");
        }
        $this->loadQueue = [];
 
        $this->removeCurrentWindow();
        $this->removePermanentWindows();
 
        $this->perm->getPermissionRecalculationCallbacks()->clear();
 
        $this->flagForDespawn();
    }
 
    protected function onDispose() : void{
        $this->disconnect("Player destroyed");
        $this->cursorInventory->removeAllWindows();
        $this->craftingGrid->removeAllWindows();
        parent::onDispose();
    }
 
    protected function destroyCycles() : void{
        $this->networkSession = null;
        $this->spawnPosition = null;
        $this->deathPosition = null;
        $this->blockBreakHandler = null;
        parent::destroyCycles();
    }
 
    public function __debugInfo() : array{
        return [];
    }
 
    public function __destruct(){
        parent::__destruct();
        $this->logger->debug("Destroyed by garbage collector");
    }
 
    public function canSaveWithChunk() : bool{
        return false;
    }
 
    public function setCanSaveWithChunk(bool $value) : void{
        throw new \BadMethodCallException("Players can't be saved with chunks");
    }
 
    public function getSaveData() : CompoundTag{
        $nbt = $this->saveNBT();
 
        $nbt->setString(self::TAG_LAST_KNOWN_XUID, $this->xuid);
 
        if($this->location->isValid()){
            $nbt->setString(self::TAG_LEVEL, $this->getWorld()->getFolderName());
        }
 
        if($this->hasValidCustomSpawn()){
            $spawn = $this->getSpawn();
            $nbt->setString(self::TAG_SPAWN_WORLD, $spawn->getWorld()->getFolderName());
            $nbt->setInt(self::TAG_SPAWN_X, $spawn->getFloorX());
            $nbt->setInt(self::TAG_SPAWN_Y, $spawn->getFloorY());
            $nbt->setInt(self::TAG_SPAWN_Z, $spawn->getFloorZ());
        }
 
        if($this->deathPosition !== null && $this->deathPosition->isValid()){
            $nbt->setString(self::TAG_DEATH_WORLD, $this->deathPosition->getWorld()->getFolderName());
            $nbt->setInt(self::TAG_DEATH_X, $this->deathPosition->getFloorX());
            $nbt->setInt(self::TAG_DEATH_Y, $this->deathPosition->getFloorY());
            $nbt->setInt(self::TAG_DEATH_Z, $this->deathPosition->getFloorZ());
        }
 
        $nbt->setInt(self::TAG_GAME_MODE, GameModeIdMap::getInstance()->toId($this->gamemode));
        $nbt->setLong(self::TAG_FIRST_PLAYED, (int) $this->firstPlayed->format('Uv'));
        $nbt->setLong(self::TAG_LAST_PLAYED, (int) floor(microtime(true) * 1000));
 
        return $nbt;
    }
 
    public function save() : void{
        $this->server->saveOfflinePlayerData($this->username, $this->getSaveData());
    }
 
    protected function onDeath() : void{
        //Crafting grid must always be evacuated even if keep-inventory is true. This dumps the contents into the
        //main inventory and drops the rest on the ground.
        $this->removeCurrentWindow();
 
        $this->setDeathPosition($this->getPosition());
 
        $ev = new PlayerDeathEvent($this, $this->getDrops(), $this->getXpDropAmount(), null);
        $ev->call();
 
        if(!$ev->getKeepInventory()){
            foreach($ev->getDrops() as $item){
                $this->getWorld()->dropItem($this->location, $item);
            }
 
            $this->hotbar->setSelectedIndex(0);
            $clearInventory = fn(Inventory $inventory) => $inventory->setContents(array_filter($inventory->getContents(), fn(Item $item) => $item->keepOnDeath()));
            $clearInventory($this->inventory);
            $clearInventory($this->armorInventory);
            $clearInventory($this->offHandInventory);
        }
 
        if(!$ev->getKeepXp()){
            $this->getWorld()->dropExperience($this->location, $ev->getXpDropAmount());
            $this->xpManager->setXpAndProgress(0, 0.0);
        }
 
        if($ev->getDeathMessage() !== ""){
            $this->server->broadcastMessage($ev->getDeathMessage());
        }
 
        $this->startDeathAnimation();
 
        $this->getNetworkSession()->onServerDeath($ev->getDeathScreenMessage());
    }
 
    protected function onDeathUpdate(int $tickDiff) : bool{
        parent::onDeathUpdate($tickDiff);
        return false; //never flag players for despawn
    }
 
    public function respawn() : void{
        if($this->server->isHardcore()){
            if($this->kick(KnownTranslationFactory::pocketmine_disconnect_ban(KnownTranslationFactory::pocketmine_disconnect_ban_hardcore()))){ //this allows plugins to prevent the ban by cancelling PlayerKickEvent
                $this->server->getNameBans()->addBan($this->getName(), "Died in hardcore mode");
            }
            return;
        }
 
        $this->actuallyRespawn();
    }
 
    protected function actuallyRespawn() : void{
        if($this->respawnLocked){
            return;
        }
        $this->respawnLocked = true;
 
        $this->logger->debug("Waiting for safe respawn position to be located");
        $spawn = $this->getSpawn();
        $spawn->getWorld()->requestSafeSpawn($spawn)->onCompletion(
            function(Position $safeSpawn) : void{
                if(!$this->isConnected()){
                    return;
                }
                $this->logger->debug("Respawn position located, completing respawn");
                $ev = new PlayerRespawnEvent($this, $safeSpawn);
                $spawnPosition = $ev->getRespawnPosition();
                $spawnBlock = $spawnPosition->getWorld()->getBlock($spawnPosition);
                if($spawnBlock instanceof RespawnAnchor){
                    if($spawnBlock->getCharges() > 0){
                        $spawnPosition->getWorld()->setBlock($spawnPosition, $spawnBlock->setCharges($spawnBlock->getCharges() - 1));
                        $spawnPosition->getWorld()->addSound($spawnPosition, new RespawnAnchorDepleteSound());
                    }else{
                        $defaultSpawn = $this->server->getWorldManager()->getDefaultWorld()?->getSpawnLocation();
                        if($defaultSpawn !== null){
                            $this->setSpawn($defaultSpawn);
                            $ev->setRespawnPosition($defaultSpawn);
                            $this->sendMessage(KnownTranslationFactory::tile_respawn_anchor_notValid()->prefix(TextFormat::GRAY));
                        }
                    }
                }
                $ev->call();
 
                $realSpawn = Position::fromObject($ev->getRespawnPosition()->add(0.5, 0, 0.5), $ev->getRespawnPosition()->getWorld());
                $this->teleport($realSpawn);
 
                $this->setSprinting(false);
                $this->setSneaking(false);
                $this->setFlying(false);
 
                $this->extinguish(EntityExtinguishEvent::CAUSE_RESPAWN);
                $this->setAirSupplyTicks($this->getMaxAirSupplyTicks());
                $this->deadTicks = 0;
                $this->noDamageTicks = 60;
 
                $this->effectManager->clear();
                $this->setHealth($this->getMaxHealth());
 
                foreach($this->attributeMap->getAll() as $attr){
                    if($attr->getId() === Attribute::EXPERIENCE || $attr->getId() === Attribute::EXPERIENCE_LEVEL){ //we have already reset both of those if needed when the player died
                        continue;
                    }
                    $attr->resetToDefault();
                }
 
                $this->spawnToAll();
                $this->scheduleUpdate();
 
                $this->getNetworkSession()->onServerRespawn();
                $this->respawnLocked = false;
            },
            function() : void{
                if($this->isConnected()){
                    $this->getNetworkSession()->disconnectWithError(KnownTranslationFactory::pocketmine_disconnect_error_respawn());
                }
            }
        );
    }
 
    protected function applyPostDamageEffects(EntityDamageEvent $source) : void{
        parent::applyPostDamageEffects($source);
 
        $this->hungerManager->exhaust(0.1, EntityExhaustEvent::CAUSE_DAMAGE);
    }
 
    public function attack(EntityDamageEvent $source) : void{
        if(!$this->isAlive()){
            return;
        }
 
        if($this->isCreative()
            && $source->getCause() !== EntityDamageEvent::CAUSE_SUICIDE
        ){
            $source->cancel();
        }elseif($this->allowFlight && $source->getCause() === EntityDamageEvent::CAUSE_FALL){
            $source->cancel();
        }
 
        parent::attack($source);
    }
 
    protected function syncNetworkData(EntityMetadataCollection $properties) : void{
        parent::syncNetworkData($properties);
 
        $properties->setGenericFlag(EntityMetadataFlags::ACTION, $this->startAction > -1);
        $properties->setGenericFlag(EntityMetadataFlags::HAS_COLLISION, $this->hasBlockCollision());
 
        $properties->setPlayerFlag(PlayerMetadataFlags::SLEEP, $this->sleeping !== null);
        $properties->setBlockPos(EntityMetadataProperties::PLAYER_BED_POSITION, $this->sleeping !== null ? BlockPosition::fromVector3($this->sleeping) : new BlockPosition(0, 0, 0));
 
        if($this->deathPosition !== null && $this->deathPosition->world === $this->location->world){
            $properties->setBlockPos(EntityMetadataProperties::PLAYER_DEATH_POSITION, BlockPosition::fromVector3($this->deathPosition));
            //TODO: this should be updated when dimensions are implemented
            $properties->setInt(EntityMetadataProperties::PLAYER_DEATH_DIMENSION, DimensionIds::OVERWORLD);
            $properties->setByte(EntityMetadataProperties::PLAYER_HAS_DIED, 1);
        }else{
            $properties->setBlockPos(EntityMetadataProperties::PLAYER_DEATH_POSITION, new BlockPosition(0, 0, 0));
            $properties->setInt(EntityMetadataProperties::PLAYER_DEATH_DIMENSION, DimensionIds::OVERWORLD);
            $properties->setByte(EntityMetadataProperties::PLAYER_HAS_DIED, 0);
        }
    }
 
    public function sendData(?array $targets, ?array $data = null) : void{
        if($targets === null){
            $targets = $this->getViewers();
            $targets[] = $this;
        }
        parent::sendData($targets, $data);
    }
 
    public function broadcastAnimation(Animation $animation, ?array $targets = null) : void{
        if($this->spawned && $targets === null){
            $targets = $this->getViewers();
            $targets[] = $this;
        }
        parent::broadcastAnimation($animation, $targets);
    }
 
    public function broadcastSound(Sound $sound, ?array $targets = null) : void{
        if($this->spawned && $targets === null){
            $targets = $this->getViewers();
            $targets[] = $this;
        }
        parent::broadcastSound($sound, $targets);
    }
 
    protected function sendPosition(Vector3 $pos, ?float $yaw = null, ?float $pitch = null, int $mode = MovePlayerPacket::MODE_NORMAL) : void{
        $this->getNetworkSession()->syncMovement($pos, $yaw, $pitch, $mode);
 
        $this->ySize = 0;
    }
 
    public function teleport(Vector3 $pos, ?float $yaw = null, ?float $pitch = null) : bool{
        if(parent::teleport($pos, $yaw, $pitch)){
 
            $this->removeCurrentWindow();
            $this->stopSleep();
 
            $this->sendPosition($this->location, $this->location->yaw, $this->location->pitch, MovePlayerPacket::MODE_TELEPORT);
            $this->broadcastMovement(true);
 
            $this->spawnToAll();
 
            $this->resetFallDistance();
            $this->nextChunkOrderRun = 0;
            if($this->spawnChunkLoadCount !== -1){
                $this->spawnChunkLoadCount = 0;
            }
            $this->blockBreakHandler = null;
 
            //TODO: workaround for player last pos not getting updated
            //Entity::updateMovement() normally handles this, but it's overridden with an empty function in Player
            $this->resetLastMovements();
 
            return true;
        }
 
        return false;
    }
 
    protected function addDefaultWindows() : void{
        $this->cursorInventory = new SimpleInventory(1);
        $this->craftingGrid = new CraftingGrid(CraftingGrid::SIZE_SMALL);
 
        $this->addPermanentWindows([
            new PlayerInventoryWindow($this, $this->inventory, PlayerInventoryWindow::TYPE_INVENTORY),
            new PlayerInventoryWindow($this, $this->armorInventory, PlayerInventoryWindow::TYPE_ARMOR),
            new PlayerInventoryWindow($this, $this->cursorInventory, PlayerInventoryWindow::TYPE_CURSOR),
            new PlayerInventoryWindow($this, $this->offHandInventory, PlayerInventoryWindow::TYPE_OFFHAND),
            new PlayerInventoryWindow($this, $this->craftingGrid, PlayerInventoryWindow::TYPE_CRAFTING),
        ]);
    }
 
    public function getCursorInventory() : Inventory{
        return $this->cursorInventory;
    }
 
    public function getCraftingGrid() : CraftingGrid{
        return $this->craftingGrid;
    }
 
    public function getCreativeInventory() : CreativeInventory{
        return $this->creativeInventory;
    }
 
    public function setCreativeInventory(CreativeInventory $inventory) : void{
        $this->creativeInventory = $inventory;
        if($this->spawned && $this->isConnected()){
            $this->getNetworkSession()->getInvManager()?->syncCreative();
        }
    }
 
    private function doCloseInventory() : void{
        $windowsToClear = [];
        $mainInventoryWindow = null;
        foreach($this->permanentWindows as $window){
            if($window->getType() === PlayerInventoryWindow::TYPE_CRAFTING || $window->getType() === PlayerInventoryWindow::TYPE_CURSOR){
                $windowsToClear[] = $window;
            }elseif($window->getType() === PlayerInventoryWindow::TYPE_INVENTORY){
                $mainInventoryWindow = $window;
            }
        }
        if($mainInventoryWindow === null){
            //TODO: in the future this might not be the case, if we implement support for the player closing their
            //inventory window outside the protocol layer
            //in that case we'd have to create a new ephemeral window here
            throw new AssumptionFailedError("This should never be null");
        }
 
        if($this->currentWindow instanceof TemporaryInventoryWindow){
            $windowsToClear[] = $this->currentWindow;
        }
 
        $builder = new TransactionBuilder();
        foreach($windowsToClear as $window){
            $contents = $window->getInventory()->getContents();
 
            if(count($contents) > 0){
                $drops = $builder->getActionBuilder($mainInventoryWindow)->addItem(...$contents);
                foreach($drops as $drop){
                    $builder->addAction(new DropItemAction($drop));
                }
 
                $builder->getActionBuilder($window)->clearAll();
            }
        }
 
        $actions = $builder->generateActions();
        if(count($actions) !== 0){
            $transaction = new InventoryTransaction($this, $actions);
            try{
                $transaction->execute();
                $this->logger->debug("Successfully evacuated items from temporary inventories");
            }catch(TransactionCancelledException){
                $this->logger->debug("Plugin cancelled transaction evacuating items from temporary inventories; items will be destroyed");
                foreach($windowsToClear as $window){
                    $window->getInventory()->clearAll();
                }
            }catch(TransactionValidationException $e){
                throw new AssumptionFailedError("This server-generated transaction should never be invalid", 0, $e);
            }
        }
    }
 
    public function getCurrentWindow() : ?InventoryWindow{
        return $this->currentWindow;
    }
 
    public function setCurrentWindow(InventoryWindow $window) : bool{
        if($window === $this->currentWindow){
            return true;
        }
        if($window->getViewer() !== $this){
            throw new \InvalidArgumentException("Cannot reuse InventoryWindow instances, please create a new one for each player");
        }
        $ev = new InventoryOpenEvent($window, $this);
        $ev->call();
        if($ev->isCancelled()){
            return false;
        }
 
        $this->removeCurrentWindow();
 
        if(($inventoryManager = $this->getNetworkSession()->getInvManager()) === null){
            throw new \InvalidArgumentException("Player cannot open inventories in this state");
        }
        $this->logger->debug("Opening inventory window " . get_class($window) . "#" . spl_object_id($window));
        $inventoryManager->onCurrentWindowChange($window);
        $window->onOpen();
        $this->currentWindow = $window;
        return true;
    }
 
    public function removeCurrentWindow() : void{
        $this->doCloseInventory();
        if($this->currentWindow !== null){
            $currentWindow = $this->currentWindow;
            $this->logger->debug("Closing inventory window " . get_class($this->currentWindow) . "#" . spl_object_id($this->currentWindow));
            $this->currentWindow->onClose();
            if(($inventoryManager = $this->getNetworkSession()->getInvManager()) !== null){
                $inventoryManager->onCurrentWindowRemove();
            }
            $this->currentWindow = null;
            (new InventoryCloseEvent($currentWindow, $this))->call();
        }
    }
 
    protected function addPermanentWindows(array $windows) : void{
        foreach($windows as $window){
            $window->onOpen();
            $this->permanentWindows[spl_object_id($window)] = $window;
        }
    }
 
    protected function removePermanentWindows() : void{
        foreach($this->permanentWindows as $window){
            $window->onClose();
        }
        $this->permanentWindows = [];
    }
 
    public function getPermanentWindows() : array{
        return $this->permanentWindows;
    }
 
    public function openSignEditor(Vector3 $position, bool $frontFace = true) : void{
        $block = $this->getWorld()->getBlock($position);
        if($block instanceof BaseSign){
            $this->getWorld()->setBlock($position, $block->setEditorEntityRuntimeId($this->getId()));
            $this->getNetworkSession()->onOpenSignEditor($position, $frontFace);
        }else{
            throw new \InvalidArgumentException("Block at this position is not a sign");
        }
    }
 
    use ChunkListenerNoOpTrait {
        onChunkChanged as private;
        onChunkUnloaded as private;
    }
 
    public function onChunkChanged(int $chunkX, int $chunkZ, Chunk $chunk) : void{
        $status = $this->usedChunks[$hash = World::chunkHash($chunkX, $chunkZ)] ?? null;
        if($status === UsedChunkStatus::SENT){
            $this->usedChunks[$hash] = UsedChunkStatus::NEEDED;
            $this->nextChunkOrderRun = 0;
        }
    }
 
    public function onChunkUnloaded(int $chunkX, int $chunkZ, Chunk $chunk) : void{
        if($this->isUsingChunk($chunkX, $chunkZ)){
            $this->logger->debug("Detected forced unload of chunk " . $chunkX . " " . $chunkZ);
            $this->unloadChunk($chunkX, $chunkZ);
        }
    }
}