ServerWorldJoiner.h

#pragma once
 
#include "mc/_HeaderOutputPredefine.h"
 
// auto generated inclusion list
#include "mc/client/world/JoinServerWorldResult.h"
#include "mc/deps/core/threading/Async.h"
#include "mc/deps/core/utility/NonOwnerPointer.h"
 
// auto generated forward declare list
// clang-format off
class ExperienceSystemsManager;
class IAppPlatform;
class IClientInstance;
class IMinecraftEventing;
class INetworkGameConnector;
class IThirdPartyServerRepository;
class ProgressHandler;
class ServerLocator;
class TaskGroup;
struct ExperienceJoinRequestInfo;
struct NetworkWorldInfo;
struct PlayerJoinWorldContext;
namespace Network { struct ServerID; }
namespace OreUI { class Router; }
namespace Parties { class IPartyProvider; }
namespace Social { class GameConnectionInfo; }
namespace Social { class IUserManager; }
namespace World { class ExternalServerWorldList; }
namespace World { class FriendServerWorldList; }
namespace World { class IServerURLResolver; }
namespace World { class LanServerWorldList; }
namespace World { class ThirdPartyWorldList; }
namespace World { struct RecentlyPlayedPendingTargetData; }
// clang-format on
 
namespace World {
 
class ServerWorldJoiner {
public:
    // ServerWorldJoiner inner types define
    enum class ServerType : int {
        ThirdParty       = 0,
        ExternalServer   = 1,
        ExperienceServer = 2,
    };
 
public:
    // member variables
    // NOLINTBEGIN
    ::ll::TypedStorage<8, 8, ::IClientInstance&>                                            mClient;
    ::ll::TypedStorage<8, 8, ::IMinecraftEventing&>                                         mMinecraftEventing;
    ::ll::TypedStorage<8, 24, ::Bedrock::NonOwnerPointer<::Social::IUserManager>>           mUserManager;
    ::ll::TypedStorage<8, 24, ::Bedrock::NonOwnerPointer<::IAppPlatform>>                   mAppPlatform;
    ::ll::TypedStorage<8, 24, ::Bedrock::NotNullNonOwnerPtr<::IThirdPartyServerRepository>> mThirdPartyServerRepository;
    ::ll::TypedStorage<8, 8, ::ServerLocator&>                                              mServerLocator;
    ::ll::TypedStorage<8, 8, ::World::IServerURLResolver&>                                  mServerURLResolver;
    ::ll::TypedStorage<8, 8, ::std::unique_ptr<::TaskGroup>>                                mTaskGroup;
    ::ll::TypedStorage<8, 8, ::INetworkGameConnector&>                                      mNetworkGameConnector;
    ::ll::TypedStorage<8, 8, ::World::ExternalServerWorldList&>                             mExternalServerWorldList;
    ::ll::TypedStorage<8, 8, ::World::FriendServerWorldList&>                               mFriendServerWorldList;
    ::ll::TypedStorage<8, 8, ::World::LanServerWorldList&>                                  mLanServerWorldList;
    ::ll::TypedStorage<8, 8, ::World::ThirdPartyWorldList&>                                 mThirdPartyWorldList;
    ::ll::TypedStorage<1, 1, bool>                                                          mIsEduMode;
    ::ll::TypedStorage<8, 24, ::Bedrock::NotNullNonOwnerPtr<::ExperienceSystemsManager>>    mExperienceSystemsManager;
    ::ll::TypedStorage<8, 64, ::std::function<::Bedrock::NonOwnerPointer<::Parties::IPartyProvider>()>>
                                               mGetPartyProvider;
    ::ll::TypedStorage<8, 8, ::OreUI::Router&> mRouter;
    ::ll::TypedStorage<8, 64, ::std::function<void(::World::RecentlyPlayedPendingTargetData)>>
                                                                      mPrepareRecentlyPlayedTarget;
    ::ll::TypedStorage<8, 8, ::std::chrono::steady_clock::time_point> mServerConnectionTime;
    // NOLINTEND
 
public:
    // prevent constructor by default
    ServerWorldJoiner& operator=(ServerWorldJoiner const&);
    ServerWorldJoiner(ServerWorldJoiner const&);
    ServerWorldJoiner();
 
public:
    // member functions
    // NOLINTBEGIN
    MCNAPI ServerWorldJoiner(
        ::IClientInstance&                                                       client,
        ::IMinecraftEventing&                                                    minecraftEventing,
        ::Bedrock::NotNullNonOwnerPtr<::Social::IUserManager> const&             userManager,
        ::Bedrock::NonOwnerPointer<::IAppPlatform> const&                        appPlatform,
        ::Bedrock::NotNullNonOwnerPtr<::IThirdPartyServerRepository>             thirdPartyServerRepository,
        ::ServerLocator&                                                         serverLocator,
        ::World::IServerURLResolver&                                             serverURLResolver,
        ::INetworkGameConnector&                                                 networkGameConnector,
        ::World::ExternalServerWorldList&                                        externalServerWorldList,
        ::World::FriendServerWorldList&                                          friendServerWorldList,
        ::World::LanServerWorldList&                                             lanServerWorldList,
        ::World::ThirdPartyWorldList&                                            thirdPartyWorldList,
        bool                                                                     isEduMode,
        ::Bedrock::NotNullNonOwnerPtr<::ExperienceSystemsManager> const&         experienceSystemsManager,
        ::std::function<::Bedrock::NonOwnerPointer<::Parties::IPartyProvider>()> getPartyProvider,
        ::OreUI::Router&                                                         router,
        ::std::function<void(::World::RecentlyPlayedPendingTargetData)>          prepareRecentlyPlayedTarget
    );
 
