PlayerAuthInputPacket.php

<?php
 
/*
 * This file is part of BedrockProtocol.
 * Copyright (C) 2014-2022 PocketMine Team <https://github.com/pmmp/BedrockProtocol>
 *
 * BedrockProtocol 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.
 */
 
declare(strict_types=1);
 
namespace pocketmine\network\mcpe\protocol;
 
use pmmp\encoding\ByteBufferReader;
use pmmp\encoding\ByteBufferWriter;
use pmmp\encoding\LE;
use pmmp\encoding\VarInt;
use pocketmine\math\Vector2;
use pocketmine\math\Vector3;
use pocketmine\network\mcpe\protocol\serializer\BitSet;
use pocketmine\network\mcpe\protocol\serializer\CommonTypes;
use pocketmine\network\mcpe\protocol\types\InputMode;
use pocketmine\network\mcpe\protocol\types\InteractionMode;
use pocketmine\network\mcpe\protocol\types\inventory\stackrequest\ItemStackRequest;
use pocketmine\network\mcpe\protocol\types\ItemInteractionData;
use pocketmine\network\mcpe\protocol\types\PlayerAction;
use pocketmine\network\mcpe\protocol\types\PlayerAuthInputFlags;
use pocketmine\network\mcpe\protocol\types\PlayerAuthInputVehicleInfo;
use pocketmine\network\mcpe\protocol\types\PlayerBlockAction;
use pocketmine\network\mcpe\protocol\types\PlayerBlockActionStopBreak;
use pocketmine\network\mcpe\protocol\types\PlayerBlockActionWithBlockInfo;
use pocketmine\network\mcpe\protocol\types\PlayMode;
use function count;
 
class PlayerAuthInputPacket extends DataPacket implements ServerboundPacket{
    public const NETWORK_ID = ProtocolInfo::PLAYER_AUTH_INPUT_PACKET;
 
    private Vector3 $position;
    private float $pitch;
    private float $yaw;
    private float $headYaw;
    private float $moveVecX;
    private float $moveVecZ;
    private BitSet $inputFlags;
    private int $inputMode;
    private int $playMode;
    private int $interactionMode;
    private Vector2 $interactRotation;
    private int $tick;
    private Vector3 $delta;
    private ?ItemInteractionData $itemInteractionData = null;
    private ?ItemStackRequest $itemStackRequest = null;
    private ?array $blockActions = null;
    private ?PlayerAuthInputVehicleInfo $vehicleInfo = null;
    private float $analogMoveVecX;
    private float $analogMoveVecZ;
    private Vector3 $cameraOrientation;
    private Vector2 $rawMove;
 
    private static function internalCreate(
        Vector3 $position,
        float $pitch,
        float $yaw,
        float $headYaw,
        float $moveVecX,
        float $moveVecZ,
        BitSet $inputFlags,
        int $inputMode,
        int $playMode,
        int $interactionMode,
        Vector2 $interactRotation,
        int $tick,
        Vector3 $delta,
        ?ItemInteractionData $itemInteractionData,
        ?ItemStackRequest $itemStackRequest,
        ?array $blockActions,
        ?PlayerAuthInputVehicleInfo $vehicleInfo,
        float $analogMoveVecX,
        float $analogMoveVecZ,
        Vector3 $cameraOrientation,
        Vector2 $rawMove,
    ) : self{
        $result = new self;
        $result->position = $position;
        $result->pitch = $pitch;
        $result->yaw = $yaw;
        $result->headYaw = $headYaw;
        $result->moveVecX = $moveVecX;
        $result->moveVecZ = $moveVecZ;
        $result->inputFlags = $inputFlags;
        $result->inputMode = $inputMode;
        $result->playMode = $playMode;
        $result->interactionMode = $interactionMode;
        $result->interactRotation = $interactRotation;
        $result->tick = $tick;
        $result->delta = $delta;
        $result->itemInteractionData = $itemInteractionData;
        $result->itemStackRequest = $itemStackRequest;
        $result->blockActions = $blockActions;
        $result->vehicleInfo = $vehicleInfo;
        $result->analogMoveVecX = $analogMoveVecX;
        $result->analogMoveVecZ = $analogMoveVecZ;
        $result->cameraOrientation = $cameraOrientation;
        $result->rawMove = $rawMove;
        return $result;
    }
 
