Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

142 lines
5.9 KiB

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Manages CPlayerGroups (A group of players stored on the GC)
//
//=============================================================================
#ifndef PLAYERGROUPMANAGER_H
#define PLAYERGROUPMANAGER_H
#ifdef _WIN32
#pragma once
#endif
#include "playergroup.h"
const int k_NoGroupMemberLimit = -1;
namespace GCSDK
{
class CGCJobDestroyPlayerGroup;
class CGCJobFindGroupFromMemcached;
class CPlayerGroupManager
{
public:
CPlayerGroupManager();
static const int kGroupIDGenerationLockType = -1;
virtual void YieldingSessionStartPlaying( CGCUserSession *pSession );
virtual void YieldingSessionStopPlaying( CGCUserSession *pSession ) { }
virtual void YieldingSessionStartServer( CGCGSSession *pSession );
virtual void YieldingSessionStopServer( CGCGSSession *pSession );
IPlayerGroup* YldFindAndLockGroup( PlayerGroupID_t nPlayerGroupID );
IPlayerGroup* YldFindAndLockGroupByMemberID( const CSteamID &steamID );
IPlayerGroup* FindGroup( PlayerGroupID_t nPlayerGroupID );
IPlayerGroup* FindGroupByMemberID( const CSteamID &steamID );
virtual int GetGroupLockType() = 0;
bool IsPlayerWaitingForMemcache( const CSteamID &steamID ) const;
bool BYieldingLockGroupID( PlayerGroupID_t nPlayerGroupID );
void UnlockGroupID( PlayerGroupID_t nPlayerGroupID );
bool IsGroupIDLocked( PlayerGroupID_t nPlayerGroupID );
void StartFrameSchedule();
bool BExpireLocks( CLimitTimer &limitTimer );
void DumpGroups();
virtual void SendGroupStorageAndNetworkUpdate( IPlayerGroup *pPlayerGroup );
// invites
void YldInviteToGroup( const CSteamID &steamIDLeader, const CSteamID &steamIDNewMember );
void YldGroupInviteResponse( const CSteamID &steamID, const PlayerGroupID_t nPlayerGroupID, bool bAccepted );
void YldRequestKickFromGroup( const CSteamID &steamIDLeader, const CSteamID &steamIDNewMember );
bool BYldRequestLeaveGroup( const CSteamID &steamID );
void YldDestroyGroup( PlayerGroupID_t nPlayerGroupID );
virtual int GetMaxGroupMembers() { return k_NoGroupMemberLimit; }
protected:
bool BYldAddMemberToGroup( PlayerGroupID_t nPlayerGroupID, const CSteamID &steamIDNewMember );
void YldRemoveMemberFromGroup( PlayerGroupID_t nPlayerGroupID, const CSteamID &steamIDRemovingMember );
void YldDoFindGroupFromMemcached( const CSteamID &memberSteamID );
virtual IPlayerGroup* YldCreateAndLockPlayerGroup() = 0; // game specific derived class will implement this to create a game specific playergroup
virtual IPlayerGroup* YldCreateAndLockPlayerGroupFromMemcached( const CUtlBuffer &buf ) = 0; // game specific derived class will implement this to create a game specific playergroup
PlayerGroupID_t GeneratePlayerGroupID();
void YldDestroyGroupIfEmpty( PlayerGroupID_t nPlayerGroupID );
void MemcachedUpdateAllMemberAssocation( IPlayerGroup *pPlayerGroup );
void MemcachedRemoveAllMemberAssocation( IPlayerGroup *pPlayerGroup );
void MemcachedUpdateMemberAssocation( PlayerGroupID_t nPlayerGroupID, const CSteamID &steamID );
void MemcachedRemoveMemberAssocation( PlayerGroupID_t nPlayerGroupID, const CSteamID &steamID );
void YldFindGroupFromMemcached( const CSteamID &memberSteamID );
virtual const char *GetMemcachedIdentityKey() const = 0;
// notifications for derived classes
virtual void YldOnPlayerJoinedGroup( IPlayerGroup *pPlayerGroup, const CSteamID& steamIDNewMember ) { }
virtual void YldOnPlayerLeftGroup( IPlayerGroup *pPlayerGroup, const CSteamID& steamIDRemovingMember );
virtual void YldOnGroupDestroyed( IPlayerGroup *pPlayerGroup );
virtual void YldOnGroupLoadedFromMemcached( IPlayerGroup *pPlayerGroup );
// invites
virtual IPlayerGroupInvite* CreateInvite() = 0;
void YldAddPendingInvite( PlayerGroupID_t nPlayerGroupID, const CSteamID &steamIDNewMember );
virtual void YldRemovePendingInvite( PlayerGroupID_t nPlayerGroupID, const CSteamID &steamIDNewMember );
virtual bool YldHasGroupInvite( const CSteamID &steamID, const PlayerGroupID_t nPlayerGroupID ) = 0;
void YldCreateInvitesForGroup( PlayerGroupID_t nPlayerGroupID );
typedef CUtlMap<PlayerGroupID_t, IPlayerGroup*, int32> mapPlayerGroups_t;
typedef CUtlHashMapLarge<PlayerGroupID_t, IPlayerGroup*> hashPlayerGroups_t;
hashPlayerGroups_t m_mapGroups; // map from PlayerGroupID_t to IPlayerGroup
typedef CUtlHashMapLarge<CSteamID, IPlayerGroup*> mapMembersToPlayerGroups_t;
mapMembersToPlayerGroups_t m_mapMemberToGroup; // map from any member's SteamID to IPlayerGroup
CTHash<CLock, PlayerGroupID_t> m_hashPlayerGroupIDLocks;
friend class CGCJobDestroyGroup;
friend class CGCJobFindGroupFromMemcached;
CLock m_GroupIDGenerationLock;
private:
typedef CUtlHashMapLarge<CSteamID, int> mapPlayersMemcacheJobCount_t;
static mapPlayersMemcacheJobCount_t sm_mapPlayersMemcacheJobCount;
};
class CGCJobDestroyGroup : public CGCJob
{
public:
CGCJobDestroyGroup( CGCBase *pGC, CPlayerGroupManager *pGroupManager, PlayerGroupID_t nPlayerGroupID ) : CGCJob( pGC ), m_pGroupManager( pGroupManager ), m_nPlayerGroupID( nPlayerGroupID ) { }
virtual bool BYieldingRunGCJob();
private:
CPlayerGroupManager *m_pGroupManager;
PlayerGroupID_t m_nPlayerGroupID;
};
class CGCJobLeaveGroup : public CGCJob
{
public:
CGCJobLeaveGroup( CGCBase *pGC, CPlayerGroupManager *pGroupManager, const CSteamID &steamID ) : CGCJob( pGC ), m_pGroupManager( pGroupManager ), m_SteamID( steamID ) { }
virtual bool BYieldingRunGCJob();
private:
CPlayerGroupManager *m_pGroupManager;
CSteamID m_SteamID;
};
class CGCJobFindGroupFromMemcached : public CGCJob
{
public:
CGCJobFindGroupFromMemcached( CGCBase *pGC, CPlayerGroupManager *pGroupManager, const CSteamID& memberSteamID ) : CGCJob( pGC ), m_pGroupManager( pGroupManager ), m_memberSteamID( memberSteamID ) { }
virtual bool BYieldingRunGCJob();
private:
CPlayerGroupManager *m_pGroupManager;
CSteamID m_memberSteamID;
};
}
#endif