TeamManager.h

Go to the documentation of this file.

/*
 *  Original work: Copyright (c) 2014, Oculus VR, Inc.
 *  All rights reserved.
 *
 *  This source code is licensed under the BSD-style license found in the
 *  RakNet License.txt file in the licenses directory of this source tree. An additional grant 
 *  of patent rights can be found in the RakNet Patents.txt file in the same directory.
 *
 *
 *  Modified work: Copyright (c) 2016-2017, SLikeSoft UG (haftungsbeschränkt)
 *
 *  This source code was modified by SLikeSoft. Modifications are licensed under the MIT-style
 *  license found in the license.txt file in the root directory of this source tree.
 */

// TODO: optimize the list of teams and team members to be O(1). Store in hashes, use linked lists to get ordered traversal



#include "NativeFeatureIncludes.h"
#if _RAKNET_SUPPORT_TeamManager==1

#ifndef __TEAM_MANAGER_H
#define __TEAM_MANAGER_H

#include "PluginInterface2.h"
#include "memoryoverride.h"
#include "NativeTypes.h"
#include "DS_List.h"
#include "types.h"
#include "DS_Hash.h"
#include "DS_OrderedList.h"

namespace SLNet
{
class RakPeerInterface;


typedef unsigned char NoTeamId;

typedef uint8_t WorldId;

typedef uint16_t TeamMemberLimit;

#define ALLOW_JOIN_ANY_AVAILABLE_TEAM (1<<0)

#define ALLOW_JOIN_SPECIFIC_TEAM (1<<1)

#define ALLOW_JOIN_REBALANCING (1<<2)

// Bitwise combination of ALLOW_JOIN_ANY_AVAILABLE_TEAM, ALLOW_JOIN_SPECIFIC_TEAM, ALLOW_JOIN_REBALANCING
typedef uint8_t JoinPermissions;

// Forward declarations
class TM_Team;
class TM_TeamMember;
class TM_World;
class TeamManager;

enum JoinTeamType
{
    JOIN_ANY_AVAILABLE_TEAM,
    JOIN_SPECIFIC_TEAM,
    JOIN_NO_TEAM
};

enum TMTopology
{
    // Each system will send all messages to all participants
    TM_PEER_TO_PEER,

    // The host will relay incoming messages to all participants
    TM_CLIENT_SERVER,
};

struct TeamSelection
{
    TeamSelection();
    TeamSelection(JoinTeamType itt);
    TeamSelection(JoinTeamType itt, TM_Team *param);
    TeamSelection(JoinTeamType itt, NoTeamId param);
    JoinTeamType joinTeamType;
    
    union
    {
        TM_Team *specificTeamToJoin;
        NoTeamId noTeamSubcategory;
    } teamParameter;
    
    static TeamSelection AnyAvailable(void);
    static TeamSelection SpecificTeam(TM_Team *specificTeamToJoin);
    static TeamSelection NoTeam(NoTeamId noTeamSubcategory);
};

class RAK_DLL_EXPORT TM_TeamMember
{
public:
    // GetInstance() and DestroyInstance(instance*)
    STATIC_FACTORY_DECLARATIONS(TM_TeamMember)

    TM_TeamMember();
    virtual ~TM_TeamMember();
    
    bool RequestTeam(TeamSelection teamSelection);
    
    bool RequestTeamSwitch(TM_Team *teamToJoin, TM_Team *teamToLeave);
    
    TeamSelection GetRequestedTeam(void) const;
    
    void GetRequestedSpecificTeams(DataStructures::List<TM_Team*> &requestedTeams) const;

    bool HasRequestedTeam(TM_Team *team) const;

    unsigned int GetRequestedTeamIndex(TM_Team *team) const;

    unsigned int GetRequestedTeamCount(void) const;
    
    bool CancelTeamRequest(TM_Team *specificTeamToCancel);
    
    bool LeaveTeam(TM_Team* team, NoTeamId _noTeamSubcategory);

    bool LeaveAllTeams(NoTeamId inNoTeamSubcategory);
    
    TM_Team* GetCurrentTeam(void) const;

    unsigned int GetCurrentTeamCount(void) const;

    TM_Team* GetCurrentTeamByIndex(unsigned int index);
    
    void GetCurrentTeams(DataStructures::List<TM_Team*> &_teams) const;

    void GetLastTeams(DataStructures::List<TM_Team*> &_teams) const;

    bool IsOnTeam(TM_Team *team) const;
    
    NetworkID GetNetworkID(void) const;
    
    TM_World* GetTM_World(void) const;
    
    void SerializeConstruction(BitStream *constructionBitstream);
    
    bool DeserializeConstruction(TeamManager *teamManager, BitStream *constructionBitstream);

    void SetOwner(void *o);

    void *GetOwner(void) const;

    NoTeamId GetNoTeamId(void) const;

