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 */
#include "RNPlatform/Inc/MemoryTracking.h"
#ifndef __REPLICANET_H__
#define __REPLICANET_H__

#define _REPLICANET_VERSION 7300

#include <string>

#include "RNXPURL/Inc/Transport.h"
#include "RNPlatform/Inc/SysTime.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 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,
        kPacket_Ordered = 3
    };

    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);

    int GetNetworkPacketsRejected(void);

    virtual SysTimeType GetTime(void);

    virtual SysTimeType 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 SysTimeType 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);

    void SetSessionIDCallback(const bool enable = false);

    virtual int CallbackGetSessionID(void);

    virtual int CallbackGetObjectUniqueID(ReplicaObject *object);

    void SetMaximumDataSize(const int bytes = 64*1024);
    int GetMaximumDataSize(void) const;

    void SetPacketCompressionLevel(const int level = 10);
    void SetLargePacketCompressionLevel(const int level = 5);

    int GetPacketCompressionLevel(void);
    int GetLargePacketCompressionLevel(void);

    void SetTransparentPacketCompression(const int level = 0);

    int GetTransparentPacketCompression(void);

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 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 void *_gReplicaNet_PreRegisterReplicasFunc;
// This function is created when parsing an ROL file containing ReplicaObject definitions. Or it can contain user generated code.
extern void _ReplicaNetPreRegisterReplicasFunc(RNReplicaNet::ReplicaNet *repNet);

#endif