MunMasterMatchingRoom.hpp

Go to the documentation of this file.

#ifndef __MUN_MASTER_MATCHING_ROOM_HPP__
#define __MUN_MASTER_MATCHING_ROOM_HPP__

#include <map>
#include <vector>
#include <mrs.hpp>
#include <stream/MunStream.hpp>
#include <log/MunLogger.hpp>
#include "database/matching/PlayerInRoom/MunMasterMatchingPlayerInRoom.hpp"

class   MatchingRoom
{
protected:
    uint64          m_Id;
    
    std::string     m_Name;
    
    uint64          m_LobbyId;
    
    bool            m_IsVisible;
    
    bool            m_IsOpen;
    
    uint32          m_MaxPlayers;
    
    std::map< int32, MatchingPlayerInRoom >     m_PlayersInRoom;
    
    int32           m_HostId;
    
    int32           m_NextPlayerId;
    
    std::map< std::string, STREAM::Union >      m_RoomParameters;
    
    std::vector< std::string >      m_LobbyParameters;
    
    uint64          m_RoomUid;
    
    bool            m_IsNeedHostPlayer;
    
public:
    uint64  GetId() { return m_Id; }
    
    void    SetId(uint64 id) { m_Id = id; }
    
    std::string     GetName() { return m_Name; }
    
    void    SetName(std::string name) { m_Name = name; }
    
    uint64  GetLobbyId() { return m_LobbyId; }
    
    void    SetLobbyId(uint64 lobbyId) { m_LobbyId = lobbyId; }
    
    bool    GetIsVisible() { return m_IsVisible; }
    
    void    SetIsVisible(bool isVisible) { m_IsVisible = isVisible; }
    
    bool    GetIsOpen() { return m_IsOpen; }
    
    void    SetIsOpen(bool isOpen) { m_IsOpen = isOpen; }
    
    uint32  GetMaxPlayers() { return m_MaxPlayers; }
    
    void    SetMaxPlayers(uint32 maxPlayers) { m_MaxPlayers = maxPlayers; }
    
    bool    GetSummaryInfo(STREAM::SummaryRoomInfo& info) {
        if( m_PlayersInRoom.size() > STREAM::PLAYER_MAX ) {
            MRSEXT_LOG_ERR( "m_PlayersInRoom.size() is over %d", STREAM::PLAYER_MAX );
            return false;
        }
        if( m_RoomParameters.size() > STREAM::ROOM_PARAMETERS_MAX ) {
            MRSEXT_LOG_ERR( "m_RoomParameters.size() is over %d", STREAM::ROOM_PARAMETERS_MAX );
            return false;
        }
        info.name.text   = m_Name;
        info.maxPlayers  = m_MaxPlayers;
        info.isVisible   = m_IsVisible;
        info.isOpen      = m_IsOpen;
        info.hostId      = GetHostId();
        info.playersLen  = m_PlayersInRoom.size();
        info.roomParametersLen = 0;
        if( m_RoomParameters.size() > 0 )
        {
            for( std::map<std::string, STREAM::Union>::iterator itr = m_RoomParameters.begin(); m_RoomParameters.end() != itr; ++itr ) {
                STREAM::Text    roomParamKey = STREAM::Text(itr->first);
                //ロビーパラメータに設定されていないものは除きます。
                for(std::vector<std::string>::iterator lobby_itr = m_LobbyParameters.begin();
                        m_LobbyParameters.end()!=lobby_itr;lobby_itr++){
                    if(itr->first == *lobby_itr){
                        info.roomParameters[info.roomParametersLen] = STREAM::KeyValue( roomParamKey, itr->second );
                        info.roomParametersLen++;
                    }
                }
            }
        }
        return true;
    }
    
    void    GetInfo(STREAM::RoomInfo& info) {
        if( m_PlayersInRoom.size() > STREAM::PLAYER_MAX ) {
            MRSEXT_LOG_ERR( "m_PlayersInRoom.size() is over %d", STREAM::PLAYER_MAX );
            return;
        }
        if( m_RoomParameters.size() > STREAM::ROOM_PARAMETERS_MAX ) {
            MRSEXT_LOG_ERR( "m_RoomParameters.size() is over %d", STREAM::ROOM_PARAMETERS_MAX );
            return;
        }
        if( m_LobbyParameters.size() > STREAM::LOBBY_PARAMETERS_MAX ) {
            MRSEXT_LOG_ERR( "m_LobbyParameters.size() is over %d", STREAM::LOBBY_PARAMETERS_MAX );
            return;
        }
        info.name.text      = m_Name;
        info.isVisible      = m_IsVisible;
        info.isOpen         = m_IsOpen;
        info.maxPlayers     = m_MaxPlayers;
        info.playersLen     = m_PlayersInRoom.size();
        info.roomParametersLen = 0;
        info.hostId = GetHostId();
        if( m_RoomParameters.size() > 0 )
        {
            for( std::map<std::string, STREAM::Union>::iterator itr = m_RoomParameters.begin(); m_RoomParameters.end() != itr; ++itr ) {
                STREAM::Text    roomParamKey = STREAM::Text(itr->first);
                info.roomParameters[info.roomParametersLen] = STREAM::KeyValue( roomParamKey, itr->second );
                info.roomParametersLen++;
            }
        }
        info.lobbyParametersLen = 0;
        if( m_LobbyParameters.size() > 0 )
        {
            for( std::vector<std::string>::iterator itr = m_LobbyParameters.begin(); m_LobbyParameters.end() != itr; ++itr ) {
                info.lobbyParameters[info.lobbyParametersLen] = STREAM::Text(*itr);
                info.lobbyParametersLen++;
            }
        }
    }
    std::map<int32, MatchingPlayerInRoom >* GetPlayers() { return &m_PlayersInRoom; }
    