    unsigned int GetWorldIndex(void) const;

    static unsigned long ToUint32( const NetworkID &g );

    struct RequestedTeam
    {
        SLNet::Time whenRequested;
        unsigned int requestIndex;
        TM_Team *requested;
        bool isTeamSwitch;
        TM_Team *teamToLeave;
    };
    
protected:
    NetworkID networkId;
    TM_World* world;
    // Teams we are a member of. We can be on more than one team, but not on the same team more than once
    DataStructures::List<TM_Team*> teams;
    // If teams is empty, which subcategory of noTeam we are on
    NoTeamId noTeamSubcategory;
    // Teams we have requested to join. Mutually exclusive with teams we are already on. Cannot request the same team more than once.
    DataStructures::List<RequestedTeam> teamsRequested;
    // If teamsRequested is not empty, we want to join a specific team
    // If teamsRequested is empty, then joinTeamType is either JOIN_NO_TEAM or JOIN_ANY_AVAILABLE_TEAM
    JoinTeamType joinTeamType;
    // Set by StoreLastTeams()
    DataStructures::List<TM_Team*> lastTeams;
    SLNet::Time whenJoinAnyRequested;
    unsigned int joinAnyRequestIndex;
    void *owner;

    // Remove from all requested and current teams.
    void UpdateListsToNoTeam(NoTeamId nti);
    bool JoinAnyTeamCheck(void) const;
    bool JoinSpecificTeamCheck(TM_Team *specificTeamToJoin, bool ignoreRequested) const;
    bool SwitchSpecificTeamCheck(TM_Team *teamToJoin, TM_Team *teamToLeave, bool ignoreRequested) const;
    bool LeaveTeamCheck(TM_Team *team) const;
    void UpdateTeamsRequestedToAny(void);
    void UpdateTeamsRequestedToNone(void);
    void AddToRequestedTeams(TM_Team *teamToJoin);
    void AddToRequestedTeams(TM_Team *teamToJoin, TM_Team *teamToLeave);
    bool RemoveFromRequestedTeams(TM_Team *team);
    void AddToTeamList(TM_Team *team);
    void RemoveFromSpecificTeamInternal(TM_Team *team);
    void RemoveFromAllTeamsInternal(void);
    void StoreLastTeams(void);

    friend class TM_World;
    friend class TM_Team;
    friend class TeamManager;
};

class RAK_DLL_EXPORT TM_Team
{
public:
    // GetInstance() and DestroyInstance(instance*)
    STATIC_FACTORY_DECLARATIONS(TM_Team)

    TM_Team();
    virtual ~TM_Team();
    
    bool SetMemberLimit(TeamMemberLimit _teamMemberLimit, NoTeamId noTeamSubcategory);
    
    TeamMemberLimit GetMemberLimit(void) const;

    TeamMemberLimit GetMemberLimitSetting(void) const;
    
    bool SetJoinPermissions(JoinPermissions _joinPermissions);
    
    JoinPermissions GetJoinPermissions(void) const;
    
    void LeaveTeam(TM_TeamMember* teamMember, NoTeamId noTeamSubcategory);
    
    bool GetBalancingApplies(void) const;
    
    void GetTeamMembers(DataStructures::List<TM_TeamMember*> &_teamMembers) const;

    unsigned int GetTeamMembersCount(void) const;

    TM_TeamMember *GetTeamMemberByIndex(unsigned int index) const;
    
    NetworkID GetNetworkID(void) const;
    
    TM_World* GetTM_World(void) const;
    
    void SerializeConstruction(BitStream *constructionBitstream);
    
    bool DeserializeConstruction(TeamManager *teamManager, BitStream *constructionBitstream);

    void SetOwner(void *o);

    void *GetOwner(void) const;

    unsigned int GetWorldIndex(void) const;

    static unsigned long ToUint32( const NetworkID &g );
    
protected:
    NetworkID ID;
    TM_World* world;
    // Which members are on this team. The same member cannot be on the same team more than once
    DataStructures::List<TM_TeamMember*> teamMembers;
    // Permissions on who can join this team
    JoinPermissions joinPermissions;
    // Whether or not to consider this team when balancing teams
    bool balancingApplies;
    TeamMemberLimit teamMemberLimit;
    void *owner;

    // Remove input from list teamMembers
    void RemoveFromTeamMemberList(TM_TeamMember *teamMember);

    // Find the member index that wants to join the indicated team, is only on one team, and wants to leave that team
    unsigned int GetMemberWithRequestedSingleTeamSwitch(TM_Team *team);
    

    friend class TM_World;
    friend class TM_TeamMember;
    friend class TeamManager;
};

class TM_World
{
public:
    TM_World();
    virtual ~TM_World();

    TeamManager *GetTeamManager(void) const;

    void AddParticipant(RakNetGUID rakNetGUID);

