GxP2PSessionManager.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
GX_P2P_NAMESPACE_BEGIN()
 
//===========================================================================
//===========================================================================
class GxP2PStation
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // friend宣言
    friend class GxP2PSessionManager;
 
    static constexpr nu32 INVALID_STATION_INDEX         = static_cast<nu32>(-1);
private:
    static constexpr nu32 IPADDRESS_STRING_MAX          = GxMath::VALUE_16;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GxP2PStation(void){ clear(); }
    ~GxP2PStation(void){}
 
    void clear(void);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    constexpr nu32 getIndex(void)               const   { return _index; }
    GX_FORCE_INLINE b32  isLocal(void)          const   { return _isLocal; }
    GX_FORCE_INLINE b32  isHost(void)           const   { return _isHost; }
    GX_FORCE_INLINE b32  isActive(void)         const   { return _isActive; }
    GX_FORCE_INLINE b32  isReady(void)          const   { return _isReady; }
    constexpr nu32    getPingAverage(void)      const   { return _pingAverage; }
    constexpr nu32    getIPAddress(void)        const   { return _sockAddress.sin_addr.s_addr; }
    constexpr nu32    getPort(void)             const   { return _sockAddress.sin_port; }
    constexpr GX_CSTR getIPAddressString(void)  const   { return _ipAddress; }
#if GX_DEVELOP
    constexpr nu32    getRecievePacketBytesMomentary(void) const    { return _recievePacketBytesMomentary; }
    constexpr nu32    getSendPacketBytesMomentary(void) const   { return _sendPacketBytesMomentary; }
    constexpr nu32    getRecievePacketBytesPeek(void)   const   { return _recievePacketBytesPeek; }
    constexpr nu32    getSendPacketBytesPeek(void)      const   { return _sendPacketBytesPeek; }
    constexpr nu32    getRecievePacketCountMomentary(void) const    { return _recievePacketCountMomentary; }
    constexpr nu32    getSendPacketCountMomentary(void) const   { return _sendPacketCountMomentary; }
    constexpr nu32    getRecievePacketCountPeek(void)   const   { return _recievePacketCountPeek; }
    constexpr nu32    getSendPacketCountPeek(void)      const   { return _sendPacketCountPeek; }
#endif  // GX_DEVELOP
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    nu32                _index;                             
    b32                 _isLocal;                           
    b32                 _isHost;                            
    b32                 _isActive;                          
    b32                 _isReady;                           
    nu32                _pingAverage;                       
    sockaddr_in         _sockAddress;                       
#if GX_DEVELOP
    nu32                _recievePacketBytesMomentary;       
    nu32                _sendPacketBytesMomentary;          
    nu32                _recievePacketBytesPeek;            
    nu32                _sendPacketBytesPeek;               
    nu32                _recievePacketCountMomentary;       
    nu32                _sendPacketCountMomentary;          
    nu32                _recievePacketCountPeek;            
    nu32                _sendPacketCountPeek;               
#endif  // GX_DEVELOP
    GX_CHAR             _ipAddress[IPADDRESS_STRING_MAX];   
 
};
 
//===========================================================================
//===========================================================================
class GxP2PSessionManager
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // フレンド宣言
    friend class GxP2PMessageManager;
 
private:
    // プライベート定数定義
    static constexpr nu32  DEBUG_SERVER_PRINT_LEVEL  = 3;
    static constexpr nu16  DEBUG_SERVER_RECV_PORT    = 6200;
    static constexpr nu16  DEBUG_SERVER_SEND_PORT    = 6199;
    static constexpr nu32  DEBUG_SERVER_MAGIC_NUMBER = 0x22222222;
 
