GxSysP2P.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
GX_P2P_NAMESPACE_BEGIN()
 
//===========================================================================
//===========================================================================
class GxSysP2P : public GxSysP2PBase
{
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    // RTTI宣言
    GX_RTTI_ABSTRACT_CLASS(GxSysP2P, GxSysP2PBase)
    // ClassBase継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE(GxSysP2P)
 
    
    enum NETWORK_SERVICE
    {
        NETWORK_SERVICE_MESSAGE   = 0x00000001,         
        NETWORK_SERVICE_SYNC      = 0x00000002,         
        NETWORK_SERVICE_DUPLICATE = 0x00000004,         
        NETWORK_SERVICE_REMOTE    = 0x00000010,         
        NETWORK_SERVICE_UPNP      = 0x00001000,         
        
        NETWORK_SERVICE_ALL       = 0xFFFFFFFF          
    };
 
    enum class NETWORK_RESULT
    {
        SUCCESS             = 0,                        
        ERROR_INVALID       = -1                        
    };
 
    static constexpr u32 STATION_MAX = GxP2PSessionManager::NETWORK_GAMER_MAX;
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    GxSysP2P(void);
 
    static void loadModule(void) {}
    static void unloadModule(void) {}
 
    void terminate(void) override;
    
    virtual NETWORK_RESULT startNetwork(GxP2PSessionManager::EVENT_CALLBACK_FUNCTION eventCallback = GxSysP2P::callbackEvent, u32 port = GxP2PSessionManager::DEFAULT_USE_PORT, u32 magicNumber = GxP2PSessionManager::DEFAULT_MAGIC_NUMBER, nu32 systemLinkPort = GxP2PSessionManager::DEFAULT_SYSTEM_LINK_PORT);
    virtual void           endNetwork(void);
    
    virtual b32  startService(u32 serviceFlags);
    virtual void endService(u32 serviceFlags);
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
public:
    void update(void) override;
    
    b32 createSession(GxP2PSessionManager::CREATE_MODE mode);
    b32 joinSession(GX_CSTR address);
    b32 joinSession(u32 address);
    b32 joinSession(const GxP2PSessionManager::GxSessionInformation& session);
    b32 leaveSession(void);
    b32 searchSession(GxP2PSessionManager::GxSessionInformation* pDst, u32* pNum);
    b32 kickoutSession(const GxP2PStation& station);
 
    b32 createSessionAsync(GxP2PSessionManager::CREATE_MODE mode);
    b32 joinSessionAsync(GX_CSTR address);
    b32 joinSessionAsync(u32 address);
    b32 joinSessionAsync(const GxP2PSessionManager::GxSessionInformation& session);
    b32 leaveSessionAsync(void);
    b32 searchSessionAsync(GxP2PSessionManager::GxSessionInformation* pDst, u32* pNum);
    b32 kickoutSessionAsync(const GxP2PStation& station);
 
public:
    void readyGameSession(void);
    b32  startGameSession(const GxP2PSessionManager::GxSessionParameter* pParam = nullptr);
    b32  endGameSession(void);
 
    static void callbackEvent(GxP2PSessionManager::EVENT type, GxP2PSessionManager::ERROR_TYPE error, u32 stationId);
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_FORCE_INLINE GxP2PSessionManager::ASYNC_RESULT getAsyncResult(void) const { return (_pSessionManager) ? _pSessionManager->getAsyncResult() : GxP2PSessionManager::ASYNC_RESULT::SUCCESS; }
    GX_FORCE_INLINE GxP2PSessionManager::ERROR_TYPE getError(void) const { return (_pSessionManager) ? _pSessionManager->getError() : GxP2PSessionManager::ERROR_TYPE::NONE; }
 
    //---- ステーション情報
 
    const GxP2PStation* getStation(void)                        const;
    const GxP2PStation* getStation(u32 index)                   const;
    const GxP2PStation* getStationHost(void)                    const;
    u32                 getStationNum(void)                     const;
    u32                 getStationId(void)                      const;
    
    //---- サービス情報
 
    GX_FORCE_INLINE b32 isServedSessionManager(void)                            const   { return (_pSessionManager != nullptr); }
    GX_FORCE_INLINE b32 isServedMessageManager(void)                            const   { return (_pMessageManager != nullptr); }
    GX_FORCE_INLINE b32 isServedSyncManager(void)                               const   { return (_pSyncManager != nullptr); }
    GX_FORCE_INLINE b32 isServedDuplicateManager(void)                          const   { return (_pDuplicateManager != nullptr); }
    GX_FORCE_INLINE b32 isServedRemoteManager(void)                             const   { return (_pRemoteManager != nullptr); }
#if defined(_WINDOWS)
    GX_FORCE_INLINE b32 isServedUPnPManager(void)                               const   { return (_pUPnPManager != nullptr); }
#endif  // _WINDOWS
 
