ReplicaManager3.h

Go to the documentation of this file.

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

#ifndef __REPLICA_MANAGER_3
#define __REPLICA_MANAGER_3

#include "DS_Multilist.h"
#include "RakNetTypes.h"
#include "RakNetTime.h"
#include "BitStream.h"
#include "PacketPriority.h"
#include "PluginInterface2.h"
#include "NetworkIDObject.h"


namespace RakNet
{
class Connection_RM3;
class Replica3;


struct PRO
{
    PacketPriority priority;

    PacketReliability reliability;

    char orderingChannel;

    uint32_t sendReceipt;

    bool operator==( const PRO& right ) const;
    bool operator!=( const PRO& right ) const;
};


class RAK_DLL_EXPORT ReplicaManager3 : public PluginInterface2
{
public:
    ReplicaManager3();
    virtual ~ReplicaManager3();

    virtual Connection_RM3* AllocConnection(const SystemAddress &systemAddress, RakNetGUID rakNetGUID) const=0;

    virtual void DeallocConnection(Connection_RM3 *connection) const=0;

    void SetAutoManageConnections(bool autoCreate, bool autoDestroy);

    bool PushConnection(RakNet::Connection_RM3 *newConnection);

    RakNet::Connection_RM3 * PopConnection(RakNetGUID guid);

    void Reference(RakNet::Replica3 *replica3);

    void Dereference(RakNet::Replica3 *replica3);

    void DereferenceList(DataStructures::Multilist<ML_STACK, Replica3*> &replicaListIn);

    void GetReplicasCreatedByGuid(RakNetGUID guid, DataStructures::Multilist<ML_STACK, Replica3*> &replicaListOut);

    void GetReplicasCreatedByMe(DataStructures::Multilist<ML_STACK, Replica3*> &replicaListOut);

    void GetReferencedReplicaList(DataStructures::Multilist<ML_STACK, Replica3*> &replicaListOut);

    unsigned GetReplicaCount(void) const;

    Replica3 *GetReplicaAtIndex(unsigned index);

    DataStructures::DefaultIndexType GetConnectionCount(void) const;

    Connection_RM3* GetConnectionAtIndex(unsigned index) const;

    Connection_RM3* GetConnectionBySystemAddress(const SystemAddress &sa) const;

    Connection_RM3* GetConnectionByGUID(RakNetGUID guid) const;

    void SetDefaultOrderingChannel(char def);

    void SetDefaultPacketPriority(PacketPriority def);

    void SetDefaultPacketReliability(PacketReliability def);

    void SetAutoSerializeInterval(RakNet::Time intervalMS);

    void GetConnectionsThatHaveReplicaConstructed(Replica3 *replica, DataStructures::Multilist<ML_STACK, Connection_RM3*> &connectionsThatHaveConstructedThisReplica);

    void SetWorldID(unsigned char id);

    unsigned char GetWorldID(void) const;

    void SetNetworkIDManager(NetworkIDManager *_networkIDManager);

    NetworkIDManager *GetNetworkIDManager(void) const;

    void BroadcastDestructionList(DataStructures::Multilist<ML_STACK, Replica3*> &replicaList, const SystemAddress &exclusionAddress);

    void BroadcastDestruction(Replica3 *replica, const SystemAddress &exclusionAddress);

    void Clear(void);

    PRO GetDefaultSendParameters(void) const;

    virtual void Update(void);
protected:
    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);
    virtual void OnRakPeerShutdown(void);
    virtual void OnDetach(void);

    PluginReceiveResult OnConstruction(Packet *packet, unsigned char *packetData, int packetDataLength, RakNetGUID senderGuid, unsigned char packetDataOffset);
    PluginReceiveResult OnSerialize(Packet *packet, unsigned char *packetData, int packetDataLength, RakNetGUID senderGuid, RakNet::Time timestamp, unsigned char packetDataOffset);
    PluginReceiveResult OnDownloadStarted(Packet *packet, unsigned char *packetData, int packetDataLength, RakNetGUID senderGuid, unsigned char packetDataOffset);
    PluginReceiveResult OnDownloadComplete(Packet *packet, unsigned char *packetData, int packetDataLength, RakNetGUID senderGuid, unsigned char packetDataOffset);