public:
    // パブリック定数定義
    static constexpr ns32  LOCAL_GAMER_MAX           = 1;
    static constexpr ns32  NETWORK_GAMER_MAX         = 8;
    static constexpr nu32  IPADDRESS_STRING_MAX      = 16;
    static constexpr nu32  DEFAULT_USE_PORT          = 6221;
    static constexpr nu32  DEFAULT_SYSTEM_LINK_PORT  = 6220;
    static constexpr nu32  DEFAULT_MAGIC_NUMBER      = 0x00DCBA98;
    static constexpr nu32  SEARCH_SESSION_MAX        = MyNetworkSession::SYSTEMLINK_HOST_MAX;
 
    enum class CREATE_MODE
    {
        LAN = 0,                                
        INET                                    
    };
 
    enum class LEAVE_MODE
    {
        EXCLUSION = 0,                          
        TOLERANCE,                              
        CLIENT_SERVER                           
    };
 
    enum class EVENT
    {
        NONE = 0,                               
        JOIN,                                   
        LEAVE,                                  
        DESTROY,                                
        START_GAME,                             
        END_GAME                                
    };
 
    enum class ERROR_TYPE
    {
        NONE                        = 0,        
        
        INVALID                     = -1,       
        NOTFOUND                    = -2,       
        HOST_END                    = -3,       
        DISCONNECT                  = -4,       
        NOT_HOST                    = -5,       
        NOT_SESSION                 = -6,       
        ALREADY_DONE                = -7,       
    };
 
    enum class ASYNC_PROCESS
    {
        NONE = 0,                               
        CREATE_SESSION,                         
        JOIN_SESSION,                           
        LEAVE_SESSION,                          
        SEARCH_SESSION,                         
        KICKOUT_SESSION                         
    };
 
    enum class ASYNC_RESULT
    {
        PROGRESS = 0,                           
        SUCCESS,                                
        FAILED                                  
    };
 
    struct GxSessionInformation
    {
        union
        {
            CREATE_MODE _mode;                  
            nu64        _host;                  
        } _union;
        nu32            _magic;                 
    };
 
    struct GxSessionParameter
    {
        b32             _allowHostMigration;    
        b32             _allowJoinOnTheWay;     
    };
 
    struct GxDebugServerInformation
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        GxDebugServerInformation(GX_CSTR ip, ns32 printLV = DEBUG_SERVER_PRINT_LEVEL, nu16 recievePort = DEBUG_SERVER_RECV_PORT, nu16 sendPort = DEBUG_SERVER_SEND_PORT, nu32 magicNumber = DEBUG_SERVER_MAGIC_NUMBER)
            : _ipAddress(ip)
            , _printLV(printLV)
            , _recievePort(recievePort)
            , _sendPort(sendPort)
            , _magicNumber(magicNumber)
        {}
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
 
        GX_CSTR         _ipAddress;             
        ns32            _printLV;               
        nu16            _recievePort;           
        nu16            _sendPort;              
        nu32            _magicNumber;           
 
    };
 
    typedef void (*EVENT_CALLBACK_FUNCTION)(GxP2PSessionManager::EVENT type, GxP2PSessionManager::ERROR_TYPE error, nu32 gamerId);
 
private:
    class GxP2PAsyncThread : public GxThread
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        static constexpr s32 WAIT_INFINITY = -1;
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        void threadMain(void* pArgument) override;
 
        GX_FORCE_INLINE b32 waitStartEvent(s32 milliSecond = WAIT_INFINITY) { return _startEvent.waitEvent(milliSecond); }
        GX_FORCE_INLINE b32 setStartEvent(void) { return _startEvent.setEvent(); }
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    private:
        GxEvent _startEvent;        
 
    };
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
public:
    GxP2PSessionManager(void);
    ~GxP2PSessionManager(void);
 
    b32 initialize(nu32 port = DEFAULT_USE_PORT, nu32 magicNumber = DEFAULT_MAGIC_NUMBER, nu32 systemLinkPort = DEFAULT_SYSTEM_LINK_PORT);
    void   terminate(void);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    b32 update(nu32 elapsedMilliSecond);
 
    void   registerEventCallback(EVENT_CALLBACK_FUNCTION callback);
 
#if GX_DEVELOP
    b32 initializeDebugServer(const GxDebugServerInformation& debugServerInformation);
    void   terminateDebugServer(void);
#endif  // GX_DEVELOP
 
    b32 createSession(CREATE_MODE mode);
    b32 joinSession(GX_CSTR address);
    b32 joinSession(nu32 address);
    b32 joinSession(const GxSessionInformation& session);
    b32 leaveSession(void);
    b32 searchSession(GxSessionInformation* pDst, nu32* pNum);
    b32 kickoutSession(const GxP2PStation& station);
 
    b32 createSessionAsync(CREATE_MODE mode);
    b32 joinSessionAsync(GX_CSTR address);
    b32 joinSessionAsync(nu32 address);
    b32 joinSessionAsync(const GxSessionInformation& session);
    b32 leaveSessionAsync(void);
    b32 searchSessionAsync(GxSessionInformation* pDst, u32* pNum);
    b32 kickoutSessionAsync(const GxP2PStation& station);
 
public:
    void   readyGameSession(void);
    b32 startGameSession(const GxSessionParameter* pParam = nullptr);
    b32 endGameSession(void);
 
