IMatchmaking.h

Go to the documentation of this file.

#ifndef GALAXY_I_MATCHMAKING_H
#define GALAXY_I_MATCHMAKING_H
 
#include "GalaxyID.h"
#include "IListenerRegistrar.h"
 
namespace galaxy
{
    namespace api
    {
        enum LobbyType
        {
            LOBBY_TYPE_PRIVATE, 
            LOBBY_TYPE_FRIENDS_ONLY, 
            LOBBY_TYPE_PUBLIC, 
            LOBBY_TYPE_INVISIBLE_TO_FRIENDS 
        };
 
        enum LobbyTopologyType
        {
            DEPRECATED_LOBBY_TOPOLOGY_TYPE_FCM_HOST_MIGRATION, 
            LOBBY_TOPOLOGY_TYPE_FCM, 
            LOBBY_TOPOLOGY_TYPE_STAR, 
            LOBBY_TOPOLOGY_TYPE_CONNECTIONLESS, 
            LOBBY_TOPOLOGY_TYPE_FCM_OWNERSHIP_TRANSITION 
        };
 
        enum LobbyMemberStateChange
        {
            LOBBY_MEMBER_STATE_CHANGED_ENTERED = 0x0001, 
            LOBBY_MEMBER_STATE_CHANGED_LEFT = 0x0002, 
            LOBBY_MEMBER_STATE_CHANGED_DISCONNECTED = 0x0004, 
            LOBBY_MEMBER_STATE_CHANGED_KICKED = 0x0008, 
            LOBBY_MEMBER_STATE_CHANGED_BANNED = 0x0010 
        };
 
        enum LobbyComparisonType
        {
            LOBBY_COMPARISON_TYPE_EQUAL, 
            LOBBY_COMPARISON_TYPE_NOT_EQUAL, 
            LOBBY_COMPARISON_TYPE_GREATER, 
            LOBBY_COMPARISON_TYPE_GREATER_OR_EQUAL, 
            LOBBY_COMPARISON_TYPE_LOWER, 
            LOBBY_COMPARISON_TYPE_LOWER_OR_EQUAL 
        };
 
        enum LobbyCreateResult
        {
            LOBBY_CREATE_RESULT_SUCCESS, 
            LOBBY_CREATE_RESULT_ERROR, 
            LOBBY_CREATE_RESULT_CONNECTION_FAILURE 
        };
 
        enum LobbyEnterResult
        {
            LOBBY_ENTER_RESULT_SUCCESS, 
            LOBBY_ENTER_RESULT_LOBBY_DOES_NOT_EXIST, 
            LOBBY_ENTER_RESULT_LOBBY_IS_FULL, 
            LOBBY_ENTER_RESULT_ERROR, 
            LOBBY_ENTER_RESULT_CONNECTION_FAILURE 
        };
 
        enum LobbyListResult
        {
            LOBBY_LIST_RESULT_SUCCESS, 
            LOBBY_LIST_RESULT_ERROR, 
            LOBBY_LIST_RESULT_CONNECTION_FAILURE 
        };
 
        class ILobbyListListener : public GalaxyTypeAwareListener<LOBBY_LIST>
        {
        public:
 
            virtual void OnLobbyList(uint32_t lobbyCount, LobbyListResult result) = 0;
        };
 
        typedef SelfRegisteringListener<ILobbyListListener> GlobalLobbyListListener;
 
        class ILobbyCreatedListener : public GalaxyTypeAwareListener<LOBBY_CREATED>
        {
        public:
 
            virtual void OnLobbyCreated(const GalaxyID& lobbyID, LobbyCreateResult result) = 0;
        };
 
        typedef SelfRegisteringListener<ILobbyCreatedListener> GlobalLobbyCreatedListener;
 
        typedef SelfRegisteringListener<ILobbyCreatedListener, GameServerListenerRegistrar> GameServerGlobalLobbyCreatedListener;
 
        class ILobbyEnteredListener : public GalaxyTypeAwareListener<LOBBY_ENTERED>
        {
        public:
 
            virtual void OnLobbyEntered(const GalaxyID& lobbyID, LobbyEnterResult result) = 0;
        };
 
        typedef SelfRegisteringListener<ILobbyEnteredListener> GlobalLobbyEnteredListener;
 
        typedef SelfRegisteringListener<ILobbyEnteredListener, GameServerListenerRegistrar> GameServerGlobalLobbyEnteredListener;
 
        class ILobbyLeftListener : public GalaxyTypeAwareListener<LOBBY_LEFT>
        {
        public:
 
            enum LobbyLeaveReason
            {
                LOBBY_LEAVE_REASON_UNDEFINED, 
                LOBBY_LEAVE_REASON_USER_LEFT, 
                LOBBY_LEAVE_REASON_LOBBY_CLOSED, 
                LOBBY_LEAVE_REASON_CONNECTION_LOST 
            };
 