    RakNet::Connection_RM3 * PopConnection(DataStructures::DefaultIndexType index);
    Replica3* GetReplicaByNetworkID(NetworkID networkId);
    DataStructures::DefaultIndexType ReferenceInternal(RakNet::Replica3 *replica3);

    DataStructures::Multilist<ML_STACK, Connection_RM3*> connectionList;
    DataStructures::Multilist<ML_STACK, Replica3*> userReplicaList;

    PRO defaultSendParameters;
    RakNet::Time autoSerializeInterval;
    RakNet::Time lastAutoSerializeOccurance;
    unsigned char worldId;
    NetworkIDManager *networkIDManager;
    bool autoCreateConnections, autoDestroyConnections;

    friend class Connection_RM3;
};

static const int RM3_NUM_OUTPUT_BITSTREAM_CHANNELS=8;

struct LastSerializationResultBS
{
    RakNet::BitStream bitStream[RM3_NUM_OUTPUT_BITSTREAM_CHANNELS];
    bool indicesToSend[RM3_NUM_OUTPUT_BITSTREAM_CHANNELS];
};

struct LastSerializationResult
{
    LastSerializationResult();
    ~LastSerializationResult();
    
    RakNet::Replica3 *replica;
    //bool neverSerialize;
//  bool isConstructed;

    void AllocBS(void);
    LastSerializationResultBS* lastSerializationResultBS;
};

struct SerializeParameters
{
    RakNet::BitStream outputBitstream[RM3_NUM_OUTPUT_BITSTREAM_CHANNELS];

    RakNet::BitStream* lastSentBitstream[RM3_NUM_OUTPUT_BITSTREAM_CHANNELS];

    RakNet::Time messageTimestamp;

    PRO pro[RM3_NUM_OUTPUT_BITSTREAM_CHANNELS];

    RakNet::Connection_RM3 *destinationConnection;

    BitSize_t bitsWrittenSoFar;

    RakNet::Time whenLastSerialized;

    RakNet::Time curTime;
};

struct DeserializeParameters
{
    RakNet::BitStream serializationBitstream[RM3_NUM_OUTPUT_BITSTREAM_CHANNELS];
    bool bitstreamWrittenTo[RM3_NUM_OUTPUT_BITSTREAM_CHANNELS];
    RakNet::Time timeStamp;
    RakNet::Connection_RM3 *sourceConnection;
};

enum SendSerializeIfChangedResult
{
    SSICR_SENT_DATA,
    SSICR_DID_NOT_SEND_DATA,
    SSICR_NEVER_SERIALIZE,
};

class RAK_DLL_EXPORT Connection_RM3
{
public:

    Connection_RM3(const SystemAddress &_systemAddress, RakNetGUID _guid);
    virtual ~Connection_RM3();

    virtual Replica3 *AllocReplica(RakNet::BitStream *allocationIdBitstream, ReplicaManager3 *replicaManager3)=0;

    virtual void GetConstructedReplicas(DataStructures::Multilist<ML_STACK, Replica3*> &objectsTheyDoHave);

    bool HasReplicaConstructed(RakNet::Replica3 *replica);

    virtual void SerializeOnDownloadStarted(RakNet::BitStream *bitStream) {(void) bitStream;}

    virtual void DeserializeOnDownloadStarted(RakNet::BitStream *bitStream) {(void) bitStream;}

    virtual void SerializeOnDownloadComplete(RakNet::BitStream *bitStream) {(void) bitStream;}

    virtual void DeserializeOnDownloadComplete(RakNet::BitStream *bitStream) {(void) bitStream;}

    SystemAddress GetSystemAddress(void) const {return systemAddress;}

    RakNetGUID GetRakNetGUID(void) const {return guid;}

    enum ConstructionMode
    {
        QUERY_REPLICA_FOR_CONSTRUCTION,