    //---- セッション情報
 
    b32 isJoined(void)                                          const;
    b32 isHost(void)                                            const;
    b32 isReady(void)                                           const;
    b32 isGameSession(void)                                     const;
 
    constexpr GxP2PSessionManager* getSessionManager(void) const { return _pSessionManager; }
    constexpr GxP2PMessageManager* getMessageManager(void) const { return _pMessageManager; }
    constexpr GxP2PSyncManager* getSyncManager(void) const { return _pSyncManager; }
    constexpr GxP2PDuplicateManager* getDuplicateManager(void) const { return _pDuplicateManager; }
    constexpr GxP2PRemoteManager* getRemoteManager(void) const { return _pRemoteManager; }
#if defined(_WINDOWS)
    constexpr GxP2PUPnPManager* getUPnPManager(void) const { return _pUPnPManager;  }
#endif  // _WINDOWS
 
    //-------------------------------------------------------------
    //-------------------------------------------------------------
protected:
    GxP2PSessionManager*                _pSessionManager;           
    GxP2PMessageManager*                _pMessageManager;           
    GxP2PSyncManager*                   _pSyncManager;              
    GxP2PDuplicateManager*              _pDuplicateManager;         
    GxP2PRemoteManager*                 _pRemoteManager;            
#if defined(_WINDOWS)
    GxP2PUPnPManager*                   _pUPnPManager;              
#endif  // _WINDOWS
 
};
 
// アクセスインターフェース
GX_FORCE_INLINE GxSysP2P* getGxSysP2P(void){ return static_cast<GxSysP2P*>(GxSysP2P::getSingletonPointer()); }
 
//---------------------------------------------------------------------------
// セッション作成
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 GxSysP2P::createSession(GxP2PSessionManager::CREATE_MODE mode)
{
    return (_pSessionManager) ? _pSessionManager->createSession(mode) : static_cast<b32>(false);
}
 
//---------------------------------------------------------------------------
// セッション参加 (IP文字列指定)
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 GxSysP2P::joinSession(GX_CSTR address)
{
    return (_pSessionManager) ? _pSessionManager->joinSession(address) : static_cast<b32>(false);
}
 
//---------------------------------------------------------------------------
// セッション参加 (IP数値指定)
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 GxSysP2P::joinSession(u32 address)
{
    return (_pSessionManager) ? _pSessionManager->joinSession(address) : static_cast<b32>(false);
}
 
//---------------------------------------------------------------------------
// セッション参加 (セッション指定)
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 GxSysP2P::joinSession(const GxP2PSessionManager::GxSessionInformation& session)
{
    return (_pSessionManager) ? _pSessionManager->joinSession(session) : static_cast<b32>(false);
}
 
//---------------------------------------------------------------------------
// セッション離脱
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 GxSysP2P::leaveSession(void)
{
    return (_pSessionManager) ? _pSessionManager->leaveSession() : static_cast<b32>(false);
}
 
//---------------------------------------------------------------------------
// セッション探索
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 GxSysP2P::searchSession(GxP2PSessionManager::GxSessionInformation* pDst, u32* pNum)
{
    return (_pSessionManager) ? _pSessionManager->searchSession(pDst, pNum) : static_cast<b32>(false);
}
 
//---------------------------------------------------------------------------
// セッションメンバーキックアウト
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 GxSysP2P::kickoutSession(const GxP2PStation& station)
{
    return (_pSessionManager) ? _pSessionManager->kickoutSession(station) : static_cast<b32>(false);
}
 
//---------------------------------------------------------------------------
// セッション作成 [非同期]
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 GxSysP2P::createSessionAsync(GxP2PSessionManager::CREATE_MODE mode)
{
    return (_pSessionManager) ? _pSessionManager->createSessionAsync(mode) : static_cast<b32>(false);
}
 
//---------------------------------------------------------------------------
// セッション参加 [非同期] (IP文字列指定)
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 GxSysP2P::joinSessionAsync(GX_CSTR address)
{
    return (_pSessionManager) ? _pSessionManager->joinSessionAsync(address) : static_cast<b32>(false);
}
 
//---------------------------------------------------------------------------
// セッション参加 [非同期] (IP数値指定)
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 GxSysP2P::joinSessionAsync(u32 address)
{
    return (_pSessionManager) ? _pSessionManager->joinSessionAsync(address) : static_cast<b32>(false);
}
 
