DiarkisRoomBase.h

[詳解]

// © 2019-2024 Diarkis Inc. All rights reserved.
 
#pragma once
 
#include <functional>
#include "diarkis/common.h"
#include "diarkis/modules/room.h"
#include "diarkis/network/tcp.h"
#include "diarkis/network/udp.h"
#include "logging/LoggerFactory.h"
#include "protocol.h"
#include "DiarkisP2PBase.h"
 
using namespace Diarkis::Modules;
 
class DIARKIS_API DiarkisRoomBase
{
   public:
    DiarkisRoomBase();
 
    virtual ~DiarkisRoomBase();
 
    virtual void SetupTcpRoom(const std::shared_ptr<IDiarkisTcp>& tcp, const std::shared_ptr<LoggerFactory>& loggerFactory, bool bRetry);
 
    virtual void SetupUdpRoom(const std::shared_ptr<IDiarkisUdp>& udp,
                              const std::shared_ptr<LoggerFactory>& loggerFactory,
                              const std::shared_ptr<DiarkisP2PBase>& p2pBase,
                              bool bRetry);
 
    std::shared_ptr<IDiarkisRoom> GetRoom();
 
    void SetJoinRoomID(const char* roomID);
 
    void SetJoinRoomID(const std::string& roomID);
 
    virtual void SendCreateRoom(uint16_t maxMembers, bool allowEmpty, bool join, uint16_t ttl, uint32_t interval);
 
    virtual void SendJoinRoom(const char* uid);
 
    virtual void SendJoinRoom(const std::string& uid);
 
    virtual void SendJoinRoom(const char* roomID, const char* uid);
 
    virtual void SendJoinRoom(const std::string& roomID, const std::string& uid);
 
    virtual void SendJoinRandomRoom(const char* uid, uint32_t maxMembers, uint16_t ttl, uint32_t interval, bool allowEmpty);
 
    virtual void SendJoinRandomRoom(const std::string& uid, uint32_t maxMembers, uint16_t ttl, uint32_t interval, bool allowEmpty);
 
    virtual void SendBroadcastToRoom(const uint8_t* payload, size_t payloadSize, bool reliable);
 
    virtual void SendBroadcastToRoom(const std::vector<uint8_t>& payload, bool reliable);
 
    virtual void SendMessageToRoom(const char** memberIDs, size_t memberIDsCount, const uint8_t* payload, size_t payloadSize, bool reliable);
 
    virtual void SendMessageToRoom(const std::vector<std::string>& memberIDs, const std::vector<uint8_t>& payload, bool reliable);
 
    virtual void SendRelay(const uint8_t* payload, size_t payloadSize, bool reliable);
 
    virtual void SendRelay(const std::vector<uint8_t>& payload, bool reliable);
 
    virtual void SendRelayTo(const char** memberIDs, size_t memberIDsCount, const uint8_t* payload, size_t payloadSize, bool reliable);
 
    virtual void SendRelayTo(const std::vector<std::string>& memberIDs, const std::vector<uint8_t>& payload, bool reliable);
 
    virtual void SendLeaveRoom(const char* uid);
 
    virtual void SendLeaveRoom(const std::string& uid);
 
    virtual void SendFindByTypeRoom(uint32_t roomType, uint32_t limit);
 
    virtual void SendRegisterRoom(uint32_t roomType, const char* roomName, const char* roomMetadata);
 
    virtual void SendRegisterRoom(uint32_t roomType, const std::string& roomName, const std::string& roomMetadata);
 
    virtual void SendMigrateRoom(void);
 
    virtual void SendGetOwnerID(void);
 
    virtual void SendGetMemberIDs(void);
 
    virtual void SendGetNumberOfMembers(void);
 
    virtual void SendUpdateProperties(const std::unordered_map<std::string, std::vector<uint8_t>>& properties, bool sync = false);
 
    virtual void SendGetProperties(const char** propertyNames, size_t propertyNamesCount);
 
    virtual void SendGetProperties(const std::vector<std::string>& propertyNames);
 
    virtual void SendIncrementProperty(Diarkis::StdString propertyName, int64_t delta, bool sync);
 
    virtual void SendReserveRoom(const char** userIDs, size_t userIDsCount);
 
    virtual void SendReserveRoom(const std::vector<std::string>& userIDs);
 
    virtual void SendCancelReservationRoom(const char* cancelRoomID, const char** userIDs, size_t userIDsCount);
 
    virtual void SendCancelReservationRoom(const std::string& cancelRoomID, const std::vector<std::string>& userIDs);
 