        QUERY_REPLICA_FOR_CONSTRUCTION_AND_DESTRUCTION,

        QUERY_CONNECTION_FOR_REPLICA_LIST
    };

    virtual bool QueryGroupDownloadMessages(void) const {return false;}

    virtual ConstructionMode QueryConstructionMode(void) const {return QUERY_REPLICA_FOR_CONSTRUCTION_AND_DESTRUCTION;}

    virtual void QueryReplicaList(
        DataStructures::Multilist<ML_STACK, Replica3*, Replica3*> newReplicasToCreate,
        DataStructures::Multilist<ML_STACK, Replica3*, Replica3*> existingReplicasToDestroy) {}

    virtual SendSerializeIfChangedResult SendSerialize(RakNet::Replica3 *replica, bool indicesToSend[RM3_NUM_OUTPUT_BITSTREAM_CHANNELS], RakNet::BitStream serializationData[RM3_NUM_OUTPUT_BITSTREAM_CHANNELS], RakNet::Time timestamp, PRO sendParameters[RM3_NUM_OUTPUT_BITSTREAM_CHANNELS], RakNet::RakPeerInterface *rakPeer, unsigned char worldId);

    virtual SendSerializeIfChangedResult SendSerializeIfChanged(DataStructures::DefaultIndexType queryToSerializeIndex, SerializeParameters *sp, RakNet::RakPeerInterface *rakPeer, unsigned char worldId, ReplicaManager3 *replicaManager);

    virtual void SendConstruction(DataStructures::Multilist<ML_STACK, Replica3*, Replica3*> &newObjects, DataStructures::Multilist<ML_STACK, Replica3*, Replica3*> &deletedObjects, PRO sendParameters, RakNet::RakPeerInterface *rakPeer, unsigned char worldId, ReplicaManager3 *replicaManager3);

    void CullUniqueNewAndDeletedObjects(DataStructures::Multilist<ML_STACK, Replica3*> &newObjectsIn,
        DataStructures::Multilist<ML_STACK, Replica3*> &deletedObjectsIn,
        DataStructures::Multilist<ML_STACK, Replica3*> &newObjectsOut,
        DataStructures::Multilist<ML_STACK, Replica3*> &deletedObjectsOut);

    void SendValidation(RakNet::RakPeerInterface *rakPeer, unsigned char worldId);

    void AutoConstructByQuery(ReplicaManager3 *replicaManager3);


    // Internal - does the other system have this connection too? Validated means we can now use it
    bool isValidated;
    // Internal - Used to see if we should send download started
    bool isFirstConstruction;

protected:

    SystemAddress systemAddress;
    RakNetGUID guid;