    public static function create(
        Vector3 $position,
        float $pitch,
        float $yaw,
        float $headYaw,
        float $moveVecX,
        float $moveVecZ,
        BitSet $inputFlags,
        int $inputMode,
        int $playMode,
        int $interactionMode,
        Vector2 $interactRotation,
        int $tick,
        Vector3 $delta,
        ?ItemInteractionData $itemInteractionData,
        ?ItemStackRequest $itemStackRequest,
        ?array $blockActions,
        ?PlayerAuthInputVehicleInfo $vehicleInfo,
        float $analogMoveVecX,
        float $analogMoveVecZ,
        Vector3 $cameraOrientation,
        Vector2 $rawMove
    ) : self{
        if($inputFlags->getLength() !== PlayerAuthInputFlags::NUMBER_OF_FLAGS){
            throw new \InvalidArgumentException("Input flags must be " . PlayerAuthInputFlags::NUMBER_OF_FLAGS . " bits long");
        }
 
        $inputFlags->set(PlayerAuthInputFlags::PERFORM_ITEM_STACK_REQUEST, $itemStackRequest !== null);
        $inputFlags->set(PlayerAuthInputFlags::PERFORM_ITEM_INTERACTION, $itemInteractionData !== null);
        $inputFlags->set(PlayerAuthInputFlags::PERFORM_BLOCK_ACTIONS, $blockActions !== null);
        $inputFlags->set(PlayerAuthInputFlags::IN_CLIENT_PREDICTED_VEHICLE, $vehicleInfo !== null);
 
        return self::internalCreate(
            $position,
            $pitch,
            $yaw,
            $headYaw,
            $moveVecX,
            $moveVecZ,
            $inputFlags,
            $inputMode,
            $playMode,
            $interactionMode,
            $interactRotation,
            $tick,
            $delta,
            $itemInteractionData,
            $itemStackRequest,
            $blockActions,
            $vehicleInfo,
            $analogMoveVecX,
            $analogMoveVecZ,
            $cameraOrientation,
            $rawMove
        );
    }
 
    public function getPosition() : Vector3{
        return $this->position;
    }
 
    public function getPitch() : float{
        return $this->pitch;
    }
 
    public function getYaw() : float{
        return $this->yaw;
    }
 
    public function getHeadYaw() : float{
        return $this->headYaw;
    }
 
    public function getMoveVecX() : float{
        return $this->moveVecX;
    }
 
    public function getMoveVecZ() : float{
        return $this->moveVecZ;
    }
 
    public function getInputFlags() : BitSet{
        return $this->inputFlags;
    }
 
    public function getInputMode() : int{
        return $this->inputMode;
    }
 
    public function getPlayMode() : int{
        return $this->playMode;
    }
 
    public function getInteractionMode() : int{
        return $this->interactionMode;
    }
 
    public function getInteractRotation() : Vector2{ return $this->interactRotation; }
 
    public function getTick() : int{
        return $this->tick;
    }
 
    public function getDelta() : Vector3{
        return $this->delta;
    }
 
    public function getItemInteractionData() : ?ItemInteractionData{
        return $this->itemInteractionData;
    }
 
    public function getItemStackRequest() : ?ItemStackRequest{
        return $this->itemStackRequest;
    }
 
    public function getBlockActions() : ?array{
        return $this->blockActions;
    }
 
    public function getVehicleInfo() : ?PlayerAuthInputVehicleInfo{ return $this->vehicleInfo; }
 
    public function getAnalogMoveVecX() : float{ return $this->analogMoveVecX; }
 
    public function getAnalogMoveVecZ() : float{ return $this->analogMoveVecZ; }
 
    public function getCameraOrientation() : Vector3{ return $this->cameraOrientation; }
 
    public function getRawMove() : Vector2{ return $this->rawMove; }
 
