MunMasterDatabase.hpp

Go to the documentation of this file.

#ifndef __MUN_MASTER_DATABASE_HPP__
#define __MUN_MASTER_DATABASE_HPP__

#include <map>
#include <mrs.hpp>
#include <sqlite/SqliteAgent.hpp>
#include <sql/SQL.hpp>
#include <stream/MunStream.hpp>
#include <version/MunVersion.hpp>
#include "config/MunMasterConfigure.hpp"
#include "database/connection/MunMasterClientConnectInfo.hpp"
#include "database/connection/MunMasterRoomServerConnectInfo.hpp"
#include "database/index/MunIndexManager.hpp"
#include "database/matching/MunMasterMatchingDatabase.hpp"

class MunMasterDatabase
{
private:
    static  MunVersion                                          s_MunVersion;

    static  SqliteAgent                                         s_MasterDB;
    
    static  IndexManager<std::string, uint32, MatchingDatabase> s_AppMatchingDatabase;
    
    static  IndexManager<uint64, uint32, ClientConnectInfo>     s_AppClient;
    
    static  std::map<uint64, RoomServerConnectInfo>             s_RoomServerConnectInfo;
    
    static  uint32                                              s_MaxClientNum;
    
    static  std::string                                         s_ApplicationId;
    
    static STREAM::MasterLobbyUpdateResponse                    s_MasterLobbyUpdateResponse;
    static STREAM::MasterRoomUpdateResponse                     s_MasterRoomUpdateResponse;
    static STREAM::MasterStatsUpdateResponse                    s_MasterStatsUpdateResponse;
    static STREAM::MasterCheckResponse                          s_MasterCheckResponse;
    static STREAM::MasterLobbyForceJoinResponse                 s_MasterLobbyForceJoinResponse;
    static STREAM::MasterRoomCreateResponse                     s_MasterRoomCreateResponse;
    static STREAM::MasterRoomForceJoinResponse                  s_MasterRoomForceJoinResponse;
    static STREAM::MasterRoomJoinResponse                       s_MasterRoomJoinResponse;
    static STREAM::MasterRoomRandomJoinResponse                 s_MasterRoomRandomJoinResponse;
    static STREAM::MasterRoomLeaveResponse                      s_MasterRoomLeaveResponse;
    static STREAM::MasterRoomUpdateMaxPlayersResponse           s_MasterRoomUpdateMaxPlayersResponse;
    static STREAM::MasterRoomUpdateIsVisibleResponse            s_MasterRoomUpdateIsVisibleResponse;
    static STREAM::MasterRoomUpdateIsOpenResponse               s_MasterRoomUpdateIsOpenResponse;
    static STREAM::MasterRoomUpdateRoomParametersResponse       s_MasterRoomUpdateRoomParametersResponse;
    static STREAM::MasterRoomUpdateLobbyParametersResponse      s_MasterRoomUpdateLobbyParametersResponse;
    static STREAM::MasterSearchPlayersResponse                  s_MasterSearchPlayersResponse;
    static STREAM::MasterRoomUpdatePlayerParametersResponse     s_MasterRoomUpdatePlayerParametersResponse;
    static STREAM::MasterUpdatePlayerNameResponse               s_MasterUpdatePlayerNameResponse;
    
    
    static STREAM::RoomMasterUpdatePlayerParametersRequest      s_RoomMasterUpdatePlayerParametersRequest;
    static STREAM::RoomMasterUpdatePlayerNameRequest            s_RoomMasterUpdatePlayerNameRequest;
    static STREAM::RoomMasterLoginPlayerResponse                s_RoomMasterLoginPlayerResponse;
    static STREAM::RoomMasterLogoutPlayerResponse               s_RoomMasterLogoutPlayerResponse;
    static STREAM::RoomMasterUpdateHostIdResponse               s_RoomMasterUpdateHostIdResponse;
    
public:
    static IndexManager<std::string, uint32, MatchingDatabase>* GetAppMatchingDatabase(){ return &s_AppMatchingDatabase; }
    
protected:
    static  RoomServerConnectInfo*      GetRoomServerConnectInfo( uint64 roomUid ) {
        std::map<uint64, RoomServerConnectInfo>::iterator itr = s_RoomServerConnectInfo.find(roomUid);
        return (s_RoomServerConnectInfo.end() == itr) ? NULL : &(itr->second);
    }
    
    static  void    AddRoomServerConnectInfo( uint64 roomUid, RoomServerConnectInfo& roomServerConnectInfo ) {
        s_RoomServerConnectInfo.insert( std::pair<uint64, RoomServerConnectInfo>( roomUid, roomServerConnectInfo ) );
    }
    
