ReplicaManager.h

Go to the documentation of this file.

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

#ifndef __REPLICA_MANAGER_H
#define __REPLICA_MANAGER_H

#include "Export.h"
#include "RakNetTypes.h"
#include "DS_OrderedList.h"
#include "PluginInterface2.h"
#include "NetworkIDObject.h"
#include "DS_Queue.h"
#include "ReplicaEnums.h"

namespace RakNet
{
        class BitStream;
};
class Replica;
class ReplicaManager;



class ReceiveConstructionInterface
{
public:
        ReceiveConstructionInterface() {}
        virtual ~ReceiveConstructionInterface() {}

        virtual ReplicaReturnResult ReceiveConstruction(RakNet::BitStream *inBitStream, RakNetTime timestamp, NetworkID networkID, NetworkIDObject *existingObject, SystemAddress senderId, ReplicaManager *caller)=0;
};

class SendDownloadCompleteInterface
{
public:
        SendDownloadCompleteInterface() {}
        virtual ~SendDownloadCompleteInterface() {}

        virtual ReplicaReturnResult SendDownloadComplete(RakNet::BitStream *outBitStream, RakNetTime currentTime, SystemAddress senderId, ReplicaManager *caller)=0;
};

class ReceiveDownloadCompleteInterface
{
public:
        ReceiveDownloadCompleteInterface() {}
        virtual ~ReceiveDownloadCompleteInterface() {}

        virtual ReplicaReturnResult ReceiveDownloadComplete(RakNet::BitStream *inBitStream, SystemAddress senderId, ReplicaManager *caller)=0;
};


class RAK_DLL_EXPORT ReplicaManager : public PluginInterface2
{
public:
        // Constructor
        ReplicaManager();

        // Destructor
        virtual ~ReplicaManager();

        void AssertReplicatedObjectsClear(void);

        void AssertParticipantsClear(void);

        void SetAutoParticipateNewConnections(bool autoAdd);

        bool AddParticipant(SystemAddress systemAddress);

        bool RemoveParticipant(SystemAddress systemAddress);

        void Construct(Replica *replica, bool isCopy, SystemAddress systemAddress, bool broadcast);

        void Destruct(Replica *replica, SystemAddress systemAddress, bool broadcast);

        void ReferencePointer(Replica *replica);

        void DereferencePointer(Replica *replica);

        void SetScope(Replica *replica, bool inScope, SystemAddress systemAddress, bool broadcast);

        void SignalSerializeNeeded(Replica *replica, SystemAddress systemAddress, bool broadcast);

        void SetReceiveConstructionCB(ReceiveConstructionInterface *receiveConstructionInterface);

        void SetDownloadCompleteCB( SendDownloadCompleteInterface *sendDownloadComplete, ReceiveDownloadCompleteInterface *receiveDownloadComplete );

        void SetSendChannel(unsigned char channel);

        void SetAutoConstructToNewParticipants(bool autoConstruct);

        void SetDefaultScope(bool scope);

        void SetAutoSerializeInScope(bool autoSerialize);

        void Update(void);

        void EnableReplicaInterfaces(Replica *replica, unsigned char interfaceFlags);

        void DisableReplicaInterfaces(Replica *replica, unsigned char interfaceFlags);

        bool IsConstructed(Replica *replica, SystemAddress systemAddress);

        bool IsInScope(Replica *replica, SystemAddress systemAddress);

        unsigned GetReplicaCount(void) const;

    Replica *GetReplicaAtIndex(unsigned index);

        unsigned GetParticipantCount(void) const;

        SystemAddress GetParticipantAtIndex(unsigned index);

        bool HasParticipant(SystemAddress systemAddress);

        void SignalSerializationFlags(Replica *replica, SystemAddress systemAddress, bool broadcast, bool set, unsigned int flags);

        unsigned int* AccessSerializationFlags(Replica *replica, SystemAddress systemAddress);

        // ---------------------------- ALL INTERNAL AFTER HERE ----------------------------

        enum
        {
                // Treat the object as on the remote system, and send a packet
                REPLICA_EXPLICIT_CONSTRUCTION=1<<0,
                // Treat the object as on the remote system, but do not send a packet. Overridden by REPLICA_EXPLICIT_CONSTRUCTION.
                REPLICA_IMPLICIT_CONSTRUCTION=1<<1,
                REPLICA_SCOPE_TRUE=1<<2, // Mutually exclusive REPLICA_SCOPE_FALSE
                REPLICA_SCOPE_FALSE=1<<3, // Mutually exclusive REPLICA_SCOPE_TRUE
                REPLICA_SERIALIZE=1<<4,
        };