    /*
        Operations:

        Locally reference a new replica:
        Add to queryToConstructReplicaList for all objects

        Add all objects to queryToConstructReplicaList

        Download:
        Add to constructedReplicaList for connection that send the object to us
        Add to queryToSerializeReplicaList for connection that send the object to us
        Add to queryToConstructReplicaList for all other connections

        Never construct for this connection:
        Remove from queryToConstructReplicaList

        Construct to this connection
        Remove from queryToConstructReplicaList
        Add to constructedReplicaList for this connection
        Add to queryToSerializeReplicaList for this connection

        Serialize:
        Iterate through queryToSerializeReplicaList

        Never serialize for this connection
        Remove from queryToSerializeReplicaList

        Reference (this system has this object already)
        Remove from queryToConstructReplicaList
        Add to constructedReplicaList for this connection
        Add to queryToSerializeReplicaList for this connection

        Downloaded an existing object
        if replica is in queryToConstructReplicaList, OnConstructToThisConnection()
        else ignore

        Send destruction from query
        Remove from queryToDestructReplicaList
        Remove from queryToSerializeReplicaList
        Remove from constructedReplicaList
        Add to queryToConstructReplicaList

        Do not query destruction again
        Remove from queryToDestructReplicaList
    */
    void OnLocalReference(Replica3* replica3, ReplicaManager3 *replicaManager);
    void OnDereference(Replica3* replica3, ReplicaManager3 *replicaManager);
    void OnDownloadFromThisSystem(Replica3* replica3, ReplicaManager3 *replicaManager);
    void OnDownloadFromOtherSystem(Replica3* replica3, ReplicaManager3 *replicaManager);
    void OnNeverConstruct(DataStructures::DefaultIndexType queryToConstructIdx, ReplicaManager3 *replicaManager);
    void OnConstructToThisConnection(DataStructures::DefaultIndexType queryToConstructIdx, ReplicaManager3 *replicaManager);
    void OnConstructToThisConnection(Replica3 *replica, ReplicaManager3 *replicaManager);
    void OnNeverSerialize(DataStructures::DefaultIndexType queryToSerializeIndex, ReplicaManager3 *replicaManager);
    void OnReplicaAlreadyExists(DataStructures::DefaultIndexType queryToConstructIdx, ReplicaManager3 *replicaManager);
    void OnDownloadExisting(Replica3* replica3, ReplicaManager3 *replicaManager);
    void OnSendDestructionFromQuery(DataStructures::DefaultIndexType queryToDestructIdx, ReplicaManager3 *replicaManager);
    void OnDoNotQueryDestruction(DataStructures::DefaultIndexType queryToDestructIdx, ReplicaManager3 *replicaManager);
    void ValidateLists(ReplicaManager3 *replicaManager) const;
    void SendSerializeHeader(RakNet::Replica3 *replica, RakNet::Time timestamp, RakNet::BitStream *bs, unsigned char worldId);
    
    // The list of objects that our local system and this remote system both have
    // Either we sent this object to them, or they sent this object to us
    // A given Replica can be either in queryToConstructReplicaList or constructedReplicaList but not both at the same time
    DataStructures::Multilist<ML_ORDERED_LIST, LastSerializationResult*, Replica3*> constructedReplicaList;

    // Objects that we have, but this system does not, and we will query each tick to see if it should be sent to them
    // If we do send it to them, the replica is moved to constructedReplicaList
    // A given Replica can be either in queryToConstructReplicaList or constructedReplicaList but not both at the same time
    DataStructures::Multilist<ML_STACK, LastSerializationResult*, Replica3*> queryToConstructReplicaList;

    // Objects that this system has constructed are added at the same time to queryToSerializeReplicaList
    // This list is used to serialize all objects that this system has to this connection
    DataStructures::Multilist<ML_STACK, LastSerializationResult*, Replica3*> queryToSerializeReplicaList;

    // Objects that are constructed on this system are also queried if they should be destroyed to this system
    DataStructures::Multilist<ML_STACK, LastSerializationResult*, Replica3*> queryToDestructReplicaList;

    // Working lists
    DataStructures::Multilist<ML_STACK, Replica3*, Replica3*> constructedReplicasCulled, destroyedReplicasCulled;

    // This is used if QueryGroupDownloadMessages() returns true when ID_REPLICA_MANAGER_DOWNLOAD_STARTED arrives
    // Packets will be gathered and not returned until ID_REPLICA_MANAGER_DOWNLOAD_COMPLETE arrives
    bool groupConstructionAndSerialize;
    DataStructures::Multilist<ML_QUEUE, Packet*, Packet*> downloadGroup;
    void ClearDownloadGroup(RakPeerInterface *rakPeerInterface);

    friend class ReplicaManager3;
private:
    Connection_RM3() {};

    ConstructionMode constructionMode;
};

enum RM3ConstructionState
{
    RM3CS_SEND_CONSTRUCTION,

    RM3CS_ALREADY_EXISTS_REMOTELY,

    RM3CS_ALREADY_EXISTS_REMOTELY_DO_NOT_CONSTRUCT,

    RM3CS_NEVER_CONSTRUCT,
    
    RM3CS_NO_ACTION,
};

enum RM3DestructionState
{
    RM3DS_SEND_DESTRUCTION,

    RM3DS_DO_NOT_QUERY_DESTRUCTION,

    RM3DS_NO_ACTION,
};

enum RM3SerializationResult
{
    RM3SR_BROADCAST_IDENTICALLY,

