NetworkSystem.h

#pragma once
 
#include "mc/_HeaderOutputPredefine.h"
 
// auto generated inclusion list
#include "mc/common/SubClientId.h"
#include "mc/deps/core/threading/Async.h"
#include "mc/deps/core/utility/BinaryStream.h"
#include "mc/deps/core/utility/NonOwnerPointer.h"
#include "mc/deps/core/utility/pub_sub/Connector.h"
#include "mc/deps/core/utility/pub_sub/Publisher.h"
#include "mc/network/DevConnectionQuality.h"
#include "mc/network/NetworkEnableDisableListener.h"
#include "mc/network/NetworkSettingOptions.h"
#include "mc/network/PacketGroupDefinition.h"
#include "mc/network/RakNetConnector.h"
#include "mc/network/RakPeerHelper.h"
#include "mc/network/TransportLayer.h"
#include "mc/network/connection/DisconnectFailReason.h"
#include "mc/platform/threading/Mutex.h"
 
// auto generated forward declare list
// clang-format off
class AppPlatform;
class CompressedNetworkPeer;
class EncryptedNetworkPeer;
class IPacketObserver;
class IPacketSerializationController;
class LocalConnector;
class NetEventCallback;
class NetworkConnection;
class NetworkIdentifier;
class NetworkPeer;
class NetworkSessionOwner;
class NetworkStatistics;
class Packet;
class RemoteConnector;
class Scheduler;
class ServerLocator;
class TaskGroup;
class WeakEntityRef;
struct NetworkIdentifierWithSubId;
namespace Bedrock::PubSub::ThreadModel { struct MultiThreaded; }
namespace Json { class Value; }
namespace cereal { struct ReflectionCtx; }
// clang-format on
 