        struct CommandStruct
        {
                Replica *replica; // Pointer to an external object - not allocated here.
                unsigned char command; // This is one of the enums immediately above.
                unsigned int userFlags;
        };

        struct RegisteredReplica
        {
                Replica *replica; // Pointer to an external object - not allocated here.
                RakNetTime lastDeserializeTrue; //   For replicatedObjects it's the last time deserialize returned true.
                unsigned char allowedInterfaces; // Replica interface flags
                unsigned int referenceOrder; // The order in which we started tracking this object.  Used so autoconstruction can send objects in-order
        };

        struct RemoteObject
        {
                Replica *replica; // Pointer to an external object - not allocated here.
        bool inScope; // Is replica in scope or not?
                RakNetTime lastSendTime;
                unsigned int userFlags;
        };

        struct ReceivedCommand
        {
                SystemAddress systemAddress;
                NetworkID networkID;
                unsigned command; // A packetID
                unsigned u1;
                RakNet::BitStream *userData;
        };


        static int RegisteredReplicaComp( Replica* const &key, const ReplicaManager::RegisteredReplica &data );
        static int RegisteredReplicaRefOrderComp( const unsigned int &key, const ReplicaManager::RegisteredReplica &data );
        static int RemoteObjectComp( Replica* const &key, const ReplicaManager::RemoteObject &data );
        static int CommandStructComp( Replica* const &key, const ReplicaManager::CommandStruct &data );

        struct ParticipantStruct
        {
                ~ParticipantStruct();

                // The player this participant struct represents.
                SystemAddress systemAddress;

                // Call sendDownloadCompleteCB when REPLICA_SEND_CONSTRUCTION is done for all objects in commandList
                // This variable tracks if we did it yet or not.
                bool callDownloadCompleteCB;

                // Sorted list of Replica*, sorted by pointer, along with a command to perform on that pointer.
                // Ordering is just for fast lookup.
                // Nothing is allocated inside this list
                // DataStructures::OrderedList<Replica *, CommandStruct, ReplicaManager::CommandStructComp> commandList;
                // June 4, 2007 - Don't sort commands in the command list.  The game replies on processing the commands in order
                DataStructures::List<CommandStruct> commandList;

                // Sorted list of Replica*, sorted by pointer, along with if that object is inScope or not for this system
                // Only objects that exist on the remote system are in this list, so not all objects are necessarily in this list
                DataStructures::OrderedList<Replica *, RemoteObject, ReplicaManager::RemoteObjectComp> remoteObjectList;

                // List of pending ReceivedCommand to process
                DataStructures::Queue<ReceivedCommand*> pendingCommands;
        };

        static int ParticipantStructComp( const SystemAddress &key, ReplicaManager::ParticipantStruct * const &data );

protected:
        void Clear(void);
        // Processes a struct representing a received command
        ReplicaReturnResult ProcessReceivedCommand(ParticipantStruct *participantStruct, ReceivedCommand *receivedCommand);
        unsigned GetCommandListReplicaIndex(const DataStructures::List<ReplicaManager::CommandStruct> &commandList, Replica *replica, bool *objectExists) const;

        // Plugin interface functions
        PluginReceiveResult OnReceive(Packet *packet);
        void OnClosedConnection(SystemAddress systemAddress, RakNetGUID rakNetGUID, PI2_LostConnectionReason lostConnectionReason );
        void OnRakPeerShutdown(void);
        void OnNewConnection(SystemAddress systemAddress, RakNetGUID rakNetGUID, bool isIncoming);

        DataStructures::OrderedList<Replica *, RegisteredReplica, ReplicaManager::RegisteredReplicaComp> replicatedObjects;

        DataStructures::OrderedList<SystemAddress, ParticipantStruct *, ReplicaManager::ParticipantStructComp> participantList;

        // Internal functions
        ParticipantStruct* GetParticipantBySystemAddress(const SystemAddress systemAddress) const;

        // Callback pointers.
        
        // Required callback to handle construction calls
        ReceiveConstructionInterface *_constructionCB;

        // Optional callbacks to send and receive download complete.
        SendDownloadCompleteInterface *_sendDownloadCompleteCB;
        ReceiveDownloadCompleteInterface *_receiveDownloadCompleteCB;

        // Channel to do send calls on.  All calls are reliable ordered except for Replica::Serialize
        unsigned char sendChannel;

        // Stores what you pass to SetAutoParticipateNewConnections
        bool autoParticipateNewConnections;
        bool autoSerializeInScope;

        bool defaultScope;
        bool autoConstructToNewParticipants;
        unsigned int nextReferenceIndex;

#ifdef _DEBUG
        // Check for and assert on recursive calls to update
        bool inUpdate;
#endif
};


#endif

#endif // _RAKNET_SUPPORT_*