    static  void    RemoveRoomServerConnectInfo( uint64 roomUid ) {
        s_RoomServerConnectInfo.erase( roomUid );
    }
    
    static  uint64  GetAppRoomId( uint32 appId, uint64 roomId ) { return ((uint64)appId << 32) + roomId; }
    
    static  uint32  GetAppId( uint64 appRoomId ) { return appRoomId >> 32; }
    
    static  uint64  GetRoomId( uint64 appRoomId ) { return appRoomId & 0xFFFFFFFF; }
    
    static  STREAM::ERRORCODE_ID    CreateClient( uint32& masterClientId, MrsConnection pMunProxy, uint64 proxyClientId, std::string munVersion, std::string appName, std::string clientName, bool isUpdateLobbyInfo, std::stringstream& errMsg );
    
    static  void    DeleteClient( uint32 clientId, bool isUpdateStats );
    
    static  STREAM::ERRORCODE_ID    InternalJoinLobby( MatchingDatabase* pMatchingDatabase, uint32 clientId, MatchingLobby& lobby, std::string lobbyName, uint8 lobbyKind );
    
    static  STREAM::ERRORCODE_ID    ForceJoinLobby( MatchingDatabase* pMatchingDatabase, uint32 clientId, MatchingLobby& lobby, std::string lobbyName, uint8 lobbyKind );
    
    static  void    InternalLeaveLobby( MatchingDatabase* pMatchingDatabase, MatchingClient& client );
    
    static  void    LeaveLobby( MatchingDatabase* pMatchingDatabase, MatchingClient& client );
    
    static  void    UpdatedLobby( MatchingDatabase* pMatchingDatabase, MatchingLobby& pLobby, bool isRemove );
    
    static  STREAM::ERRORCODE_ID    JoinRoom( MatchingDatabase* pMatchingDatabase, uint32 clientId, uint64& roomId, MatchingPlayerInRoom& player, std::string roomName );
    
    static  STREAM::ERRORCODE_ID    ForceJoinRoom( MatchingDatabase* pMatchingDatabase, uint32 clientId, uint64& roomId, MatchingPlayerInRoom& player, std::string roomName, uint64 lobbyId, bool isVisible, bool isOpen, uint32 maxPlayers, STREAM::KeyValue* pRoomParameters, uint16 roomParametersLen, STREAM::Text* pLobbyParameters, uint16 lobbyParametersLen, bool isNeedHostPlayer );
    
    static  STREAM::ERRORCODE_ID    RandomJoinRoom( MatchingDatabase* pMatchingDatabase, uint32 clientId, uint64& roomId, MatchingPlayerInRoom& player, uint64 lobbyId, uint8 lobbyKind, uint32 maxPlayers, uint8 matchingMode, STREAM::KeyValue* pRoomParameters, uint16 roomParametersLen, std::string keyValueFilter, std::string& msg );
    
    static  void    JoinedRoom( MatchingDatabase* pMatchingDatabase, uint64 lobbyId, uint64 roomId, bool roomIsVisible, MatchingPlayerInRoom& player );
    
    static  void    LeaveRoom( MatchingDatabase* pMatchingDatabase, uint32 clientId );
    
    static  void    LeaveRoom( MatchingDatabase* pMatchingDatabase, MatchingClient& client );
    
    static  void    LeftRoom( MatchingDatabase* pMatchingDatabase, MatchingRoom* pRoom, MatchingClient& client );
    
    static  bool    UpdateRoom( MatchingDatabase* pMatchingDatabase, uint64 roomId, bool isVisible, bool isOpen, uint32 maxPlayers );
    
    static  bool    UpdateRoom( MatchingDatabase* pMatchingDatabase, MatchingRoom* pRoom, uint64 roomId, int32 hostId );
    
    static  bool    UpdateRoom( MatchingDatabase* pMatchingDatabase, uint64 roomId, STREAM::KeyValue* pRoomParameters, uint16 roomParametersLen );
    
    static  bool    UpdateRoom( MatchingDatabase* pMatchingDatabase, uint64 roomId, STREAM::Text* pLobbyParameters, uint16 lobbyParametersLen );
    
    static  void    UpdatedRoom( MatchingDatabase* pMatchingDatabase, MatchingRoom* pRoom );
    
    static  void    UpdatedRoom( MatchingRoom * pRoom, bool isRemovedRoom, std::vector< uint32 >* clientIds );