class NetworkSystem : public ::RakNetConnector::ConnectionCallbacks,
                      public ::RakPeerHelper::IPSupportInterface,
                      public ::NetworkEnableDisableListener {
public:
    // NetworkSystem inner types declare
    // clang-format off
    struct Dependencies;
    struct IncomingPacketQueue;
    // clang-format on
 
    // NetworkSystem inner types define
    struct Dependencies {
    public:
        // member variables
        // NOLINTBEGIN
        ::ll::TypedStorage<8, 8, ::std::reference_wrapper<::Scheduler>>                 receiveThread;
        ::ll::TypedStorage<8, 8, ::std::unique_ptr<::RemoteConnector>>                  remoteConnector;
        ::ll::TypedStorage<8, 8, ::std::unique_ptr<::ServerLocator>>                    serverLocator;
        ::ll::TypedStorage<8, 24, ::Bedrock::NonOwnerPointer<::AppPlatform>>            appPlatform;
        ::ll::TypedStorage<8, 24, ::Bedrock::NotNullNonOwnerPtr<::NetworkSessionOwner>> networkSessionOwner;
        ::ll::TypedStorage<4, 20, ::NetworkSettingOptions>                              networkSettingOptions;
        ::ll::TypedStorage<8, 8, ::std::unique_ptr<::IPacketSerializationController>>   serializationController;
        // NOLINTEND
 
    public:
        // member functions
        // NOLINTBEGIN
        MCNAPI ~Dependencies();
        // NOLINTEND
 
    public:
        // destructor thunk
        // NOLINTBEGIN
        MCNAPI void $dtor();
        // NOLINTEND
    };
 
    struct IncomingPacketQueue {
    public:
        // member variables
        // NOLINTBEGIN
        ::ll::TypedStorage<8, 8, ::NetEventCallback&>          mCallbacksObj;
        ::ll::TypedStorage<8, 80, ::Bedrock::Threading::Mutex> mMutex;
        // NOLINTEND
 
    public:
        // prevent constructor by default
        IncomingPacketQueue& operator=(IncomingPacketQueue const&);
        IncomingPacketQueue(IncomingPacketQueue const&);
        IncomingPacketQueue();
    };
 
public:
    // member variables
    // NOLINTBEGIN
    ::ll::TypedStorage<8, 24, ::Bedrock::NotNullNonOwnerPtr<::NetworkSessionOwner>>           mNetworkSessionOwner;
    ::ll::TypedStorage<8, 80, ::std::recursive_mutex>                                         mConnectionsMutex;
    ::ll::TypedStorage<8, 24, ::std::vector<::std::unique_ptr<::NetworkConnection>>>          mConnections;
    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::LocalConnector>>                             mLocalConnector;
    ::ll::TypedStorage<8, 16, ::std::shared_ptr<::PacketGroupDefinition::PacketGroupBuilder>> mPacketGroupBuilder;
    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::RemoteConnector>>                            mRemoteConnector;
    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::ServerLocator>>                              mServerLocator;
    ::ll::TypedStorage<8, 8, uint64>                                                          mCurrentConnection;
    ::ll::TypedStorage<8, 16, ::Bedrock::Threading::Async<void>>                              mReceiveTask;
    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::TaskGroup>>                                  mReceiveTaskGroup;
    ::ll::TypedStorage<8, 24, ::Bedrock::NonOwnerPointer<::IPacketObserver>>                  mPacketObserver;
    ::ll::TypedStorage<8, 8, ::Scheduler&>                                                    mMainThread;
    ::ll::TypedStorage<8, 32, ::std::string>                                                  mReceiveBuffer;
    ::ll::TypedStorage<8, 32, ::std::string>                                                  mSendBuffer;
    ::ll::TypedStorage<8, 80, ::BinaryStream>                                                 mSendStream;
    ::ll::TypedStorage<8, 32, ::std::unique_ptr<::NetworkSystem::IncomingPacketQueue>[4]>     mIncomingPackets;
    ::ll::TypedStorage<1, 1, bool>                                                            mUseIPv6Only;
    ::ll::TypedStorage<2, 2, ushort>                                                          mDefaultGamePort;
    ::ll::TypedStorage<2, 2, ushort>                                                          mDefaultGamePortv6;
    ::ll::TypedStorage<1, 1, bool>                                                            mIsLanDiscoveryEnabled;
    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::NetworkStatistics>>                          mNetworkStatistics;
    ::ll::TypedStorage<1, 1, bool>                                                            mWebsocketsEnabled;
    ::ll::TypedStorage<4, 20, ::NetworkSettingOptions>                                        mNetworkSettingOptions;
    ::ll::TypedStorage<1, 1, bool>                                                            mRawRecordingEnabled;
    ::ll::TypedStorage<8, 8, ::gsl::not_null<::std::unique_ptr<::cereal::ReflectionCtx>>>     mReflectionCtx;
    ::ll::TypedStorage<8, 8, ::gsl::not_null<::std::unique_ptr<::IPacketSerializationController>>> mPacketOverrides;
    ::ll::TypedStorage<
        8,
        8,
        ::gsl::not_null<::std::unique_ptr<
            ::Bedrock::PubSub::
                Publisher<void(::Json::Value const&), ::Bedrock::PubSub::ThreadModel::MultiThreaded, 0>>>>
        mSessionSummaryPublisher;
    // NOLINTEND
 
public:
    // prevent constructor by default
    NetworkSystem& operator=(NetworkSystem const&);
    NetworkSystem(NetworkSystem const&);
    NetworkSystem();
 
public:
    LLNDAPI NetworkConnection* getConnectionFromId(NetworkIdentifier const& id);
 
public:
    // virtual functions
    // NOLINTBEGIN
    virtual bool useIPv4Only() const /*override*/;
 
    virtual bool useIPv6Only() const /*override*/;
 
    virtual ushort getDefaultGamePort() const /*override*/;
 
    virtual ushort getDefaultGamePortv6() const /*override*/;
 
    virtual ~NetworkSystem() /*override*/;
 
    virtual void _onDisable() /*override*/;
 
    virtual void _onEnable() /*override*/;
 
    virtual bool
    onNewIncomingConnection(::NetworkIdentifier const& id, ::std::shared_ptr<::NetworkPeer>&& peer) /*override*/;
 
    virtual bool
    onNewOutgoingConnection(::NetworkIdentifier const& id, ::std::shared_ptr<::NetworkPeer>&& peer) /*override*/;
 
    virtual void onConnectionClosed(
        ::NetworkIdentifier const&               id,
        ::Connection::DisconnectFailReason const discoReason,
        ::std::string const&                     messageFromServer,
        ::std::string const&                     messageBodyOverride,
        bool                                     skipDisconnectMessage,
        ::Json::Value const&                     sessionSummary
    ) /*override*/;
 
    virtual void
    onAllConnectionsClosed(::Connection::DisconnectFailReason discoReason, bool skipDisconnectMessage) /*override*/;
 
    virtual void onAllRemoteConnectionsClosed(
        ::Connection::DisconnectFailReason discoReason,
        bool                               skipDisconnectMessage
    ) /*override*/;
 
    virtual void onOutgoingConnectionFailed(::Connection::DisconnectFailReason discoReason) /*override*/;
 
    virtual void onWebsocketRequest(
        ::std::string const&    serverAddress,
        ::std::string const&    payload,
        ::std::function<void()> errorCallback
    ) /*override*/;
    // NOLINTEND
 
public:
    // member functions
    // NOLINTBEGIN
    MCAPI explicit NetworkSystem(::NetworkSystem::Dependencies&& deps);
 
    MCAPI ::TransportLayer _getTransportLayer() const;
 
    MCAPI void _initNetworkStatistics(::std::unique_ptr<::NetworkStatistics>&& stats);
 
    MCAPI bool _isUsingNetherNetTransportLayer() const;
 
    MCAPI void _sendInternal(::NetworkIdentifier const& id, ::Packet const& packet, ::std::string const& data);
 
#ifdef LL_PLAT_C
    MCAPI void _setDisableLanSignaling(bool disableLanSignaling);
#endif
 
    MCAPI bool
    _sortAndPacketizeEvents(::NetworkConnection& connection, ::std::chrono::steady_clock::time_point endTime);
 
#ifdef LL_PLAT_C
    MCAPI void closeConnection(
        ::NetworkIdentifier const&         id,
        ::Connection::DisconnectFailReason discoReason,
        ::std::string const&               messageFromServer
    );
#endif
 
    MCAPI void disconnect();
 
    MCAPI void enableAsyncFlush(::NetworkIdentifier const& id);
 
    MCAPI ::std::weak_ptr<::CompressedNetworkPeer> getCompressedPeerForUser(::NetworkIdentifier const& id);
 
    MCFOLD ::std::vector<::std::unique_ptr<::NetworkConnection>> const& getConnections() const;
 
    MCAPI ::std::weak_ptr<::EncryptedNetworkPeer> getEncryptedPeerForUser(::NetworkIdentifier const& id);
 
#ifdef LL_PLAT_S
    MCFOLD ::NetworkStatistics const* getNetworkStatistics() const;
#endif
 
    MCAPI ::NetworkPeer* getPeerForUser(::NetworkIdentifier const& id);
 
    MCFOLD ::Bedrock::NotNullNonOwnerPtr<::RemoteConnector const> getRemoteConnector() const;
 
    MCFOLD ::Bedrock::NotNullNonOwnerPtr<::RemoteConnector> getRemoteConnector();
 
    MCFOLD ::ServerLocator& getServerLocator();
 
#ifdef LL_PLAT_C
    MCAPI ::Bedrock::PubSub::Connector<void(::Json::Value const&)>& getSessionSummaryCallback();
 
    MCAPI bool hasNetworkSession() const;
 
    MCAPI bool isNetherNetEnabled() const;
#endif
 
    MCAPI bool isServer() const;
 
#ifdef LL_PLAT_C
    MCAPI void registerClientInstance(::NetEventCallback& callback, ::SubClientId subID);
#endif
 
    MCAPI void registerServerInstance(::NetEventCallback& callback);
 
    MCAPI void runEvents(bool networkIsCritical);
 
    MCAPI void send(::NetworkIdentifier const& id, ::Packet const& packet, ::SubClientId recipientSubId);
 
    MCAPI void sendToMultiple(::std::vector<::NetworkIdentifierWithSubId> const& ids, ::Packet const& packet);
 
    MCAPI void setCloseConnection(::NetworkIdentifier const& id);
 
#ifdef LL_PLAT_C
    MCAPI void setConnectionChannelPaused(::NetworkIdentifier const& id, uint channel, bool paused);
 
    MCAPI void setDefaultGamePort(ushort defaultPort);
 
    MCAPI void setDefaultGamePortv6(ushort defaultPortv6);
 
    MCAPI void setDevConnectionQuality(::DevConnectionQuality quality);
 
    MCAPI void setUseIPv6Only(bool useIPv6Only);
#endif
 
    MCAPI void unregisterClientOrServerInstance(::SubClientId const& subID);
 
    MCAPI void update(::std::vector<::WeakEntityRef> const* userList);
    // NOLINTEND
 
public:
    // constructor thunks
    // NOLINTBEGIN
    MCAPI void* $ctor(::NetworkSystem::Dependencies&& deps);
    // NOLINTEND
 
public:
    // destructor thunk
    // NOLINTBEGIN
    MCAPI void $dtor();
    // NOLINTEND
 
public:
    // virtual function thunks
    // NOLINTBEGIN
    MCFOLD bool $useIPv4Only() const;
 
    MCAPI bool $useIPv6Only() const;
 
    MCAPI ushort $getDefaultGamePort() const;
 
    MCAPI ushort $getDefaultGamePortv6() const;
 
    MCAPI void $_onDisable();
 
    MCAPI void $_onEnable();
 
    MCAPI bool $onNewIncomingConnection(::NetworkIdentifier const& id, ::std::shared_ptr<::NetworkPeer>&& peer);
 
    MCAPI bool $onNewOutgoingConnection(::NetworkIdentifier const& id, ::std::shared_ptr<::NetworkPeer>&& peer);
 
    MCAPI void $onConnectionClosed(
        ::NetworkIdentifier const&               id,
        ::Connection::DisconnectFailReason const discoReason,
        ::std::string const&                     messageFromServer,
        ::std::string const&                     messageBodyOverride,
        bool                                     skipDisconnectMessage,
        ::Json::Value const&                     sessionSummary
    );
 
    MCAPI void $onAllConnectionsClosed(::Connection::DisconnectFailReason discoReason, bool skipDisconnectMessage);
 
    MCAPI void
    $onAllRemoteConnectionsClosed(::Connection::DisconnectFailReason discoReason, bool skipDisconnectMessage);
 
    MCAPI void $onOutgoingConnectionFailed(::Connection::DisconnectFailReason discoReason);
 
    MCAPI void $onWebsocketRequest(
        ::std::string const&    serverAddress,
        ::std::string const&    payload,
        ::std::function<void()> errorCallback
    );
 
 
    // NOLINTEND
 
public:
    // vftables
    // NOLINTBEGIN
    MCNAPI static void** $vftableForConnectionCallbacks();
 
    MCNAPI static void** $vftableForIPSupportInterface();
 
    MCNAPI static void** $vftableForNetworkEnableDisableListener();
    // NOLINTEND
};