MunRoomDatabase.hpp

Go to the documentation of this file.

#ifndef __MUN_ROOM_DATABASE_HPP__
#define __MUN_ROOM_DATABASE_HPP__

#include <map>
#include <limits.h>
#include <mrs.hpp>
#include <sqlite/SqliteAgent.hpp>
#include <sql/SQL.hpp>
#include <stream/MunStream.hpp>
#include <version/MunVersion.hpp>
#include "config/MunRoomConfigure.hpp"
#include "database/Room/MunRoomInfo.hpp"
#include "database/PlayerInRoom/MunRoomPlayerInfo.hpp"

class MunRoomDatabase
{
private:
    static  MunVersion                          s_MunVersion;

    static  SqliteAgent                         s_RoomDB;
    
    static  std::map<uint64, MunRoomInfo>       s_RoomInfo;
    
    static  int32                               s_Weight;
    
    static  std::map< uint64, MrsConnection >   s_ClientConnectInfo;
    
    static  std::map< MrsConnection, uint64 >   s_ClientIdInfo;
    
    static uint64                              s_RoomUid;
    
    static STREAM::RoomLoginPlayerResponse          s_RoomLoginPlayerResponse;
    static STREAM::RoomMasterLoginPlayerRequest     s_RoomMasterLoginPlayerRequest;
    static STREAM::RoomJoinedPlayerResponse         s_RoomJoinedPlayerResponse;
    static STREAM::RoomLeftPlayerResponse           s_RoomLeftPlayerResponse;
    static STREAM::RoomMasterUpdateHostIdRequest    s_RoomMasterUpdateHostIdRequest;
    static STREAM::RoomUpdateHostIdResponse         s_RoomUpdateHostIdResponse;
    static STREAM::RoomRPCResponse                  s_RoomRPCResponse;
    static STREAM::RoomKickPlayerResponse           s_RoomKickPlayerResponse;
    static STREAM::RoomMasterLogoutPlayerRequest    s_RoomMasterLogoutPlayerRequest;
    
    static std::list< MrsConnection > s_CloseConnections;
    
    static uint64                     s_UpdateIntervalMsec;
    static uint64                     s_UpdateCheckMsec;
    
public:
    static  uint64          GetRoomUid() { return s_RoomUid; }
    
    static  MrsConnection   GetClientConnectInfo( uint64 clientUid ) {
        std::map<uint64, MrsConnection>::iterator itr = s_ClientConnectInfo.find( clientUid );
        return  ( s_ClientConnectInfo.end() == itr ) ? NULL: itr->second;
    }
    
    static  uint64  GetClientConnectInfo( MrsConnection pMunClient ) {
        std::map<MrsConnection, uint64>::iterator itr = s_ClientIdInfo.find( pMunClient );
        return  ( s_ClientIdInfo.end() == itr ) ? 0: itr->second;
    }
    
    static  void    AddClientConnectInfo( uint64 clientUid, MrsConnection pMunClient ) {
        s_ClientConnectInfo.insert( std::pair<uint64, MrsConnection>( clientUid, pMunClient ) );
        s_ClientIdInfo.insert( std::pair<MrsConnection, uint64>( pMunClient, clientUid ) );
    }
    
    static  void    RemoveClientConnectInfo( uint64 clientUid ) {
        MrsConnection   pMunClient = GetClientConnectInfo(clientUid);
        s_ClientIdInfo.erase(pMunClient);
        s_ClientConnectInfo.erase(clientUid);
        s_CloseConnections.push_back( pMunClient );
    }
    
    static  void    RemoveClientConnectInfo( MrsConnection pMunClient ) {
        uint64 clientUid = GetClientConnectInfo(pMunClient);
        s_ClientConnectInfo.erase(clientUid);
        s_ClientIdInfo.erase(pMunClient);
        s_CloseConnections.push_back( pMunClient );
    }
    
    static  MunRoomInfo*    GetRoomInfo( uint64 roomId ) {
        std::map< uint64, MunRoomInfo>::iterator itr = s_RoomInfo.find(roomId);
        return (s_RoomInfo.end() == itr) ? NULL : &(itr->second);
    }
    