    void RemoveParticipant(RakNetGUID rakNetGUID);

    void SetAutoManageConnections(bool autoAdd);

    void GetParticipantList(DataStructures::List<RakNetGUID> &participantList);

    void ReferenceTeam(TM_Team *team, NetworkID networkId, bool applyBalancing);

    void DereferenceTeam(TM_Team *team, NoTeamId noTeamSubcategory);

    unsigned int GetTeamCount(void) const;

    TM_Team *GetTeamByIndex(unsigned int index) const;

    TM_Team *GetTeamByNetworkID(NetworkID teamId);

    unsigned int GetTeamIndex(const TM_Team *team) const;

    void ReferenceTeamMember(TM_TeamMember *teamMember, NetworkID networkId);

    void DereferenceTeamMember(TM_TeamMember *teamMember);

    unsigned int GetTeamMemberCount(void) const;

    TM_TeamMember *GetTeamMemberByIndex(unsigned int index) const;

    NetworkID GetTeamMemberIDByIndex(unsigned int index) const;

    TM_TeamMember *GetTeamMemberByNetworkID(NetworkID teamMemberId);

    unsigned int GetTeamMemberIndex(const TM_TeamMember *teamMember) const;

    bool SetBalanceTeams(bool balanceTeams, NoTeamId noTeamSubcategory);

    bool GetBalanceTeams(void) const;

    void SetHost(RakNetGUID _hostGuid);

    RakNetGUID GetHost(void) const;

    WorldId GetWorldId(void) const;

    void Clear(void);

    struct JoinRequestHelper
    {
        SLNet::Time whenRequestMade;
        unsigned int teamMemberIndex;
        unsigned int indexIntoTeamsRequested;
        unsigned int requestIndex;
    };
    static int JoinRequestHelperComp(const TM_World::JoinRequestHelper &key, const TM_World::JoinRequestHelper &data);

protected:
    virtual void OnClosedConnection(const SystemAddress &systemAddress, RakNetGUID rakNetGUID, PI2_LostConnectionReason lostConnectionReason );
    virtual void OnNewConnection(const SystemAddress &systemAddress, RakNetGUID rakNetGUID, bool isIncoming);

    // Teams with too many members have those members go to other teams.
    void EnforceTeamBalance(NoTeamId noTeamSubcategory);
    void KickExcessMembers(NoTeamId noTeamSubcategory);
    void FillRequestedSlots(void);
    unsigned int GetAvailableTeamIndexWithFewestMembers(TeamMemberLimit secondaryLimit, JoinPermissions joinPermissions);

    void GetSortedJoinRequests(DataStructures::OrderedList<JoinRequestHelper, JoinRequestHelper, JoinRequestHelperComp> &joinRequests);


    // Send a message to all participants
    void BroadcastToParticipants(SLNet::BitStream *bsOut, RakNetGUID exclusionGuid);
    void BroadcastToParticipants(unsigned char *data, const int length, RakNetGUID exclusionGuid);

    // 1. If can join a team:
    // A. teamMember->UpdateTeamsRequestedToNone();
    // B. teamMember->AddToTeamList()
    // C. Return new team
    // 2. Else return 0
    TM_Team* JoinAnyTeam(TM_TeamMember *teamMember, int *resultCode);

    int JoinSpecificTeam(TM_TeamMember *teamMember, TM_Team *team, bool isTeamSwitch, TM_Team *teamToLeave, DataStructures::List<TM_Team*> &teamsWeAreLeaving);

    TeamMemberLimit GetBalancedTeamLimit(void) const;

    // For fast lookup. Shares pointers with list teams
    DataStructures::Hash<NetworkID, TM_Team*, 256, TM_Team::ToUint32> teamsHash;
    // For fast lookup. Shares pointers with list teamMembers
    DataStructures::Hash<NetworkID, TM_TeamMember*, 256, TM_TeamMember::ToUint32> teamMembersHash;

    TeamManager *teamManager;
    DataStructures::List<RakNetGUID> participants;
    DataStructures::List<TM_Team*> teams;
    DataStructures::List<TM_TeamMember*> teamMembers;
    bool balanceTeamsIsActive;
    RakNetGUID hostGuid;
    WorldId worldId;
    bool autoAddParticipants;
    int teamRequestIndex;

    friend class TeamManager;
    friend class TM_TeamMember;
    friend class TM_Team;
};

class RAK_DLL_EXPORT TeamManager : public PluginInterface2
{
public:
    // GetInstance() and DestroyInstance(instance*)
    STATIC_FACTORY_DECLARATIONS(TeamManager)

    TeamManager();
    virtual ~TeamManager();

    TM_World* AddWorld(WorldId worldId);

    void RemoveWorld(WorldId worldId);

    unsigned int GetWorldCount(void) const;

    TM_World* GetWorldAtIndex(unsigned int index) const;