    RM3SR_BROADCAST_IDENTICALLY_FORCE_SERIALIZATION,

    RM3SR_SERIALIZED_UNIQUELY,

    RM3SR_SERIALIZED_ALWAYS,

    RM3SR_SERIALIZED_ALWAYS_IDENTICALLY,

    RM3SR_DO_NOT_SERIALIZE,

    RM3SR_NEVER_SERIALIZE_FOR_THIS_CONNECTION,
};

enum RM3QuerySerializationResult
{
    RM3QSR_CALL_SERIALIZE,
    RM3QSR_DO_NOT_CALL_SERIALIZE,
    RM3QSR_NEVER_CALL_SERIALIZE,
};

enum RM3ActionOnPopConnection
{
    RM3AOPC_DO_NOTHING,
    RM3AOPC_DELETE_REPLICA,
    RM3AOPC_DELETE_REPLICA_AND_BROADCAST_DESTRUCTION,
};

class RAK_DLL_EXPORT Replica3 : public NetworkIDObject
{
public:
    Replica3();

    virtual ~Replica3();

    virtual void WriteAllocationID(RakNet::Connection_RM3 *destinationConnection, RakNet::BitStream *allocationIdBitstream) const=0;

    virtual RM3ConstructionState QueryConstruction(RakNet::Connection_RM3 *destinationConnection, ReplicaManager3 *replicaManager3)=0;

    virtual RM3DestructionState QueryDestruction(RakNet::Connection_RM3 *destinationConnection, ReplicaManager3 *replicaManager3) {(void) destinationConnection; (void) replicaManager3; return RM3DS_DO_NOT_QUERY_DESTRUCTION;}

    virtual bool QueryRemoteConstruction(RakNet::Connection_RM3 *sourceConnection)=0;

    virtual void SerializeConstruction(RakNet::BitStream *constructionBitstream, RakNet::Connection_RM3 *destinationConnection)=0;

    virtual bool DeserializeConstruction(RakNet::BitStream *constructionBitstream, RakNet::Connection_RM3 *sourceConnection)=0;

    virtual void SerializeConstructionExisting(RakNet::BitStream *constructionBitstream, RakNet::Connection_RM3 *destinationConnection) {(void) constructionBitstream; (void) destinationConnection;};

    virtual void DeserializeConstructionExisting(RakNet::BitStream *constructionBitstream, RakNet::Connection_RM3 *sourceConnection) {(void) constructionBitstream; (void) sourceConnection;};

    virtual void SerializeDestruction(RakNet::BitStream *destructionBitstream, RakNet::Connection_RM3 *destinationConnection)=0;

    virtual bool DeserializeDestruction(RakNet::BitStream *destructionBitstream, RakNet::Connection_RM3 *sourceConnection)=0;

    virtual RakNet::RM3ActionOnPopConnection QueryActionOnPopConnection(RakNet::Connection_RM3 *droppedConnection) const=0;

    virtual void OnPoppedConnection(RakNet::Connection_RM3 *droppedConnection) {(void) droppedConnection;}

    virtual void DeallocReplica(RakNet::Connection_RM3 *sourceConnection)=0;

    virtual RakNet::RM3QuerySerializationResult QuerySerialization(RakNet::Connection_RM3 *destinationConnection)=0;

    virtual void OnUserReplicaPreSerializeTick(void) {}

    virtual RM3SerializationResult Serialize(RakNet::SerializeParameters *serializeParameters)=0;

    virtual void OnSerializeTransmission(RakNet::BitStream *bitStream, const SystemAddress &systemAddress) {(void) bitStream; (void) systemAddress; }

    virtual void Deserialize(RakNet::DeserializeParameters *deserializeParameters)=0;

    virtual void PostSerializeConstruction(RakNet::BitStream *constructionBitstream, RakNet::Connection_RM3 *destinationConnection) {(void) constructionBitstream; (void) destinationConnection;}

    virtual void PostDeserializeConstruction(RakNet::BitStream *constructionBitstream, RakNet::Connection_RM3 *sourceConnection) {(void) constructionBitstream; (void) sourceConnection;}