    static  void    CreateRoomInfo( uint64 roomId, bool isNeedHostPlayer ) {
        s_RoomInfo.insert( std::pair<uint64, MunRoomInfo>( roomId, MunRoomInfo(roomId, isNeedHostPlayer) ) );
    }
    
    static  void    DeleteRoomInfo( uint64 roomId ) {
        s_RoomInfo.erase( roomId );
    }
    
    static  void    BeginLoginPlayer( MrsConnection pMunClient, uint32 clientUidForMasterServer, uint64 clientUidForProxyServer );
    
    static  void    EndLoginPlayer( int32 result, uint32 clientUidForMasterServer, uint64 clientUidForProxyServer, uint64 roomId, STREAM::RoomInfo& roomInfo, STREAM::PlayerInfo& playerInfo, bool isNeedHostPlayer );
    
    static  bool    LoginPlayer( MrsConnection connection, uint32 clientUidForMasterServer, uint64 clientUidForProxyServer, uint64 roomId, STREAM::RoomInfo& roomInfo, STREAM::PlayerInfo& playerInfo, bool isNeedHostPlayer );
    
    static  void    LogoutPlayer( uint64 roomId, STREAM::RoomInfo& roomInfo, int32 playerId );
    
    static  MunRoomPlayerInfo   GetPlayer( uint64 clientUidForProxyServer );
    
    static  MunRoomPlayerInfo   GetPlayer( uint64 roomId, int32 playerId );
    
    static  void    AddPlayer( MrsConnection connection, MunRoomInfo* pRoom, int32 playerId, std::string playerName, uint32 clientUidForMasterServer, uint64 clientUidForProxyServer, STREAM::KeyValue* pParameters, uint16 parametersLen );
    
    static  void    RemovePlayer( MunRoomInfo* pRoom, int32 playerId );
    
    static  void    BeginUpdateHostId( uint64 roomId, int32 hostId );
    
    static  void    EndUpdateHostId( uint64 roomId, int32 hostId );
    
    static  void    UpdateHostId( MunRoomInfo* pRoom, int32 hostId );
    
    static void SetUpdateIntervalMsec( uint64 value ){ s_UpdateIntervalMsec = value; }
    static bool IsGroupWriteRecord(){ return ( 0 < s_UpdateIntervalMsec ); }
    
public:
    static  bool    InitDB(MunRoomConfigure& configure);
    
    static  bool    Terminate();
    
    static  void    Recv_Room_LoginPlayer(MrsConnection pMunClient, STREAM::RoomLoginPlayerRequest &request);
    
    static  void    Recv_Room_UpdateHostId(MrsConnection pMunClient, STREAM::RoomUpdateHostIdRequest &request);
    
    static  void    Recv_Room_RPC(MrsConnection pMunClient, uint16 options, STREAM::RoomRPCRequest &request);
    
    static  void    Recv_Room_KickPlayer(MrsConnection pMunClient, STREAM::RoomKickPlayerRequest &request);
    
    static  void    Recv_Room_DisconnectPlayer(MrsConnection pMunClient);
    
    static  void    Recv_RoomMaster_LoginPlayerResult(MrsConnection pMunMaster, STREAM::RoomMasterLoginPlayerResponse &response);
    
    static  void    Recv_RoomMaster_LogoutPlayerResult(MrsConnection pMunMaster, STREAM::RoomMasterLogoutPlayerResponse &response);
    
    static  void    Recv_RoomMaster_UpdateHostIdResult(MrsConnection pMunMaster, STREAM::RoomMasterUpdateHostIdResponse &response);
    
    static  void    Recv_RoomMaster_UpdatePlayerParameters(MrsConnection pMunMaster, STREAM::RoomMasterUpdatePlayerParametersRequest &request);
    
    static  void    Recv_RoomMaster_UpdatePlayerName(MrsConnection pMunMaster, STREAM::RoomMasterUpdatePlayerNameRequest &request);
    
    static  void    Update();
};

#endif  /* __MUN_ROOM_DATABASE_HPP__ */