private:
    b32 getLocalNetworkGamer(MyNetLib::MyNetworkGamerLocal& dst);
 
    b32 open(void);
    b32 close(void);
 
    void setErrorValue(MyNetLib::GPlatform::PLATFORM_RETURN error);
    void setErrorValue(MyNetLib::SGS_Enum error);
    void setErrorValue(MyNetLib::SGE_Enum error);
    void setErrorValue(MyNetLib::GK_Enum error);
 
    constexpr void setAsyncRequest(ASYNC_PROCESS request) { _asyncRequest = request; _asyncResult = ASYNC_RESULT::PROGRESS; _errorType = ERROR_TYPE::NONE; }
    constexpr ASYNC_PROCESS getAsyncRequest(void) const { return _asyncRequest; }
    GX_FORCE_INLINE b32 isConflictAsyncRequest(void) const { return (_asyncRequest != ASYNC_PROCESS::NONE); }
    constexpr void setAsyncResult(ASYNC_RESULT result, ERROR_TYPE error) { _asyncRequest = ASYNC_PROCESS::NONE; _asyncResult = result; _errorType = error; }
    void waitAsyncResult(void);
 
    void clearStation(void);
 
    static nu32 atoiIPAddress(GX_CSTR ipAddress);
 
    static ns32 __stdcall callbackJoinedGamer(void* pObject, nu32 gamerId);
    static ns32 __stdcall callbackLeftGamer(void* pObject, nu32 gamerId);
    static ns32 __stdcall callbackFindHost(void* pObject, nu64 hosts[], nu32 magic[]);
    static ns32 __stdcall callbackEndSession(void* pObject, MyNetLib::SEC_Enum error);
    static ns32 __stdcall callbackStartGame(void* pObject);
    static ns32 __stdcall callbackEndGame(void* pObject);                               
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_FORCE_INLINE MyNetLib::MyNetworkSession* getSessionInstance(void) { return &_sessionInstance; }
 
    constexpr GX_CSTR getIPAddressString(void) const { return _ipAddress; }
    constexpr ASYNC_RESULT getAsyncResult(void) const { return _asyncResult; }
    constexpr ERROR_TYPE getError(void) const { return _errorType; }
 
    const GxP2PStation* getStation(void)                const;
    const GxP2PStation* getStation(nu32 index)          const;
    const GxP2PStation* getStationHost(void)            const;
    constexpr nu32 getStationNum(void) const { return _stationNum; }
    
    GX_FORCE_INLINE b32 isJoined(void) const { return (getStation() != nullptr); }
    GX_FORCE_INLINE b32 isHost(void) const { return _sessionInstance.IsHost(); }
    b32 isReady(void)                               const;
    b32 isGameSession(void)                         const;
 
    static void getIPAddressFromValue(GX_STR pDst, u32 address);
    static void getIPAddressFromHost(GX_STR pDst, u64 host);
 
#if GX_DEVELOP
    GX_FORCE_INLINE void setDebugSimulatePacketLatency(nu32 milliSeconds) { _sessionInstance.setDebugSimulatePacketLatency(milliSeconds); }
    GX_FORCE_INLINE nu32 getDebugSimulatePacketLatency(void) const { return _sessionInstance.getDebugSimulatePacketLatency(); }
    GX_FORCE_INLINE void setDebugSimulatePacketLost(nf32 probability) { _sessionInstance.setDebugSimulatePacketLost(probability); }
    GX_FORCE_INLINE nf32 getDebugSimulatePacketLost(void) const { return _sessionInstance.getDebugSimulatePacketLost(); }
#endif  // GX_DEVELOP
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
private:
    MyNetLib::MyNetworkSession      _sessionInstance;               
    GX_CHAR                         _ipAddress[IPADDRESS_STRING_MAX];   
    nu32                            _port;                          
    nu32                            _magicNumber;                   
    nu32                            _systemLinkPort;                
 
    EVENT_CALLBACK_FUNCTION         _pEventCallback;                
    GxP2PStation                    _station[NETWORK_GAMER_MAX];    
    nu32                            _stationNum;                    
 
    b32                             _isOpenSession;                 
    b32                             _isGameSession;                 
#if GX_DEVELOP
    b32                             _isUseDebugServer;              
#endif  // GX_DEVELOP
 
    GxP2PAsyncThread                _thread;                        
    b32                             _isStopThread;                  
    ASYNC_PROCESS                   _asyncRequest;                  
    ASYNC_RESULT                    _asyncResult;                   
    ERROR_TYPE                      _errorType;                     
    MyNetLib::DCM_Enum              _leaveMode;                     
 
    nu32                            _kickoutNo;                     
 
    GxSessionInformation            _joinHost;                      
    GxSessionInformation*           _pSearchResult;                 
    nu32*                           _pSearchNum;                    
 
};
 
GX_P2P_NAMESPACE_END()