DiarkisMatchMakerBase.h

[詳解]

// © 2019-2024 Diarkis Inc. All rights reserved.
 
#pragma once
 
#include <functional>
#include "DiarkisP2PBase.h"
#include "diarkis/common.h"
#include "diarkis/modules/matchMaker.h"
#include "diarkis/modules/room.h"
#include "diarkis/network/eventArgs.h"
#include "diarkis/network/tcp.h"
#include "diarkis/network/udp.h"
#include "logging/LoggerFactory.h"
#include "protocol.h"
 
using namespace Diarkis::Modules;
 
class DIARKIS_API DiarkisMatchMakerBase
{
   public:
    DiarkisMatchMakerBase();
 
    virtual ~DiarkisMatchMakerBase();
 
    virtual void SetupTcpMatchMaker(const std::shared_ptr<IDiarkisTcp>& tcp, const std::shared_ptr<LoggerFactory>& loggerFactory);
 
    virtual void SetupUdpMatchMaker(const std::shared_ptr<IDiarkisUdp>& udp,
                                    const std::shared_ptr<LoggerFactory>& loggerFactory,
                                    const std::shared_ptr<DiarkisP2PBase>& p2pBase);
 
    void SetRoomModule(const std::shared_ptr<IDiarkisRoom>& room);
 
    virtual bool SendHostMatchmaking(const char* uid,
                                     uint16_t maxMembers,
                                     uint16_t ttl,
                                     const char* profileID,
                                     const char* tag,
                                     const MatchMakerCondition* conditions,
                                     size_t conditionsCount,
                                     const uint8_t* metadata,
                                     size_t metadataSize,
                                     bool bReserveOnly);
 
    virtual bool SendHostMatchmaking(const std::string& uid,
                                     uint16_t maxMembers,
                                     uint16_t ttl,
                                     const std::string& profileID,
                                     const std::string& tag,
                                     const std::vector<MatchMakerCondition>& conditions,
                                     const std::vector<uint8_t>& metadata,
                                     bool bReserveOnly);
 
    virtual void SendAbortMatchmaking(void);
 
    virtual void SendDisbandMatchmaking(const uint8_t* message, size_t messageSize);
 
    virtual void SendDisbandMatchmaking(const std::vector<uint8_t>& message);
 
    virtual void SendClaimReservedMatchmaking(const uint8_t* message, size_t messageSize);
 
    virtual void SendClaimReservedMatchmaking(const std::vector<uint8_t>& message);
 
    virtual void SendJoinMatchmakingFromResult(MatchMakerResultItem& result, const uint8_t* message, size_t messageSize);
 
    virtual void SendJoinMatchmakingFromResult(MatchMakerResultItem& result, const std::vector<uint8_t>& message);
 
    virtual void SendLeaveMatchmaking(const uint8_t* message, size_t messageSize);
 
    virtual void SendLeaveMatchmaking(const std::vector<uint8_t>& message);
 
    virtual void SendSync(const uint8_t* message, size_t messageSize);
 
    virtual void SendSync(const std::vector<uint8_t>& message);
 
    virtual void SendNotifyMatchmakingCompletion(void);
 
    virtual void SendP2PAddressSync(uint8_t linkedClients = 0);
 
    virtual void SendSearch(const char** profileIDs,
                            size_t profileIDsCount,
                            const char* tag,
                            const MatchMakerCondition* conditions,
                            size_t conditionsCount,
                            bool joinFlag,
                            uint16_t howmany,
                            const uint8_t* message,
                            size_t messageSize);
 
    virtual void SendSearch(const std::vector<std::string>& profileIDs,
                            const std::string& tag,
                            const std::vector<MatchMakerCondition>& conditions,
                            bool joinFlag,
                            uint16_t howmany,
                            const std::vector<uint8_t>& message);
 
    virtual bool SendStartBackfill(const char* roomID);
 
    virtual bool SendStartBackfill(const std::string& roomID);
 
    virtual bool SendKick(const char* userID);
 
    virtual bool SendKick(const std::string& userID);
 
    virtual bool SendHostTeamMatchmaking(const char* uid,
                                         uint16_t maxMembers,
                                         uint16_t ttl,
                                         const char* profileID,
                                         const char* tag,
                                         const MatchMakerCondition* conditions,
                                         size_t conditionsCount,
                                         const uint8_t* metadata,
                                         size_t metadataSize,
                                         bool bReserveOnly);
 
    virtual bool SendHostTeamMatchmaking(const std::string& uid,
                                         uint16_t maxMembers,
                                         uint16_t ttl,
                                         const std::string& profileID,
                                         const std::string& tag,
                                         const std::vector<MatchMakerCondition>& conditions,
                                         const std::vector<uint8_t>& metadata,
                                         bool bReserveOnly);
 
    virtual void SendSearchTeamMatchmaking(const char** profileIDs,
                                           size_t profileIDsCount,
                                           const char* tag,
                                           const MatchMakerCondition* conditions,
                                           size_t conditionsCount,
                                           bool joinFlag,
                                           uint16_t howmany,
                                           const uint8_t* message,
                                           size_t messageSize);
 
    virtual void SendSearchTeamMatchmaking(const std::vector<std::string>& profileIDs,
                                           const std::string& tag,
                                           const std::vector<MatchMakerCondition>& conditions,
                                           bool joinFlag,
                                           uint16_t howmany,
                                           const std::vector<uint8_t>& message);
 
