EnNetwork.c

Go to the documentation of this file.

/*
// Example: Custom codec functions.
// This allows using CustomClass instances as arguments of RPCs or as replicated properties marked with
// RplProp attribute.
class CustomClass
{
    static void Encode(SSnapSerializerBase snapshot, ScriptCtx ctx, ScriptBitSerializer packet);

    static bool Decode(ScriptBitSerializer packet, ScriptCtx ctx, SSnapSerializerBase snapshot);

    static bool SnapCompare(SSnapSerializerBase lhs, SSnapSerializerBase rhs, ScriptCtx ctx);


    //! Compares instance against snapshot. Returns true when they match or false otherwise.
    static bool PropCompare(CustomClass instance, SSnapSerializerBase snapshot, ScriptCtx ctx);

    static bool Extract(CustomClass instance, ScriptCtx ctx, SSnapSerializerBase snapshot);

    static bool Inject(SSnapSerializerBase snapshot, ScriptCtx ctx, CustomClass instance);
}
*/

 
typedef int RplIdentity;
typedef int RplId;
 
class ScriptCtx : Managed
{
}

//! Property groups that allow for replication of only part of the object.
//! \deprecated Will be removed in the future (as-if all uses were RplGroup.Mandatory).
[Obsolete()]
enum RplGroup
{
    Mandatory,
    Group_1,
    Group_2,
    Group_3,
    Group_4,
    Group_5,
    Group_6,
}


Property annotation attribute. Use to enable property replication on Entities and components.
*/
class RplProp: UniqueAttribute
{
    RplGroup     m_Group;
    RplCondition m_Condition;
    string       m_CustomCondName;
    string       m_OnRplName;
    ScriptCtx    m_pCtx;
 
    void RplProp(RplGroup     group = RplGroup.Mandatory,
                 string       onRplName = "",
                 ScriptCtx    ctx = NULL,
                 RplCondition condition = RplCondition.None,
                 string       customConditionName = "")
    {
        m_Group = group;
        m_OnRplName = onRplName;
        m_pCtx = ctx;
        m_Condition = condition;
        m_CustomCondName = customConditionName;
        if (m_Group != RplGroup.Mandatory)
        {
            Print("Specifying 'group' in RplProp is deprecated and will be removed, along with RplGroup enum.", level: LogLevel.WARNING);
            m_Group = RplGroup.Mandatory;
        }
    }
}
 

class RplRpc: UniqueAttribute
{
    RplChannel   m_Channel;
    RplRcver         m_Rcver;
    RplCondition m_Condition;
    string           m_CustomCondName;
 
    void RplRpc(RplChannel   channel,
                            RplRcver         rcver,
                            RplCondition condition = RplCondition.None,
                            string           customConditionName = "")
    {
        m_Channel = channel;
        m_Rcver = rcver;
        m_Condition = condition;
        m_CustomCondName = customConditionName;
    }
}
 

class OnRpl
{
}
 
class RplBeforeInjected: UniqueAttribute
{
}
 
class RplBeforeExtracted: UniqueAttribute
{
}
 
class ScriptBitWriter : Managed
{
    proto void Write(void src, int sizeInBits);
    proto void WriteRplId(RplId val);
    proto void WriteEntityId(EntityID val);
    proto void WriteInt(int val);
    proto void WriteIntRange(int val, int min, int max);
    proto void WriteHalf(float val);
    proto void WriteFloat01(float val);
    proto void WriteRadian(float val);
    proto void WriteQuaternion(float val[4]);
    proto void WriteResourceName(ResourceName val);
    proto void WriteString(string val);
    proto native int Tell();
 
    //----------------------------------------------------------------------------
    // Helper functions for built-in types.
    // They are safe defaults but they might use more bits than necessary.
 
    void WriteBool(bool val) { Write(val, 1); }
    void WriteFloat(float val) { Write(val, 32); }
    void WriteVector(vector val)
    {
        // 3 values * 32-bits each = 96
        Write(val, 96);
    }
}
 
class ScriptBitReader : Managed
{
    proto bool Read(out void dst, int sizeInBits);
    proto bool ReadRplId(out RplId val);
    proto bool ReadEntityId(out EntityID val);
    proto bool ReadInt(out int val);
    proto bool ReadIntRange(out int val, int min, int max);
    proto bool ReadHalf(out float val);
    proto bool ReadFloat01(out float val);
    proto bool ReadRadian(out float val);
    proto bool ReadQuaternion(out float val[4]);
    proto bool ReadResourceName(out ResourceName val);
    proto bool ReadString(out string val);
    proto native int Tell();
 