    TM_World* GetWorldWithId(WorldId worldId) const;
    
    void SetAutoManageConnections(bool autoAdd);

    void SetTopology(TMTopology _topology);
    
    void DecomposeTeamFull(Packet *packet,
        TM_World **world, TM_TeamMember **teamMember, TM_Team **team,
        uint16_t &currentMembers, uint16_t &memberLimitIncludingBalancing, bool &balancingIsActive, JoinPermissions &joinPermissions);

    void DecomposeTeamLocked(Packet *packet,
        TM_World **world, TM_TeamMember **teamMember, TM_Team **team,
        uint16_t &currentMembers, uint16_t &memberLimitIncludingBalancing, bool &balancingIsActive, JoinPermissions &joinPermissions);

    void Clear(void);
    
    void DecodeTeamAssigned(Packet *packet, TM_World **world, TM_TeamMember **teamMember);

    // \brief Reads out the world and teamMember from ID_TEAM_BALANCER_TEAM_REQUESTED_CANCELLED
    void DecodeTeamCancelled(Packet *packet, TM_World **world, TM_TeamMember **teamMember, TM_Team **teamCancelled);

protected:

    virtual void Update(void);
    virtual PluginReceiveResult OnReceive(Packet *packet);
    virtual void OnClosedConnection(const SystemAddress &systemAddress, RakNetGUID rakNetGUID, PI2_LostConnectionReason lostConnectionReason );
    virtual void OnNewConnection(const SystemAddress &systemAddress, RakNetGUID rakNetGUID, bool isIncoming);
    void Send( const SLNet::BitStream * bitStream, const AddressOrGUID systemIdentifier, bool broadcast );

    void EncodeTeamFullOrLocked(SLNet::BitStream *bitStream, TM_TeamMember *teamMember, TM_Team *team);
    void DecomposeTeamFullOrLocked(SLNet::BitStream *bsIn, TM_World **world, TM_TeamMember **teamMember, TM_Team **team,
        uint16_t &currentMembers, uint16_t &memberLimitIncludingBalancing, bool &balancingIsActive, JoinPermissions &joinPermissions);
    void ProcessTeamAssigned(SLNet::BitStream *bsIn);

    void EncodeTeamAssigned(SLNet::BitStream *bitStream, TM_TeamMember *teamMember);
    void RemoveFromTeamsRequestedAndAddTeam(TM_TeamMember *teamMember, TM_Team *team, bool isTeamSwitch, TM_Team *teamToLeave);

    void PushTeamAssigned(TM_TeamMember *teamMember);
    void PushBitStream(SLNet::BitStream *bitStream);
    void OnUpdateListsToNoTeam(Packet *packet, TM_World *world);
    void OnUpdateTeamsRequestedToAny(Packet *packet, TM_World *world);
    void OnJoinAnyTeam(Packet *packet, TM_World *world);
    void OnJoinRequestedTeam(Packet *packet, TM_World *world);
    void OnUpdateTeamsRequestedToNoneAndAddTeam(Packet *packet, TM_World *world);
    void OnRemoveFromTeamsRequestedAndAddTeam(Packet *packet, TM_World *world);
    void OnAddToRequestedTeams(Packet *packet, TM_World *world);
    bool OnRemoveFromRequestedTeams(Packet *packet, TM_World *world);
    void OnLeaveTeam(Packet *packet, TM_World *world);
    void OnSetMemberLimit(Packet *packet, TM_World *world);
    void OnSetJoinPermissions(Packet *packet, TM_World *world);
    void OnSetBalanceTeams(Packet *packet, TM_World *world);
    void OnSetBalanceTeamsInitial(Packet *packet, TM_World *world);


    void EncodeTeamFull(SLNet::BitStream *bitStream, TM_TeamMember *teamMember, TM_Team *team);
    void EncodeTeamLocked(SLNet::BitStream *bitStream, TM_TeamMember *teamMember, TM_Team *team);

    void DecodeTeamAssigned(SLNet::BitStream *bsIn, TM_World **world, TM_TeamMember **teamMember, NoTeamId &noTeamSubcategory,
        JoinTeamType &joinTeamType, DataStructures::List<TM_Team *> &newTeam,
        DataStructures::List<TM_Team *> &teamsLeft, DataStructures::List<TM_Team *> &teamsJoined);

    // O(1) lookup for a given world. If I need more worlds, change this to a hash or ordered list
    TM_World *worldsArray[255];
    // All allocated worlds for linear traversal
    DataStructures::List<TM_World*> worldsList;
    bool autoAddParticipants;
    TMTopology topology;

    friend class TM_TeamMember; 
    friend class TM_World;
    friend class TM_Team;
};

} // namespace SLNet

#endif // __TEAM_MANAGER_H

#endif // _RAKNET_SUPPORT_*