    static  void    UpdatedRoom( MatchingDatabase* pMatchingDatabase, uint64 roomId, bool isRemovedRoom, std::vector< uint32 >* clientIds );
    
    static  void    UpdateStats( MatchingDatabase* pMatchingDatabase );
    
    static  bool    SetRoomWeight( uint64 roomUid, int32 weight );
    
    static  void    DeleteRoomWeight( uint64 roomUid );
    
    static  void    ClearRoomWeights();
    
    static  uint64  SelectRoomUid();
    
public:
    static  bool    InitDB(MunMasterConfigure* pConfig);
    
    static  void    Recv_Master_Check(MrsConnection pMunProxy, uint64 proxyClientId, STREAM::MasterCheckRequest& request);
    
    static  void    Recv_Master_Lobby_ForceJoin(MrsConnection pMunProxy, uint64 proxyClientId, STREAM::MasterLobbyForceJoinRequest& request);
    
    static  void    Recv_Master_Lobby_Leave(MrsConnection pMunProxy, uint64 proxyClientId);
    
    static  void    Recv_Master_Room_Create(MrsConnection pMunProxy, uint64 proxyClientId, STREAM::MasterRoomCreateRequest& request);
    
    static  void    Recv_Master_Room_ForceJoin(MrsConnection pMunProxy, uint64 proxyClientId, STREAM::MasterRoomForceJoinRequest& request);
    
    static  void    Recv_Master_Room_Join(MrsConnection pMunProxy, uint64 proxyClientId, STREAM::MasterRoomJoinRequest& request);
    
    static  void    Recv_Master_Room_RandomJoin(MrsConnection pMunProxy, uint64 proxyClientId, STREAM::MasterRoomRandomJoinRequest& request);
    
    static  void    Recv_Master_Room_Leave(MrsConnection pMunProxy, uint64 proxyClientId);
    
    static  void    Recv_Master_Room_UpdateMaxPlayers(MrsConnection pMunProxy, uint64 proxyClientId, STREAM::MasterRoomUpdateMaxPlayersRequest& request);
    
    static  void    Recv_Master_Room_UpdateIsVisible(MrsConnection pMunProxy, uint64 proxyClientId, STREAM::MasterRoomUpdateIsVisibleRequest& request);
    
    static  void    Recv_Master_Room_UpdateIsOpen(MrsConnection pMunProxy, uint64 proxyClientId, STREAM::MasterRoomUpdateIsOpenRequest& request);
    
    static  void    Recv_Master_Room_UpdateRoomParameters(MrsConnection pMunProxy, uint64 proxyClientId, STREAM::MasterRoomUpdateRoomParametersRequest& request);
    
    static  void    Recv_Master_Room_UpdateLobbyParameters(MrsConnection pMunProxy, uint64 proxyClientId, STREAM::MasterRoomUpdateLobbyParametersRequest& request);
    
    static  void    Recv_Master_SearchPlayers(MrsConnection pMunProxy, uint64 proxyClientId, STREAM::MasterSearchPlayersRequest& request);
    
    static  void    Recv_Master_Stats_Update(MrsConnection pMunProxy, uint64 proxyClientId);
    
    static  void    Recv_Master_Room_UpdatePlayerParameters(MrsConnection pMunProxy, uint64 proxyClientId, STREAM::MasterRoomUpdatePlayerParametersRequest& request);
    
    static  void    Recv_Master_UpdatePlayerName(MrsConnection pMunProxy, uint64 proxyClientId, STREAM::MasterUpdatePlayerNameRequest& request);
    
    static  void    Recv_Proxy_DisconnectClient(MrsConnection pMunProxy, uint64 proxyClientId);
    
    static  void    Recv_RoomMaster_SetAddress(MrsConnection pMunRoom, STREAM::RoomMasterSetAddressRequest& request);
    
    static  void    Recv_RoomMaster_SetWeight(MrsConnection pMunRoom, STREAM::RoomMasterSetWeightRequest& request);
    
    static  void    Recv_RoomMaster_LoginPlayer(MrsConnection pMunRoom, STREAM::RoomMasterLoginPlayerRequest& request);
    
    static  void    Recv_RoomMaster_LogoutPlayer(MrsConnection pMunRoom, STREAM::RoomMasterLogoutPlayerRequest& request);
    
    static  void    Recv_RoomMaster_UpdateHostId(MrsConnection pMunRoom, STREAM::RoomMasterUpdateHostIdRequest& request);
    
    static  void    RemoveRoomAll(MrsConnection pMunRoom);
};

#endif  /* __MUN_MASTER_DATABASE_HPP__ */