ReplicaNet.h

/* START_LICENSE_HEADER

Copyright (C) 2000 Martin Piper, original design and program code
Copyright (C) 2001 Replica Software

This program file is copyright (C) Replica Software and can only be used under license.
For more information visit: http://www.replicanet.com/
Or email: info@replicanet.com

END_LICENSE_HEADER */
// This pragma disables a warning in the Microsoft compiler. This can be safely ignored. See bug ref: C4786
#if defined(_WIN32)
#pragma warning(disable : 4786)
#endif
#ifndef __REPLICANET_H__
#define __REPLICANET_H__
#include "RNPlatform/Inc/DLLExportAPI.h"

#define _REPLICANET_VERSION 6000
// All DLL versions with the same major version are compatible
#define _REPLICANET_DLLVERSIONMAJOR 17
#define _REPLICANET_DLLVERSIONMINOR 0

#include <string>

#include "RNXPURL/Inc/Transport.h"


namespace RNReplicaNet
{

class ReplicaObject;
class ReplicaNetPrivate;
struct s_RO_RegistryBlock;
struct DataBlockReason;

class XPSession;
class MessageHelper;
class DynamicMessageHelper;

const int kReplicaNetUnknownUniqueID = -1;
const int kReplicaNetBroadcastID = -2;
const int kReplicaNetRecordID = -3;

class REPLICANETDLL_API ReplicaNet
{
public:
    enum Error
    {
        kReplicaNet_EOK = 0,                        
        kReplicaNet_EERROR = -1,                    
        kReplicaNet_ETRANSPORT_CLOSED = -2,
        kReplicaNet_ETRANSPORT_ERROR = -3,
        kReplicaNet_EEND_RECORDING = -4
    };

    enum PacketType
    {
        kPacket_Unreliable = 0,
        kPacket_Reliable = 1,
        kPacket_Certain = 2
    };

    ReplicaNet();

    virtual ~ReplicaNet();

    virtual void PreRegisterReplicas(void);

    static ReplicaNet *GetCurrentReplicaNet(void);

    static void SetCurrentReplicaNet(ReplicaNet *const replicanet);

    int GetSessionID(void);

    int GetGameChannel(void);

    void SetGameChannel(const int channel = TransportAnyGameChannel);

    void SessionCreate(const std::string name);

    void SessionCreate(const std::string name,const std::string protocols);

    std::string SessionExportURL(void);

    void SessionJoin(const std::string url);

    void SessionFind(void);

    void SessionFind(const std::string protocols);

    std::string SessionEnumerateFound(void);

    void LockObjects(void);

    void UnLockObjects(void);

    float GetNetworkSendRate(void);

    float GetNetworkReceiveRate(void);

    int GetNetworkPacketsLost(void);

    virtual float GetTime(void);

    virtual float GetLocalTime(void);

    void SetObserver(ReplicaObject *const object = 0);

    ReplicaObject *GetObserver(void);

    void Poll(void);

    void SetPollLayerBelow(bool enable = true);

    bool GetPollLayerBelow(void);

    void SetPollLayerBelowForXPSession(bool enable = true);

    bool GetPollLayerBelowForXPSession(void);

    void SetManualPoll(void);

    void SetAutomaticPoll(void);

    void SetManualPollXPSession(void);

    void SetAutomaticPollXPSession(void);

    void SetManualPollXPURL(void);

    void SetAutomaticPollXPURL(void);

    void GiveOwnership(ReplicaObject *const object,const int sessionID);

    void RequestOwnership(ReplicaObject *const object);

    void SetCanSpider(const bool canSpider = true);

    bool GetCanSpider(void);

    float GetLatencyToMasterSession(void);

    float GetLatencyToSessionID(const int sessionID);

    void SetLatencyRecalculationDelay(const float seconds = 1.0f);

    bool IsStable(void);

    bool IsMaster(void);

    void SetCanBecomeMaster(const bool canBeMaster = true);

    bool GetCanBecomeMaster(void);

    Error GetStatus(void);

    Error GetSessionErrorReason(void);

    enum OnError
    {
        kMigrateObjects = 0,
        kDeleteObjects,
        kLeaveObjects,
        kMigrateObjectsToNewMaster
    };

    void SetOnSessionError(const OnError whatToDo = kMigrateObjects);

    OnError GetOnSessionErrorMigrateObjects(void);

    void SetCanAcceptObjects(bool accept = true);

    bool GetCanAcceptObjects(void);

    void SetEncryption(const bool enable = false);

    bool GetEncryption(void);

    void SetLoadBalancing(const bool enable = false);

    bool GetLoadBalancing(void);

    void SetMaximumLoad(float load = 0.0f);

    float GetMaximumLoad(int sessionID = kReplicaNetUnknownUniqueID);

    float GetTotalLoad(int sessionID = kReplicaNetUnknownUniqueID);

    void ObjectListBeginIterate(void);