    virtual void PostSerializeConstructionExisting(RakNet::BitStream *constructionBitstream, RakNet::Connection_RM3 *destinationConnection) {(void) constructionBitstream; (void) destinationConnection;}

    virtual void PostDeserializeConstructionExisting(RakNet::BitStream *constructionBitstream, RakNet::Connection_RM3 *sourceConnection) {(void) constructionBitstream; (void) sourceConnection;}

    virtual void PreDestruction(RakNet::Connection_RM3 *sourceConnection) {(void) sourceConnection;}

    virtual RM3ConstructionState QueryConstruction_ClientConstruction(RakNet::Connection_RM3 *destinationConnection, bool isThisTheServer);
    virtual bool QueryRemoteConstruction_ClientConstruction(RakNet::Connection_RM3 *sourceConnection, bool isThisTheServer);

    virtual RM3ConstructionState QueryConstruction_ServerConstruction(RakNet::Connection_RM3 *destinationConnection, bool isThisTheServer);
    virtual bool QueryRemoteConstruction_ServerConstruction(RakNet::Connection_RM3 *sourceConnection, bool isThisTheServer);

    virtual RM3ConstructionState QueryConstruction_PeerToPeer(RakNet::Connection_RM3 *destinationConnection);
    virtual bool QueryRemoteConstruction_PeerToPeer(RakNet::Connection_RM3 *sourceConnection);

    virtual RakNet::RM3QuerySerializationResult QuerySerialization_ClientSerializable(RakNet::Connection_RM3 *destinationConnection, bool isThisTheServer);
    virtual RakNet::RM3QuerySerializationResult QuerySerialization_ServerSerializable(RakNet::Connection_RM3 *destinationConnection, bool isThisTheServer);
    virtual RakNet::RM3QuerySerializationResult QuerySerialization_PeerToPeer(RakNet::Connection_RM3 *destinationConnection);

    virtual RM3ActionOnPopConnection QueryActionOnPopConnection_Client(RakNet::Connection_RM3 *droppedConnection) const;
    virtual RM3ActionOnPopConnection QueryActionOnPopConnection_Server(RakNet::Connection_RM3 *droppedConnection) const;
    virtual RM3ActionOnPopConnection QueryActionOnPopConnection_PeerToPeer(RakNet::Connection_RM3 *droppedConnection) const;

    virtual void BroadcastDestruction(void);

    RakNetGUID GetCreatingSystemGUID(void) const;

    bool WasReferenced(void) const {return replicaManager!=0;}

    RakNetGUID creatingSystemGUID;
    RakNetGUID deletingSystemGUID;

    ReplicaManager3 *replicaManager;

    LastSerializationResultBS lastSentSerialization;
    RakNet::Time whenLastSerialized;
    bool forceSendUntilNextUpdate;
};