            virtual void OnLobbyLeft(const GalaxyID& lobbyID, LobbyLeaveReason leaveReason) = 0;
        };
 
        typedef SelfRegisteringListener<ILobbyLeftListener> GlobalLobbyLeftListener;
 
        typedef SelfRegisteringListener<ILobbyLeftListener, GameServerListenerRegistrar> GameServerGlobalLobbyLeftListener;
 
        class ILobbyDataListener : public GalaxyTypeAwareListener<LOBBY_DATA>
        {
        public:
 
            virtual void OnLobbyDataUpdated(const GalaxyID& lobbyID, const GalaxyID& memberID) = 0;
        };
 
        typedef SelfRegisteringListener<ILobbyDataListener> GlobalLobbyDataListener;
 
        typedef SelfRegisteringListener<ILobbyDataListener, GameServerListenerRegistrar> GameServerGlobalLobbyDataListener;
 
        class ILobbyDataUpdateListener : public GalaxyTypeAwareListener<LOBBY_DATA_UPDATE_LISTENER>
        {
        public:
 
            virtual void OnLobbyDataUpdateSuccess(const GalaxyID& lobbyID) = 0;
 
            enum FailureReason
            {
                FAILURE_REASON_UNDEFINED, 
                FAILURE_REASON_LOBBY_DOES_NOT_EXIST, 
                FAILURE_REASON_CONNECTION_FAILURE 
            };
 
            virtual void OnLobbyDataUpdateFailure(const GalaxyID& lobbyID, FailureReason failureReason) = 0;
        };
 
        class ILobbyMemberDataUpdateListener : public GalaxyTypeAwareListener<LOBBY_MEMBER_DATA_UPDATE_LISTENER>
        {
        public:
 
            virtual void OnLobbyMemberDataUpdateSuccess(const GalaxyID& lobbyID, const GalaxyID& memberID) = 0;
 
            enum FailureReason
            {
                FAILURE_REASON_UNDEFINED, 
                FAILURE_REASON_LOBBY_DOES_NOT_EXIST, 
                FAILURE_REASON_CONNECTION_FAILURE 
            };
 
            virtual void OnLobbyMemberDataUpdateFailure(const GalaxyID& lobbyID, const GalaxyID& memberID, FailureReason failureReason) = 0;
        };
 
        class ILobbyDataRetrieveListener : public GalaxyTypeAwareListener<LOBBY_DATA_RETRIEVE>
        {
        public:
 
            virtual void OnLobbyDataRetrieveSuccess(const GalaxyID& lobbyID) = 0;
 
            enum FailureReason
            {
                FAILURE_REASON_UNDEFINED, 
                FAILURE_REASON_LOBBY_DOES_NOT_EXIST, 
                FAILURE_REASON_CONNECTION_FAILURE 
            };
 
            virtual void OnLobbyDataRetrieveFailure(const GalaxyID& lobbyID, FailureReason failureReason) = 0;
        };
 
        typedef SelfRegisteringListener<ILobbyDataRetrieveListener> GlobalLobbyDataRetrieveListener;
 
        typedef SelfRegisteringListener<ILobbyDataRetrieveListener, GameServerListenerRegistrar> GameServerGlobalLobbyDataRetrieveListener;
 
        class ILobbyMemberStateListener : public GalaxyTypeAwareListener<LOBBY_MEMBER_STATE>
        {
        public:
 
            virtual void OnLobbyMemberStateChanged(const GalaxyID& lobbyID, const GalaxyID& memberID, LobbyMemberStateChange memberStateChange) = 0;
        };
 
        typedef SelfRegisteringListener<ILobbyMemberStateListener> GlobalLobbyMemberStateListener;
 
        typedef SelfRegisteringListener<ILobbyMemberStateListener, GameServerListenerRegistrar> GameServerGlobalLobbyMemberStateListener;
 
        class ILobbyOwnerChangeListener : public GalaxyTypeAwareListener<LOBBY_OWNER_CHANGE>
        {
        public:
 
            virtual void OnLobbyOwnerChanged(const GalaxyID& lobbyID, const GalaxyID& newOwnerID) = 0;
        };
 
        typedef SelfRegisteringListener<ILobbyOwnerChangeListener> GlobalLobbyOwnerChangeListener;
 
        class ILobbyMessageListener : public GalaxyTypeAwareListener<LOBBY_MESSAGE>
        {
        public:
 
            virtual void OnLobbyMessageReceived(const GalaxyID& lobbyID, const GalaxyID& senderID, uint32_t messageID, uint32_t messageLength) = 0;
        };
 
        typedef SelfRegisteringListener<ILobbyMessageListener> GlobalLobbyMessageListener;
 
        typedef SelfRegisteringListener<ILobbyMessageListener, GameServerListenerRegistrar> GameServerGlobalLobbyMessageListener;
 
        class IMatchmaking
        {
        public:
 