    virtual void SendChatMessage(const char* message);
 
    virtual void SendChatMessage(const std::string& message);
 
    virtual void SendGetChatLog(void);
 
    virtual void SendStartP2PSync(uint8_t linkedClients = 0);
 
    virtual void SendUpdateObject(RoomObjectMode mode, const std::string& name, const std::unordered_map<std::string, double>& obj, bool reliable = true);
 
    bool IsJoin();
 
    bool IsFail();
 
    bool IsFind();
 
    bool IsNotFind();
 
    bool IsMigrate();
 
    bool IsLeave();
 
    bool IsReserve();
 
    Diarkis::StdString GetRoomID(void);
 
    Diarkis::StdString GetOwnerUID(void);
 
    Diarkis::StdString GetOwnUID(void) const;
 
    void SetOwnUID(const char* uid);
 
    void SetOwnUID(const std::string& uid);
 
    void GetRoomMembers(Diarkis::StdVector<Diarkis::StdString>& memberList);
 
    const Diarkis::StdVector<Diarkis::StdString>& GetRoomMembers() const;
 
   protected:
    virtual void OnRoomCreation(const DiarkisRoomCreationEventArgs& e);
 
    virtual void OnRoomJoin(const DiarkisRoomJoinEventArgs& e);
 
    virtual void OnRoomLeave(const DiarkisRoomSuccessEventArgs& e);
 
    virtual void OnRoomMigrateStart(void);
 
    virtual void OnRoomMigrateComplete(const DiarkisRoomMigrateCompleteEventArgs& e);
 
    virtual void OnRoomMemberJoin(const DiarkisPayloadEventArgs& e);
 
    virtual void OnRoomMemberLeave(const DiarkisPayloadEventArgs& e);
 
    virtual void OnRoomUpdateProperties(const DiarkisRoomSuccessEventArgs& e);
 
    virtual void OnRoomGetProperties(const DiarkisRoomPropertiesEventArgs& e);
 
    virtual void OnRoomUpdateSyncProperties(const DiarkisRoomPropertiesEventArgs& e);
 
    virtual void OnRoomIncrementProperty(const DiarkisRoomIncrementPropertyEventArgs& e);
 
    virtual void OnRoomIncrementPropertySync(const DiarkisRoomIncrementPropertySyncEventArgs& e);
 
    virtual void OnRoomGetOwnerID(const DiarkisRoomGetOwnerIDEventArgs& e);
 
    virtual void OnRoomMemberIDs(const DiarkisRoomMemberIDsEventArgs& e);
 
    virtual void OnRoomNumberOfMembers(const DiarkisRoomNumberOfMembersEventArgs& e);
 
    virtual void OnRoomOwnerChange(const DiarkisRoomGetOwnerIDEventArgs& e);
 
    virtual void OnRoomMemberBroadcast(const DiarkisPayloadEventArgs& e);
 
    virtual void OnRoomMemberMessage(const DiarkisPayloadEventArgs& e);
 
    virtual void OnRoomRelay(const DiarkisPayloadEventArgs& e);
 
    virtual void OnRoomRelayTo(const DiarkisPayloadEventArgs& e);
 
    virtual void OnRoomRegister(const DiarkisRoomPayloadEventArgs& e);
 
    virtual void OnRoomFindByType(const DiarkisRoomFindByTypeEventArgs& e);
 
    virtual void OnRoomReserve(const DiarkisRoomPayloadEventArgs& e);
 
    virtual void OnRoomCancelReserve(const DiarkisRoomPayloadEventArgs& e);
 
    virtual void OnChatSyncResponse(const DiarkisRoomPayloadEventArgs& e);
 
    virtual void OnChatSync(const DiarkisRoomChatEventArgs& e);
 
    virtual void OnRoomChatLog(const DiarkisRoomChatLogEventArgs& e);
 
    virtual void OnStartP2PSync(const DiarkisP2PEventArgs& e);
 
    virtual void OnRoomObjectUpdate(const DiarkisRoomObjectUpdateEventArgs& e);
 
    virtual void OnRoomObjectUpdateResponse(const DiarkisRoomObjectUpdateResponseEventArgs& e);
 
    virtual void OnOffline();
 
    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::StdString roomID_;
 
    ConnectState roomConnect_;
 
    std::recursive_mutex list_mutex_;
 
    Diarkis::StdVector<Diarkis::StdString> roomMemberIDs_;
 
    Diarkis::StdString ownUID_;
 
    Diarkis::StdString ownerID_;
 
    int64_t createAtServer_;
 
    bool bReserved_;
 
};