    void ObjectListFinishIterate(void);

    ReplicaObject *ObjectListIterate(void);

    ReplicaObject *ObjectListFind(const int sessionID,const int uniqueID);

    virtual void JoinerSessionIDPre(const int sessionID);

    virtual void JoinerSessionIDPost(const int sessionID);

    virtual void LeaverSessionIDPre(const int sessionID);

    virtual void LeaverSessionIDPost(const int sessionID);



    void Disconnect(const int sessionID = kReplicaNetUnknownUniqueID);

    bool GetPreConnectStatus(void);

    void SetPreConnect(const bool enable = false);

    bool GetPreConnect(void);

    void PreConnectHasFinished(void);

    void SetDataRetention(const bool enable = false);

    bool GetDataRetention(void) const;

    void DataSend(const int sessionid,const void *data,const int length,const PacketType type = kPacket_Reliable,const unsigned int band = 0);

    bool DataReceive(int *const fromsessionid,void *const data,int *const length,PacketType *const type = 0);

    bool DataReceivePeek(int *const fromsessionid,int *const length,PacketType *const type = 0);
    

    void SetDataBlockUpdatePolicy(const bool automatic = true);

    bool GetDataBlockUpdatePolicy(void) const;

    void ProcessDataBlockUpdate(void);

    void SetAutomaticPacketCompression(const bool enable = false);

    bool GetAutomaticPacketCompression(void);

    void GetCompressionStatistics(int *const before=0,int *const after=0,const bool reset = false);

    void GetMergedStatistics(int *const sent=0,int *const received=0,const bool reset = false);

    int GetMasterSessionID(void);

    std::string GetURLFromSessionID(const int sessionID);

    void SetClientOnly(const bool isClient = false);

    bool GetClientOnly(void);

    bool GetBandwidthFromSessionID(const int sessionID,Transport::Bandwidth *const bandwidth,int *const output,int *const input);

    virtual ReplicaObject *CallBackAllocate(const int classID,const int sessionID,const int uniqueID);

    virtual ReplicaObject *CallBackDelete(ReplicaObject *object);

    bool BeginSessionRecord(void);

    void StopSessionRecord(void);

    virtual bool CallbackSessionRecord(const void *data,const int length);

    bool GetSessionRecord(void) const;

    bool BeginSessionPlayback(void);

    void StopSessionPlayback(void);

    void SetPlaybackSpeed(const float speed = 1.0f);

    bool PlaybackAdvanceTo(const float time);

    virtual void CallbackPlaybackAdvanceToFinished(void);

    virtual bool CallbackSessionPlayback(void *data,const int length);

    bool GetSessionPlayback(void) const;

    void SetPlaybackAllowMasterReplicaObjects(const bool allow = false);

    bool GetPlaybackAllowMasterReplicaObjects(void);

    void SetAllowConnections(const bool allow = true);

    bool GetAllowConnections(void);

    void SetNodeBuffers(const bool enable = false);

    bool GetNodeBuffers(void);

    virtual void CallbackMasterSessionIDChanged(const int previousSessionID);

private:
friend class ReplicaObject;     /* A ReplicaObject has direct access to ReplicaNet the class */
friend class ReplicaNetPrivate;
friend class ReplicaNetDLLRegister;
    void AddObject(ReplicaObject *const object);

    void RemoveObject(ReplicaObject *const object,const bool sendDelete = true);
    
    bool GetMakeMaster(void);

    int GetObjectUniqueID(void);

    int GetMakeUniqueID(void);

    int GetMakeSessionID(void);

    void LoadChangedForObject(ReplicaObject *object,float previousLoad,float newLoad);

    static ReplicaNet*  mCurrentReplicaNet; 
    ReplicaNetPrivate*  mPrivateReplicaNet;

    void                AddItem(s_RO_RegistryBlock *block);

    ReplicaObject* AllocateReplicaObject(const int class_id,const int sessionid,const int uniqueid,const int reflect = kReplicaNetUnknownUniqueID);

    void ReplicaObjectDataSend(const int sessionid,const void *data,const int length,const ReplicaNet::PacketType type = ReplicaNet::kPacket_Reliable,ReplicaObject *source = 0,const unsigned int band = 0);
};

class ReplicaNetDLLRegister
{
public:
    ReplicaNetDLLRegister(){};
    virtual ~ReplicaNetDLLRegister(){};

    void Call(ReplicaNet *repNet);
};

} // namespace RNReplicaNet

extern REPLICANETDLL_API void *_gReplicaNet_PreRegisterReplicasFunc;
extern void _ReplicaNetPreRegisterReplicasFunc(RNReplicaNet::ReplicaNet *repNet);

// Calling this is guaranteed to not cause any memory allocation.
#define REPLICANET_DLLPREREGISTER() \
    _gReplicaNet_PreRegisterReplicasFunc = (void*) &_ReplicaNetPreRegisterReplicasFunc;

#endif

---