    MCNAPI ::Social::GameConnectionInfo
    _getGameConnectionInfo(::NetworkWorldInfo& world, ::World::ServerWorldJoiner::ServerType const serverType);
 
    MCNAPI ::Bedrock::Threading::Async<::World::JoinServerWorldResult> _joinExperienceWorld(
        ::ExperienceJoinRequestInfo const& connectionData,
        ::PlayerJoinWorldContext const&    joinContext
    );
 
    MCNAPI void _joinFriendWorld(
        ::NetworkWorldInfo const&                             world,
        ::std::function<void(::World::JoinServerWorldResult)> onCompleteCallback
    );
 
    MCNAPI void _joinNetworkWorld(
        ::NetworkWorldInfo&                                                             world,
        ::World::ServerWorldJoiner::ServerType const                                    serverType,
        ::std::optional<::World::RecentlyPlayedPendingTargetData>                       recentlyPlayedTarget,
        ::std::function<void(::std::deque<::std::unique_ptr<::ProgressHandler>>, bool)> onJoinServerCompleted,
        ::std::function<void()>                                                         onJoinServerCancelled,
        ::std::function<void(::World::JoinServerWorldResult)>                           onErrorCallback
    );
 
    MCNAPI void joinExternalNetworkWorld(
        ::std::string const&                                                            id,
        ::std::function<void(::std::deque<::std::unique_ptr<::ProgressHandler>>, bool)> onJoinServerCompleted,
        ::std::function<void(::World::JoinServerWorldResult)>                           onErrorCallback
    );
 
    MCNAPI void joinExternalServer(
        ::std::string const&                                  server,
        ushort                                                port,
        ::std::string const&                                  externalServerName,
        ::std::function<void(::World::JoinServerWorldResult)> onErrorCallback
    );
 
    MCNAPI void joinFriendServerWorld(
        ::Network::ServerID const&                            serverId,
        ::std::function<void(::World::JoinServerWorldResult)> onCompleteCallback
    );
 
    MCNAPI void joinLANServerWorld(
        ::Network::ServerID const&                                  serverId,
        ::std::function<void(::std::unique_ptr<::ProgressHandler>)> onCompleteCallback,
        ::std::function<void(::World::JoinServerWorldResult)>       onErrorCallback
    );
 
    MCNAPI void joinThirdPartyServerWorld(
        ::std::string const&                                                            id,
        ::std::function<void(::std::deque<::std::unique_ptr<::ProgressHandler>>, bool)> onJoinServerCompleted,
        ::std::function<void(::World::JoinServerWorldResult)>                           onErrorCallback,
        ::std::function<void()>                                                         onJoinServerCancelled
    );
 
    MCNAPI ~ServerWorldJoiner();
    // NOLINTEND
 
public:
    // constructor thunks
    // NOLINTBEGIN
    MCNAPI void* $ctor(
        ::IClientInstance&                                                       client,
        ::IMinecraftEventing&                                                    minecraftEventing,
        ::Bedrock::NotNullNonOwnerPtr<::Social::IUserManager> const&             userManager,
        ::Bedrock::NonOwnerPointer<::IAppPlatform> const&                        appPlatform,
        ::Bedrock::NotNullNonOwnerPtr<::IThirdPartyServerRepository>             thirdPartyServerRepository,
        ::ServerLocator&                                                         serverLocator,
        ::World::IServerURLResolver&                                             serverURLResolver,
        ::INetworkGameConnector&                                                 networkGameConnector,
        ::World::ExternalServerWorldList&                                        externalServerWorldList,
        ::World::FriendServerWorldList&                                          friendServerWorldList,
        ::World::LanServerWorldList&                                             lanServerWorldList,
        ::World::ThirdPartyWorldList&                                            thirdPartyWorldList,
        bool                                                                     isEduMode,
        ::Bedrock::NotNullNonOwnerPtr<::ExperienceSystemsManager> const&         experienceSystemsManager,
        ::std::function<::Bedrock::NonOwnerPointer<::Parties::IPartyProvider>()> getPartyProvider,
        ::OreUI::Router&                                                         router,
        ::std::function<void(::World::RecentlyPlayedPendingTargetData)>          prepareRecentlyPlayedTarget
    );
    // NOLINTEND
 
public:
    // destructor thunk
    // NOLINTBEGIN
    MCNAPI void $dtor();
    // NOLINTEND
};
 
} // namespace World