    MatchingPlayerInRoom*   GetPlayer(int32 id) {
        if( m_PlayersInRoom.size() == 0 )   return NULL;
        std::map< int32, MatchingPlayerInRoom >::iterator itr = m_PlayersInRoom.find(id);
        return ( m_PlayersInRoom.end() != itr ) ? &(itr->second) : NULL;
    }
    
    void    AddPlayer( int32 playerId, uint32 clientId, std::string clientName, MatchingPlayerInRoom& player ) {
        m_PlayersInRoom.insert( std::pair< int32, MatchingPlayerInRoom >( playerId, MatchingPlayerInRoom( playerId, clientId, clientName, player.GetParameters(), player.GetParametersLen() ) ) );
    }
    
    void    RemovePlayer( int32 playerId ) {
        m_PlayersInRoom.erase( playerId );
    }
    
    int32   GetHostId() {
        if ( 0 < m_HostId ){
            // 該当するプレイヤーが存在する場合、値をそのまま返す
            if( NULL != GetPlayer( m_HostId ) ) {
                return  m_HostId;
            }
        }
        
        if ( ! m_IsNeedHostPlayer ){
            m_HostId = 0;
        }else{
            // 該当するプレイヤーが存在しない場合、ルーム内プレイヤーのうち、最も古いプレイヤーを新規ルームマスターとして、そのIDを返す
            m_HostId = ( 0 == m_PlayersInRoom.size() ) ? 0 : m_PlayersInRoom.begin()->first;
        }
        return  m_HostId;
    }
    
    void    SetHostId(int32 hostId) { m_HostId = hostId; }
    
    int32   GetNextPlayerId() { return ++m_NextPlayerId; }
    
    std::map< std::string, STREAM::Union >& GetRoomParameters() { return m_RoomParameters; }
    
    void    SetRoomParameters(std::map< std::string, STREAM::Union >& roomParameters) { m_RoomParameters = roomParameters; }
    
    void    SetRoomParameters(STREAM::KeyValue* pRoomParameters, uint16 roomParametersLen) {
        m_RoomParameters.clear();
        for( uint16 index = 0; index < roomParametersLen; index++ ) {
            m_RoomParameters[pRoomParameters[index].key.text] = pRoomParameters[index].value;
        }
    }
    
    std::vector< std::string >& GetLobbyParameters() { return m_LobbyParameters; }
    
    void    SetLobbyParameters(std::vector< std::string >& lobbyParameters) { m_LobbyParameters = lobbyParameters; }
    
    void    SetLobbyParameters(STREAM::Text* pLobbyParameters, uint16 lobbyParametersLen ) {
        m_LobbyParameters.clear();
        for( uint16 index = 0; index < lobbyParametersLen; index++ ) {
            m_LobbyParameters.push_back(pLobbyParameters[index].text);
        }
    }
    
    std::map<std::string, STREAM::Union>        GetVisibleRoomParameters() {
        std::map<std::string, STREAM::Union>        roomParameters;
        // ルームパラメータのうち、ロビー通知パラメータに登録されている要素を roomParameters に登録
        for( std::vector<std::string>::iterator itr = m_LobbyParameters.begin(); m_LobbyParameters.end() != itr; ++itr ) {
            if( m_RoomParameters.end() == m_RoomParameters.find( *itr ) )   continue;
            roomParameters.insert( std::pair<std::string, STREAM::Union>( *itr, m_RoomParameters[ *itr ] ) );
        }
        return  roomParameters;
    }
    
    uint64  GetRoomUid() { return m_RoomUid; }
    
    void    SetRoomUid(uint64 roomUid) { m_RoomUid = roomUid; }
    
    bool    GetIsNeedHostPlayer() { return m_IsNeedHostPlayer; }
    
public:
    MatchingRoom( uint64 id = 0, std::string name = "", uint64 lobbyId = 0, bool isVisible = true, bool isOpen = true, uint32 maxPlayers = 0, uint64 roomUid = 0, bool isNeedHostPlayer = true )
    {
        m_Id = id;
        m_Name = name;
        m_LobbyId = lobbyId;
        m_IsVisible = isVisible;
        m_IsOpen = isOpen;
        m_MaxPlayers = maxPlayers;
        
        m_HostId = 0;
        m_NextPlayerId = 0;
        
        m_RoomUid = roomUid;
        m_IsNeedHostPlayer = isNeedHostPlayer;
    }
    
    virtual ~MatchingRoom() {}
    
public:
    bool    IsRandomJoinable( uint32 maxPlayers = 0 );
};

#endif /* __MUN_MASTER_MATCHING_ROOM_HPP__ */