            virtual ~IMatchmaking()
            {
            }
 
            virtual void CreateLobby(
                LobbyType lobbyType,
                uint32_t maxMembers,
                bool joinable,
                LobbyTopologyType lobbyTopologyType,
                ILobbyCreatedListener* const lobbyCreatedListener = NULL,
                ILobbyEnteredListener* const lobbyEnteredListener = NULL) = 0;
 
            virtual void RequestLobbyList(bool allowFullLobbies = false, ILobbyListListener* const listener = NULL) = 0;
 
            virtual void AddRequestLobbyListResultCountFilter(uint32_t limit) = 0;
 
            virtual void AddRequestLobbyListStringFilter(const char* keyToMatch, const char* valueToMatch, LobbyComparisonType comparisonType) = 0;
 
            virtual void AddRequestLobbyListNumericalFilter(const char* keyToMatch, int32_t valueToMatch, LobbyComparisonType comparisonType) = 0;
 
            virtual void AddRequestLobbyListNearValueFilter(const char* keyToMatch, int32_t valueToBeCloseTo) = 0;
 
            virtual GalaxyID GetLobbyByIndex(uint32_t index) = 0;
 
            virtual void JoinLobby(GalaxyID lobbyID, ILobbyEnteredListener* const listener = NULL) = 0;
 
            virtual void LeaveLobby(GalaxyID lobbyID, ILobbyLeftListener* const listener = NULL) = 0;
 
            virtual void SetMaxNumLobbyMembers(GalaxyID lobbyID, uint32_t maxNumLobbyMembers, ILobbyDataUpdateListener* const listener = NULL) = 0;
 
            virtual uint32_t GetMaxNumLobbyMembers(GalaxyID lobbyID) = 0;
 
            virtual uint32_t GetNumLobbyMembers(GalaxyID lobbyID) = 0;
 
            virtual GalaxyID GetLobbyMemberByIndex(GalaxyID lobbyID, uint32_t index) = 0;
 
            virtual void SetLobbyType(GalaxyID lobbyID, LobbyType lobbyType, ILobbyDataUpdateListener* const listener = NULL) = 0;
 
            virtual LobbyType GetLobbyType(GalaxyID lobbyID) = 0;
 
            virtual void SetLobbyJoinable(GalaxyID lobbyID, bool joinable, ILobbyDataUpdateListener* const listener = NULL) = 0;
 
            virtual bool IsLobbyJoinable(GalaxyID lobbyID) = 0;
 
            virtual void RequestLobbyData(GalaxyID lobbyID, ILobbyDataRetrieveListener* const listener = NULL) = 0;
 
            virtual const char* GetLobbyData(GalaxyID lobbyID, const char* key) = 0;
 
            virtual void GetLobbyDataCopy(GalaxyID lobbyID, const char* key, char* buffer, uint32_t bufferLength) = 0;
 
            virtual void SetLobbyData(GalaxyID lobbyID, const char* key, const char* value, ILobbyDataUpdateListener* const listener = NULL) = 0;
 
            virtual uint32_t GetLobbyDataCount(GalaxyID lobbyID) = 0;
 
            virtual bool GetLobbyDataByIndex(GalaxyID lobbyID, uint32_t index, char* key, uint32_t keyLength, char* value, uint32_t valueLength) = 0;
 
            virtual void DeleteLobbyData(GalaxyID lobbyID, const char* key, ILobbyDataUpdateListener* const listener = NULL) = 0;
 
            virtual const char* GetLobbyMemberData(GalaxyID lobbyID, GalaxyID memberID, const char* key) = 0;
 
            virtual void GetLobbyMemberDataCopy(GalaxyID lobbyID, GalaxyID memberID, const char* key, char* buffer, uint32_t bufferLength) = 0;
 
            virtual void SetLobbyMemberData(GalaxyID lobbyID, const char* key, const char* value, ILobbyMemberDataUpdateListener* const listener = NULL) = 0;
 
            virtual uint32_t GetLobbyMemberDataCount(GalaxyID lobbyID, GalaxyID memberID) = 0;
 
            virtual bool GetLobbyMemberDataByIndex(GalaxyID lobbyID, GalaxyID memberID, uint32_t index, char* key, uint32_t keyLength, char* value, uint32_t valueLength) = 0;
 
            virtual void DeleteLobbyMemberData(GalaxyID lobbyID, const char* key, ILobbyMemberDataUpdateListener* const listener = NULL) = 0;
 
            virtual GalaxyID GetLobbyOwner(GalaxyID lobbyID) = 0;
 
            virtual bool SendLobbyMessage(GalaxyID lobbyID, const void* data, uint32_t dataSize) = 0;
 
            virtual uint32_t GetLobbyMessage(GalaxyID lobbyID, uint32_t messageID, GalaxyID& senderID, char* msg, uint32_t msgLength) = 0;
        };
 
    }
}
 
#endif