    protected function decodePayload(ByteBufferReader $in) : void{
        $this->pitch = LE::readFloat($in);
        $this->yaw = LE::readFloat($in);
        $this->position = CommonTypes::getVector3($in);
        $this->moveVecX = LE::readFloat($in);
        $this->moveVecZ = LE::readFloat($in);
        $this->headYaw = LE::readFloat($in);
        $this->inputFlags = BitSet::read($in, PlayerAuthInputFlags::NUMBER_OF_FLAGS);
        $this->inputMode = VarInt::readUnsignedInt($in);
        $this->playMode = VarInt::readUnsignedInt($in);
        $this->interactionMode = VarInt::readUnsignedInt($in);
        $this->interactRotation = CommonTypes::getVector2($in);
        $this->tick = VarInt::readUnsignedLong($in);
        $this->delta = CommonTypes::getVector3($in);
        if($this->inputFlags->get(PlayerAuthInputFlags::PERFORM_ITEM_INTERACTION)){
            $this->itemInteractionData = ItemInteractionData::read($in);
        }
        if($this->inputFlags->get(PlayerAuthInputFlags::PERFORM_ITEM_STACK_REQUEST)){
            $this->itemStackRequest = ItemStackRequest::read($in);
        }
        if($this->inputFlags->get(PlayerAuthInputFlags::PERFORM_BLOCK_ACTIONS)){
            $this->blockActions = [];
            $max = VarInt::readSignedInt($in);
            for($i = 0; $i < $max; ++$i){
                $actionType = VarInt::readSignedInt($in);
                $this->blockActions[] = match(true){
                    PlayerBlockActionWithBlockInfo::isValidActionType($actionType) => PlayerBlockActionWithBlockInfo::read($in, $actionType),
                    $actionType === PlayerAction::STOP_BREAK => new PlayerBlockActionStopBreak(),
                    default => throw new PacketDecodeException("Unexpected block action type $actionType")
                };
            }
        }
        if($this->inputFlags->get(PlayerAuthInputFlags::IN_CLIENT_PREDICTED_VEHICLE)){
            $this->vehicleInfo = PlayerAuthInputVehicleInfo::read($in);
        }
        $this->analogMoveVecX = LE::readFloat($in);
        $this->analogMoveVecZ = LE::readFloat($in);
        $this->cameraOrientation = CommonTypes::getVector3($in);
        $this->rawMove = CommonTypes::getVector2($in);
    }
 
    protected function encodePayload(ByteBufferWriter $out) : void{
        LE::writeFloat($out, $this->pitch);
        LE::writeFloat($out, $this->yaw);
        CommonTypes::putVector3($out, $this->position);
        LE::writeFloat($out, $this->moveVecX);
        LE::writeFloat($out, $this->moveVecZ);
        LE::writeFloat($out, $this->headYaw);
        $this->inputFlags->write($out);
        VarInt::writeUnsignedInt($out, $this->inputMode);
        VarInt::writeUnsignedInt($out, $this->playMode);
        VarInt::writeUnsignedInt($out, $this->interactionMode);
        CommonTypes::putVector2($out, $this->interactRotation);
        VarInt::writeUnsignedLong($out, $this->tick);
        CommonTypes::putVector3($out, $this->delta);
        if($this->itemInteractionData !== null){
            $this->itemInteractionData->write($out);
        }
        if($this->itemStackRequest !== null){
            $this->itemStackRequest->write($out);
        }
        if($this->blockActions !== null){
            VarInt::writeSignedInt($out, count($this->blockActions));
            foreach($this->blockActions as $blockAction){
                VarInt::writeSignedInt($out, $blockAction->getActionType());
                $blockAction->write($out);
            }
        }
        if($this->vehicleInfo !== null){
            $this->vehicleInfo->write($out);
        }
        LE::writeFloat($out, $this->analogMoveVecX);
        LE::writeFloat($out, $this->analogMoveVecZ);
        CommonTypes::putVector3($out, $this->cameraOrientation);
        CommonTypes::putVector2($out, $this->rawMove);
    }
 
    public function handle(PacketHandlerInterface $handler) : bool{
        return $handler->handlePlayerAuthInput($this);
    }
}