    virtual void SendCommit(void);
 
    virtual void SendIssueTicket(uint8_t ticketType);
 
    virtual void SendTicketCancel(uint8_t ticketType);
 
    virtual void SendTicketBroadcast(uint8_t ticketType, const uint8_t* message, size_t messageSize);
 
    virtual void SendTicketBroadcast(uint8_t ticketType, const std::vector<uint8_t>& message);
 
    virtual void SendTicketLeave(uint8_t ticketType);
 
    Diarkis::StdString GetRoomID(void);
 
    const Diarkis::StdString& GetOwnerUID(void);
 
    bool IsComplete(void);
 
    bool IsGotoRoom(void);
 
    void ResetGotoRoom(void);
 
    void ClearList(void);
 
    const Diarkis::StdString& GetTicketMessage(void);
 
    const Diarkis::StdString& GetTicketBroadcastMessage(void);
 
    bool IsTicketComplete(void);
 
    bool IsTicketCancel(void);
 
    void GetMatchingMemberList(Diarkis::StdVector<Diarkis::StdString>& memberList);
 
    void GetTeamMatchingMemberList(Diarkis::StdVector<Diarkis::StdString>& memberList);
 
    void SetOwnUID(const char* uid);
 
    void SetOwnUID(const std::string& uid);
 
   protected:
    virtual void OnHostMatchmaking(const DiarkisMMHostEventArgs& e);
 
    virtual void OnAbortMatchmaking(const DiarkisMMResponseEventArgs& e);
 
    virtual void OnDisbandMatchmaking(const DiarkisMMSyncEventArgs& e);
 
    virtual void OnMemberLeave(const DiarkisMMSyncEventArgs& e);
 
    virtual void OnMemberJoin(const DiarkisMMSyncEventArgs& e);
 
    virtual void OnMemberSync(const DiarkisMMSyncEventArgs& e);
 
    virtual void OnJoin(const DiarkisMMJoinResponseEventArgs& e);
 
    virtual void OnLeave(const DiarkisMMResponseEventArgs& e);
 
    virtual void OnComplete(void);
 
    virtual void OnSearch(const DiarkisMMJoinResponseEventArgs& e);
 
    virtual void OnResutls(const DiarkisMMResultEventArgs& e);
 
    virtual void OnP2PAddress(const DiarkisP2PEventArgs& e);
 
    virtual void OnP2PResponse(const DiarkisMMResponseEventArgs& e);
 
    virtual void OnBackfillEvent(const DiarkisMMResponseEventArgs& e);
 
    virtual void OnKick(const DiarkisPayloadEventArgs& e);
 
    virtual void OnKickResponse(const DiarkisMMResponseEventArgs& e);
 
    virtual void OnCommit(const DiarkisMMResponseEventArgs& e);
 
    virtual void OnCompleteCommit(const DiarkisMMJoinResponseEventArgs& e);
 
    virtual void OnTeamHostMatchmaking(const DiarkisMMHostEventArgs& e);
 
    virtual void OnTeamSearch(const DiarkisMMJoinResponseEventArgs& e);
 
    virtual void OnTeamMemberJoin(const DiarkisMMSyncEventArgs& e);
 
    virtual void OnIssueTicketResponse(const DiarkisMMResponseEventArgs& e);
 
    virtual void OnTicketComplete(const DiarkisMMResponseEventArgs& e);
 
    virtual void OnHostChange(const DiarkisMMStringEventArgs& e);
 
    virtual void OnTicketCancel(const DiarkisMMTicketTypeEventArgs& e);
 
    virtual void OnTicketCancelResponse(const DiarkisMMResponseEventArgs& e);
 
    virtual void OnTicketBroadcastResponse(const DiarkisMMResponseEventArgs& e);
 
    virtual void OnTicketBroadcast(const DiarkisMMSyncEventArgs& e);
 
    virtual void OnTicketLeave(const DiarkisMMResponseEventArgs& e);
 
    virtual void OnResponse(const DiarkisResponseEventArgs& args, DiarkisTransportType tt);
 
    virtual void OnPush(const DiarkisPushEventArgs& args, DiarkisTransportType tt);
 
    std::shared_ptr<IDiarkisMatchMaker> mm_;
 
    std::shared_ptr<IDiarkisTcp> tcp_;
 
    std::shared_ptr<IDiarkisUdp> udp_;
 
    std::shared_ptr<IDiarkisRoom> room_;
 
    std::shared_ptr<DiarkisP2PBase> p2pBase_;
 
    std::shared_ptr<IDiarkisLogger> logger_;
 
    Diarkis::StdVector<std::function<void()>> eventUnsubscriptions_;
 
    Diarkis::StdVector<uint8_t> Buff_;
 
    Diarkis::StdString myUid_;
 
    Diarkis::StdString ownerUid_;
 
    Diarkis::StdString ticketBroadcastMessage_;
 
    std::recursive_mutex list_mutex_;
 
    Diarkis::StdVector<Diarkis::StdString> memberLists_;
 
    Diarkis::StdVector<Diarkis::StdString> teamMemberLists_;
 
    bool bComplete_;
 
    bool bGotoRoom_;
 
    bool bTicketComplete_;
 
    Diarkis::StdString ticketMessage_;
 
    bool bTicketCancel_;
 
    bool bTeamMatchOwner_;
 
};