Packet.h

#pragma once
 
#include "mc/_HeaderOutputPredefine.h"
 
// auto generated inclusion list
#include "mc/common/SubClientId.h"
#include "mc/deps/raknet/PacketPriority.h"
#include "mc/network/Compressibility.h"
#include "mc/network/MinecraftPacketIds.h"
#include "mc/network/NetworkPeer.h"
#include "mc/network/packet/cerealize/core/SerializationMode.h"
#include "mc/platform/Result.h"
 
// auto generated forward declare list
// clang-format off
class BinaryStream;
class IPacketHandlerDispatcher;
class NetEventCallback;
class NetworkIdentifier;
class ReadOnlyBinaryStream;
namespace cereal { struct ReflectionCtx; }
// clang-format on
 
class Player;
class Actor;
class BlockPos;
class NetworkIdentifier;
struct NetworkIdentifierWithSubId;
 
class Packet {
public:
    [[nodiscard]] constexpr explicit Packet(
        PacketPriority           priority    = PacketPriority::MediumPriority,
        NetworkPeer::Reliability reliability = NetworkPeer::Reliability::ReliableOrdered,
        SubClientId              clientSubId = SubClientId::PrimaryClient,
        bool                     compress    = true
    )
    : mPriority(priority),
      mReliability(reliability),
      mSenderSubId(clientSubId),
      mCompressible(compress ? Compressibility::Compressible : Compressibility::Incompressible) {}

    LLAPI void sendTo(Player const& player) const;

    LLAPI void sendTo(BlockPos const& pos, DimensionType dimId, optional_ref<Player const> except = std::nullopt) const;

    LLAPI void sendTo(Actor const& actor, optional_ref<Player const> except = std::nullopt) const;

    LLAPI void sendToClient(NetworkIdentifier const& identifier, ::SubClientId clientId) const;
 
    LLAPI void sendToClient(NetworkIdentifierWithSubId const& identifierWithSubId) const;

    LLAPI void sendToClients() const;
 
    LLAPI void sendToClients(NetworkIdentifier const& exceptId, ::SubClientId exceptSubid) const;
 
    LLAPI void sendToServer() const;
 
public:
    // member variables
    // NOLINTBEGIN
    ::PacketPriority                        mPriority;
    ::NetworkPeer::Reliability              mReliability;
    ::SubClientId                           mSenderSubId;
    bool                                    mIsHandled;
    ::std::chrono::steady_clock::time_point mReceiveTimepoint;
    ::IPacketHandlerDispatcher const*       mHandler;
    ::Compressibility                       mCompressible;
    // NOLINTEND
 
public:
    // virtual functions
    // NOLINTBEGIN
    virtual ~Packet() = default;
 
    virtual ::MinecraftPacketIds getId() const = 0;
 
    virtual ::std::string_view getName() const = 0;
 
    virtual uint64 getMaxSize() const;
 
    virtual ::Bedrock::Result<void> checkSize(uint64 packetSize, bool receiverIsServer) const;
 
    virtual void writeWithSerializationMode(
        ::BinaryStream&                      stream,
        ::cereal::ReflectionCtx const&       reflectionCtx,
        ::std::optional<::SerializationMode> overrideMode
    ) const;
 
    virtual void write(::BinaryStream& stream, ::cereal::ReflectionCtx const& reflectionCtx) const;
 
    virtual void write(::BinaryStream& stream) const = 0;
 
    virtual ::Bedrock::Result<void>
    read(::ReadOnlyBinaryStream& bitStream, ::cereal::ReflectionCtx const& reflectionCtx);
 
    virtual ::Bedrock::Result<void> read(::ReadOnlyBinaryStream& bitStream);
 
    virtual bool disallowBatching() const;
 
    virtual bool isValid() const;
 
    virtual ::SerializationMode getSerializationMode() const;
 
    virtual void setSerializationMode(::SerializationMode mode);
 
    virtual ::std::string toString() const;
 
    virtual ::Bedrock::Result<void> _read(::ReadOnlyBinaryStream& stream, ::cereal::ReflectionCtx const& reflectionCtx);
 
    virtual ::Bedrock::Result<void> _read(::ReadOnlyBinaryStream& stream) = 0;
    // NOLINTEND
 
public:
    // member functions
    // NOLINTBEGIN
    MCAPI void
    handle(::NetworkIdentifier const& source, ::NetEventCallback& callback, ::std::shared_ptr<::Packet>& packet);
 
    MCAPI ::Bedrock::Result<void> readNoHeader(
        ::ReadOnlyBinaryStream&        bitstream,
        ::cereal::ReflectionCtx const& reflectionCtx,
        ::SubClientId const&           subid
    );
    // NOLINTEND
 
public:
    // virtual function thunks
    // NOLINTBEGIN
    MCAPI uint64 $getMaxSize() const;
 
    MCAPI ::Bedrock::Result<void> $checkSize(uint64 packetSize, bool receiverIsServer) const;
 
    MCAPI void $writeWithSerializationMode(
        ::BinaryStream&                      stream,
        ::cereal::ReflectionCtx const&       reflectionCtx,
        ::std::optional<::SerializationMode> overrideMode
    ) const;
 
    MCFOLD void $write(::BinaryStream& stream, ::cereal::ReflectionCtx const& reflectionCtx) const;
 
    MCFOLD ::Bedrock::Result<void>
    $read(::ReadOnlyBinaryStream& bitStream, ::cereal::ReflectionCtx const& reflectionCtx);
 
    MCAPI ::Bedrock::Result<void> $read(::ReadOnlyBinaryStream& bitStream);
 
    MCFOLD bool $disallowBatching() const;
 
    MCFOLD bool $isValid() const;
 
    MCFOLD ::SerializationMode $getSerializationMode() const;
 
    MCFOLD void $setSerializationMode(::SerializationMode mode);
 
    MCFOLD ::std::string $toString() const;
 
    MCFOLD ::Bedrock::Result<void> $_read(::ReadOnlyBinaryStream& stream, ::cereal::ReflectionCtx const& reflectionCtx);
 
 
    // NOLINTEND
 
public:
    // vftables
    // NOLINTBEGIN
    MCAPI static void** $vftable();
    // NOLINTEND
};
 
namespace ll {
template <class PacketPayloadT>
class PayloadPacket : public ::Packet, public PacketPayloadT {
public:
    using PayloadType = PacketPayloadT;
 
    template <typename... Args>
    PayloadPacket(Args&&... args) : Packet(),
                                    PacketPayloadT(std::forward<Args>(args)...) {}
};
} // namespace ll