template <class parent_type>
class RAK_DLL_EXPORT Replica3Composite : public Replica3
{
protected:
    parent_type *r3CompositeOwner;
public:
    void SetCompositeOwner(parent_type *p) {r3CompositeOwner=p;}
    parent_type* GetCompositeOwner(void) const {return r3CompositeOwner;};
    virtual void WriteAllocationID(RakNet::Connection_RM3 *destinationConnection, RakNet::BitStream *allocationIdBitstream) const {r3CompositeOwner->WriteAllocationID(destinationConnection, allocationIdBitstream);}
    virtual RM3ConstructionState QueryConstruction(RakNet::Connection_RM3 *destinationConnection, ReplicaManager3 *replicaManager3) {return r3CompositeOwner->QueryConstruction(destinationConnection, replicaManager3);}
    virtual RM3DestructionState QueryDestruction(RakNet::Connection_RM3 *destinationConnection, ReplicaManager3 *replicaManager3) {return r3CompositeOwner->QueryDestruction(destinationConnection, replicaManager3);}
    virtual bool QueryRemoteConstruction(RakNet::Connection_RM3 *sourceConnection) {return r3CompositeOwner->QueryRemoteConstruction(sourceConnection);}
    virtual void SerializeConstruction(RakNet::BitStream *constructionBitstream, RakNet::Connection_RM3 *destinationConnection) {r3CompositeOwner->SerializeConstruction(constructionBitstream, destinationConnection);}
    virtual bool DeserializeConstruction(RakNet::BitStream *constructionBitstream, RakNet::Connection_RM3 *sourceConnection) {return r3CompositeOwner->DeserializeConstruction(constructionBitstream, sourceConnection);}
    virtual void SerializeConstructionExisting(RakNet::BitStream *constructionBitstream, RakNet::Connection_RM3 *destinationConnection) {r3CompositeOwner->SerializeConstructionExisting(constructionBitstream, destinationConnection);}
    virtual void DeserializeConstructionExisting(RakNet::BitStream *constructionBitstream, RakNet::Connection_RM3 *sourceConnection) {r3CompositeOwner->DeserializeConstructionExisting(constructionBitstream, sourceConnection);}
    virtual void SerializeDestruction(RakNet::BitStream *destructionBitstream, RakNet::Connection_RM3 *destinationConnection) {r3CompositeOwner->SerializeDestruction(destructionBitstream, destinationConnection);}
    virtual bool DeserializeDestruction(RakNet::BitStream *destructionBitstream, RakNet::Connection_RM3 *sourceConnection) {return r3CompositeOwner->DeserializeDestruction(destructionBitstream, sourceConnection);}
    virtual RakNet::RM3ActionOnPopConnection QueryActionOnPopConnection(RakNet::Connection_RM3 *droppedConnection) const {return r3CompositeOwner->QueryActionOnPopConnection(droppedConnection);}
    virtual void OnPoppedConnection(RakNet::Connection_RM3 *droppedConnection) {r3CompositeOwner->OnPoppedConnection(droppedConnection);}
    virtual void DeallocReplica(RakNet::Connection_RM3 *sourceConnection) {r3CompositeOwner->DeallocReplica(sourceConnection);}
    virtual RakNet::RM3QuerySerializationResult QuerySerialization(RakNet::Connection_RM3 *destinationConnection) {return r3CompositeOwner->QuerySerialization(destinationConnection);}
    virtual void OnUserReplicaPreSerializeTick(void) {r3CompositeOwner->OnUserReplicaPreSerializeTick();}
    virtual RM3SerializationResult Serialize(RakNet::SerializeParameters *serializeParameters) {return r3CompositeOwner->Serialize(serializeParameters);}
    virtual void OnSerializeTransmission(RakNet::BitStream *bitStream, const SystemAddress &systemAddress) {r3CompositeOwner->OnSerializeTransmission(bitStream, systemAddress);}
    virtual void Deserialize(RakNet::DeserializeParameters *deserializeParameters) {r3CompositeOwner->Deserialize(deserializeParameters);}
    virtual void PostSerializeConstruction(RakNet::BitStream *constructionBitstream, RakNet::Connection_RM3 *destinationConnection) {r3CompositeOwner->PostSerializeConstruction(constructionBitstream, destinationConnection);}
    virtual void PostDeserializeConstruction(RakNet::BitStream *constructionBitstream, RakNet::Connection_RM3 *sourceConnection) {r3CompositeOwner->PostDeserializeConstruction(constructionBitstream, sourceConnection);}
    virtual void PostSerializeConstructionExisting(RakNet::BitStream *constructionBitstream, RakNet::Connection_RM3 *destinationConnection) {r3CompositeOwner->PostSerializeConstructionExisting(constructionBitstream, destinationConnection);}
    virtual void PostDeserializeConstructionExisting(RakNet::BitStream *constructionBitstream, RakNet::Connection_RM3 *sourceConnection) {r3CompositeOwner->PostDeserializeConstructionExisting(constructionBitstream, sourceConnection);}
    virtual void PreDestruction(RakNet::Connection_RM3 *sourceConnection) {r3CompositeOwner->PreDestruction(sourceConnection);}
};

} // namespace RakNet


#endif

#endif // _RAKNET_SUPPORT_*