    //----------------------------------------------------------------------------
    // Helper functions for built-in types.
    // They are safe defaults but they might use more bits than necessary.
 
    bool ReadBool(out bool val) { return Read(val, 1); }
    bool ReadFloat(out float val) { return Read(val, 32); }
    bool ReadVector(out vector val)
    {
        // 3 values * 32-bits each = 96
        return Read(val, 96);
    }
}
 
class ScriptBitSerializer : Managed
{
    proto bool Serialize(inout void data, int sizeInBits);
    proto bool SerializeRplId(inout RplId val);
    proto bool SerializeEntityId(inout EntityID val);
    proto bool SerializeInt(inout int val);
    proto bool SerializeIntRange(inout int val, int min, int max);
    proto bool SerializeHalf(inout float val);
    proto bool SerializeFloat01(inout float val);
    proto bool SerializeRadian(inout float val);
    proto bool SerializeQuaternion(inout float val[4]);
    proto bool SerializeResourceName(inout ResourceName val);
    proto bool SerializeString(inout string val);
    proto native int Tell();
 
    //----------------------------------------------------------------------------
    // Helper functions for built-in types.
    // They are safe defaults but they might use more bits than necessary.
 
    bool SerializeBool(inout bool val) { return Serialize(val, 1); }
    bool SerializeFloat(inout float val) { return Serialize(val, 32); }
    bool SerializeVector(inout vector val)
    {
        // 3 values * 32-bits each = 96
        return Serialize(val, 96);
    }
}
 
class SSnapSerializerBase: Managed
{
    proto void SerializeBytes(inout void data, int sizeInBytes);
 
    void SerializeBool(inout bool val) { SerializeBytes(val, 4); }
    void SerializeInt(inout int val) { SerializeBytes(val, 4); }
    void SerializeFloat(inout float val) { SerializeBytes(val, 4); }
    void SerializeVector(inout vector val) { SerializeBytes(val, 12); }
    proto void SerializeString(inout string val);
 
    bool EncodeBool(ScriptBitSerializer packet)
    {
        bool val;
        this.SerializeBytes(val, 4);
        packet.Serialize(val, 1);
        return val;
    }
    bool DecodeBool(ScriptBitSerializer packet)
    {
        bool val;
        packet.Serialize(val, 1);
        this.SerializeBytes(val, 4);
        return val;
    }
 
    int EncodeInt(ScriptBitSerializer packet)
    {
        int val;
        this.SerializeBytes(val, 4);
        packet.Serialize(val, 32);
        return val;
    }
    int DecodeInt(ScriptBitSerializer packet)
    {
        int val;
        packet.Serialize(val, 32);
        this.SerializeBytes(val, 4);
        return val;
    }
 
    float EncodeFloat(ScriptBitSerializer packet)
    {
        float val;
        this.SerializeBytes(val, 4);
        packet.Serialize(val, 32);
        return val;
    }
    float DecodeFloat(ScriptBitSerializer packet)
    {
        float val;
        packet.Serialize(val, 32);
        this.SerializeBytes(val, 4);
        return val;
    }
 
    vector EncodeVector(ScriptBitSerializer packet)
    {
        vector val;
        this.SerializeBytes(val, 12);
        packet.Serialize(val, 96);
        return val;
    }
    vector DecodeVector(ScriptBitSerializer packet)
    {
        vector val;
        packet.Serialize(val, 96);
        this.SerializeBytes(val, 12);
        return val;
    }
 
    proto void EncodeString(ScriptBitSerializer packet);
    proto void DecodeString(ScriptBitSerializer packet);

    proto native bool Serialize(ScriptBitSerializer serializer, int sizeInBytes);

    proto native int Tell();

    proto bool Compare(void data, int sizeInBytes);
    bool CompareBool(bool val) { return Compare(val, 4); }
    bool CompareInt(int val) { return Compare(val, 4); }
    bool CompareFloat(float val) { return Compare(val, 4); }
    bool CompareVector(vector val) { return Compare(val, 12); }
    proto bool CompareString(string val);

    proto native bool CompareSnapshots(SSnapSerializerBase snapshot, int sizeInBytes);
    proto bool CompareStringSnapshots(SSnapSerializerBase snapshot);
 
    private void SSnapSerializerBase();
    private void ~SSnapSerializerBase();
}

class SSnapshot : Managed
{
    void SSnapshot(int sizeInBytes);
}

class SSnapSerializer : SSnapSerializerBase
{
    proto static ref SSnapSerializer MakeWriter(SSnapshot snap);
    proto static ref SSnapSerializer MakeReader(SSnapshot snap);
    proto native int Seek(int posInBytes);
}