//---------------------------------------------------------------------------
// セッション参加 [非同期] (LAN用)
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 GxSysP2P::joinSessionAsync(const GxP2PSessionManager::GxSessionInformation& session)
{
    return (_pSessionManager) ? _pSessionManager->joinSessionAsync(session) : static_cast<b32>(false);
}
 
//---------------------------------------------------------------------------
// セッション離脱 [非同期]
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 GxSysP2P::leaveSessionAsync(void)
{
    return (_pSessionManager) ? _pSessionManager->leaveSessionAsync() : static_cast<b32>(false);
}
 
//---------------------------------------------------------------------------
// セッション探索 [非同期]
//          探索完了時には実際に発見した数が pNum に格納されます
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 GxSysP2P::searchSessionAsync(GxP2PSessionManager::GxSessionInformation* pDst, u32* pNum)
{
    return (_pSessionManager) ? _pSessionManager->searchSessionAsync(pDst, pNum) : static_cast<b32>(false);
}
 
//---------------------------------------------------------------------------
// セッションメンバーキックアウト [非同期]
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 GxSysP2P::kickoutSessionAsync(const GxP2PStation& station)
{
    return (_pSessionManager) ? _pSessionManager->kickoutSessionAsync(station) : static_cast<b32>(false);
}
 
//---------------------------------------------------------------------------
// ゲームセッション準備
//---------------------------------------------------------------------------
GX_FORCE_INLINE void GxSysP2P::readyGameSession(void)
{
    if( _pSessionManager )
    {
        _pSessionManager->readyGameSession();
    }
}
 
//---------------------------------------------------------------------------
// ゲームセッション開始 (ホスト専用)
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 GxSysP2P::startGameSession(const GxP2PSessionManager::GxSessionParameter* pParam)
{
    return (_pSessionManager) ? _pSessionManager->startGameSession(pParam) : static_cast<b32>(false);
}
 
//---------------------------------------------------------------------------
// ゲームセッション終了 (ホスト専用)
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 GxSysP2P::endGameSession(void)
{
    return (_pSessionManager) ? _pSessionManager->endGameSession() : static_cast<b32>(false);
}
 
//---------------------------------------------------------------------------
// ステーションID取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE u32 GxSysP2P::getStationId(void) const
{
    const GxP2PStation* pStation = getStation();
    return (pStation) ? pStation->getIndex() : static_cast<u32>(GX_INVALID_HANDLE);
}
 
//---------------------------------------------------------------------------
// 自分ステーション取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxP2PStation* GxSysP2P::getStation(void) const
{
    return (_pSessionManager) ? _pSessionManager->getStation() : nullptr;
}
 
//---------------------------------------------------------------------------
// 指定ステーション取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxP2PStation* GxSysP2P::getStation(u32 index) const
{
    return (_pSessionManager) ? _pSessionManager->getStation(index) : nullptr;
}
 
//---------------------------------------------------------------------------
// ホストステーション取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE const GxP2PStation* GxSysP2P::getStationHost(void) const
{
    return (_pSessionManager) ? _pSessionManager->getStationHost() : nullptr;
}
 
//---------------------------------------------------------------------------
// ステーション数取得
//---------------------------------------------------------------------------
GX_FORCE_INLINE u32 GxSysP2P::getStationNum(void) const
{
    return (_pSessionManager) ? _pSessionManager->getStationNum() : 0;
}
 
//---------------------------------------------------------------------------
// セッション参加中判定
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 GxSysP2P::isJoined(void) const
{
    return (_pSessionManager) ? _pSessionManager->isJoined() : static_cast<b32>(false);
}
 
//---------------------------------------------------------------------------
// セッションホスト判定
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 GxSysP2P::isHost(void) const
{
    return (_pSessionManager) ? _pSessionManager->isHost() : static_cast<b32>(false);
}
 
//---------------------------------------------------------------------------
// ゲームセッション準備確認 (ホスト専用)
//          １人でも準備未完了であれば false を返却します。
//          定員と参加人数に関するチェックは行いませんので注意してください。
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 GxSysP2P::isReady(void) const
{
    return (_pSessionManager) ? _pSessionManager->isReady() : static_cast<b32>(false);
}
 
//---------------------------------------------------------------------------
// ゲームセッション中判定
//---------------------------------------------------------------------------
GX_FORCE_INLINE b32 GxSysP2P::isGameSession(void) const
{
    return (_pSessionManager) ? _pSessionManager->isGameSession() : static_cast<b32>(false);
}
 
GX_P2P_NAMESPACE_END()