RplDocs.c

Go to the documentation of this file.

 
#ifdef DOXYGEN

class EntityWithRplProp : GenericEntity
{
    [RplProp()]
    bool bFlag;
 
    [RplProp(onRplName: "OnIValueChanged")]
    int iValue;
 
    [RplProp(condition: RplCondition.NoOwner)]
    float fValue;
 
    [RplProp(customConditionName: "MyCondition")]
    float fCustomCondition;
 
    void OnIValueChanged()
    {
        // ...
    }
 
    // The custom condition can be helpful in places where you know that
    // certain values are no longer needed on the other side. This can't be
    // utilized to filter out connections!
    bool MyCondition()
    {
        return bFlag;
    }
}
 
class EntityWithRplPropClass: GenericEntityClass {}
EntityWithRplPropClass g_EntityWithRplPropClassInst;

class EntityWithRplRpc : GenericEntity
{
    // This is a RPC. It has to be annotated with the RplRpc attribute.
    [RplRpc(RplChannel.Reliable, RplRcver.Owner)]
    void OwnerRpc(int a)
    {
        // ...
    }
 
    override void EOnFrame(IEntity owner, float timeSlice)
    {
        // The RPC has to be call via special method on the entity/component.
        Rpc(OwnerRpc, 7);
        // This call can have multiple outcomes depending on the role and
        // ownership of this instance.
        // 1. If this instance is the owner the RPC will be called directly
        //    (the same way a method would be).
        // 2. This instance is the server and some client owns the instance.
        //    Then the RPC would be called on the owning client.
        // 3. This is the client that does not own the instance. Then this
        //    RPC would be dropped.
        //
        // You can avoid a lot of branches if you design your code around these rules.
 
 
        // You can still use the RPC method the same way as you would use any other method.
        // In many cases this would be the best way how to unify your logic.
        OwnerRpc(7);
    }
}
 
class EntityWithRplRpcClass: GenericEntityClass {}
EntityWithRplRpcClass g_EntityWithRplRpcClassInst;

class ComplexType
{
    bool m_Bool;
    int m_Int;
    string m_String;
    float m_Float;
    WorldTimestamp m_Timestamp;
    vector m_Vector;
 
    // ## Extract/Inject
    // Extracting data from instance into snapshot, and injecting data from snapshot to instance.
    // Snapshot is meant to be fast to work with, so values are left uncompressed
    // to avoid extra work when accessing these values.
 
    // ## Encode/Decode
    // Encoding snapshot into a packet and decoding snapshot from a packet.
    // Packets need to be as small as possible, so this process tries to reduce the
    // size as much as it can. Knowing what range of values can certain variable have and
    // encoding that range in minimum number of bits required is key. If you have
    // to assume full range of values is needed, you can use helpers for different
    // types that already implement those.
 
    // ## EncodeDelta/DecodeDelta
    // Optional functions for implementing encoding of snapshot differences
    // (delta encoding). Encoding reads from old and new snapshots and writes differences
    // between them into delta-encoded packet. Decoding then reads from old snapshot
    // and delta-encoded packet and writes new packet based on them.
 
    static bool Extract(ComplexType instance, ScriptCtx ctx, SSnapSerializerBase snapshot)
    {
        // Fill a snapshot with values from an instance.
        snapshot.SerializeBool(instance.m_Bool);
        snapshot.SerializeInt(instance.m_Int);
        snapshot.SerializeString(instance.m_String);
        snapshot.SerializeFloat(instance.m_Float);
        snapshot.SerializeBytes(instance.m_Timestamp, 8);
        snapshot.SerializeVector(instance.m_Vector);
        return true;
    }
 
    static bool Inject(SSnapSerializerBase snapshot, ScriptCtx ctx, ComplexType instance)
    {
        // Fill an instance with values from snapshot.
        snapshot.SerializeBool(instance.m_Bool);
        snapshot.SerializeInt(instance.m_Int);
        snapshot.SerializeString(instance.m_String);
        snapshot.SerializeFloat(instance.m_Float);
        snapshot.SerializeBytes(instance.m_Timestamp, 8);
        snapshot.SerializeVector(instance.m_Vector);
        return true;
    }
 
    static void Encode(SSnapSerializerBase snapshot, ScriptCtx ctx, ScriptBitSerializer packet)
    {
        // Read values from snapshot, encode them into smaller representation, then
        // write them into packet.
        snapshot.EncodeBool(packet);   // m_Bool
        snapshot.EncodeInt(packet);    // m_Int
        snapshot.EncodeString(packet); // m_String
        snapshot.EncodeFloat(packet);  // m_Float
        snapshot.Serialize(packet, 8); // m_Timestamp
        snapshot.EncodeVector(packet); // m_Vector
    }
 
    static bool Decode(ScriptBitSerializer packet, ScriptCtx ctx, SSnapSerializerBase snapshot)
    {
        // Read values from packet, decode them into their original representation,
        // then write them into snapshot.
        snapshot.DecodeBool(packet);   // m_Bool
        snapshot.DecodeInt(packet);    // m_Int
        snapshot.DecodeString(packet); // m_String
        snapshot.DecodeFloat(packet);  // m_Float
        snapshot.Serialize(packet, 8); // m_Timestamp
        snapshot.DecodeVector(packet); // m_Vector
        return true;
    }
 
    static bool SnapCompare(SSnapSerializerBase lhs, SSnapSerializerBase rhs , ScriptCtx ctx)
    {
        // Compare two snapshots and determine whether they are the same.
        // We have to compare properties one-by-one, but for properties with known
        // length (such as primitive types bool, int, float and vector), we do multiple
        // comparisons in single call. However, because we do not know length of string,
        // we use provided function which will determine number of bytes that need
        // to be compared from serialized data.
        return lhs.CompareSnapshots(rhs, 4+4)   // m_Bool, m_Int
            && lhs.CompareStringSnapshots(rhs)  // m_String
            && lhs.CompareSnapshots(rhs, 4+8+12); // m_Float, m_Timestamp, m_Vector
    }
 
    static bool PropCompare(ComplexType instance, SSnapSerializerBase snapshot, ScriptCtx ctx)
    {
        // Determine whether current values in instance are sufficiently different from
        // an existing snapshot that it's worth creating new one.
        // For float or vector values, you could use some threshold to avoid creating too
        // many snapshots due to tiny changes in these values.
        return snapshot.CompareBool(instance.m_Bool)
            && snapshot.CompareInt(instance.m_Int)
            && snapshot.CompareString(instance.m_String)
            && snapshot.CompareFloat(instance.m_Float)
            && snapshot.Compare(instance.m_Timestamp, 8)
            && snapshot.CompareVector(instance.m_Vector);
    }
 
    static void EncodeDelta(SSnapSerializerBase oldSnapshot, SSnapSerializerBase newSnapshot, ScriptCtx ctx, ScriptBitSerializer packet)
    {
        // Generate packet that allows other side to produce new snapshot when it already
        // has old one available.
 
        // We write new value of bool directly, as there is no way to reduce it below one bit.
        // We still need to read old value from old snapshot to correctly access following
        // properties.
        bool oldBool;
        oldSnapshot.SerializeBool(oldBool);
        bool newBool;
        newSnapshot.SerializeBool(newBool);
        packet.Serialize(newBool, 1);
 
        // We encode difference between old and new value of the int, and rely on the fact
        // that difference of these values requires fewer bits to encode than value itself.
        int oldInt;
        oldSnapshot.SerializeInt(oldInt);
        int newInt;
        newSnapshot.SerializeInt(newInt);
        int deltaInt = newInt - oldInt;
        packet.SerializeInt(deltaInt);
 
        // For remaining values (string, float, vector), we use single bit to signal whether
        // value has changed and we only encode their new value if it is different from
        // the old one.
        string oldString;
        oldSnapshot.SerializeString(oldString);
        string newString;
        newSnapshot.SerializeString(newString);
        bool stringChanged = newString != oldString;
        packet.Serialize(stringChanged, 1);
        if (stringChanged)
            packet.SerializeString(newString);
 
        float oldFloat;
        oldSnapshot.SerializeFloat(oldFloat);
        float newFloat;
        newSnapshot.SerializeFloat(newFloat);
        bool floatChanged = newFloat != oldFloat;
        packet.Serialize(floatChanged, 1);
        if (floatChanged)
            packet.Serialize(newFloat, 32);
 
        // For timestamps, rounding of float will occur when absolute value of
        // difference is more than 16777216ms (~4.5 hours). Also, past certain
        // point, differences cannot be represented as 32-bit int either. Therefore,
        // once difference cannot be sent accurately, we instead send full value.
        // This might not be the best solution for extreme uses, but it demonstrates
        // how one can implement delta-encoding using domain-specific knowledge.
        WorldTimestamp oldTimestamp;
        oldSnapshot.SerializeBytes(oldTimestamp, 8);
        WorldTimestamp newTimestamp;
        newSnapshot.SerializeBytes(newTimestamp, 8);
        float deltaMs = newTimestamp.DiffMilliseconds(oldTimestamp);
        bool isUsingDelta = -16777216.0 <= deltaMs && deltaMs <= 16777216.0;
        packet.Serialize(isUsingDelta, 1);
        if (isUsingDelta)
        {
            int deltaMsInt = deltaMs;
            packet.SerializeInt(deltaMsInt);
        }
        else
        {
            packet.Serialize(newTimestamp, 64);
        }
 
        vector oldVector;
        oldSnapshot.SerializeVector(oldVector);
        vector newVector;
        newSnapshot.SerializeVector(newVector);
        bool vectorChanged = newVector != oldVector;
        packet.Serialize(vectorChanged, 1);
        if (vectorChanged)
            packet.Serialize(newVector, 96);
 
        // More techniques are possible when modification patterns are known. For example,
        // when multiple properties are always modified together, they could share single
        // bit that would say whether there were any changes (and new values were encoded)
        // or not.
    }
 
    static void DecodeDelta(ScriptBitSerializer packet, ScriptCtx ctx, SSnapSerializerBase oldSnapshot, SSnapSerializerBase newSnapshot)
    {
        // Generate new snapshot using data from old snapshot and packet.
        // Note that even when value from old snapshot is not used because packet carries
        // new value, we always read it to make sure we correctly access following
        // properties that may not have changed.
 
        // Bool value is read directly from packet, just as it was written.
        bool oldBool;
        oldSnapshot.SerializeBool(oldBool);
        bool newBool;
        packet.Serialize(newBool, 1);
        newSnapshot.SerializeBool(newBool);
 
        // New value of int is reconstructed by applying delta to old value.
        int oldInt;
        oldSnapshot.SerializeInt(oldInt);
        int deltaInt;
        packet.SerializeInt(deltaInt);
        int newInt = oldInt + deltaInt;
        newSnapshot.SerializeInt(newInt);
 
        // Remaining properties are reconstructed by checking whether they changed
        // and either reading new value from packet, or copying old value.
        string oldString;
        oldSnapshot.SerializeString(oldString);
        bool stringChanged;
        packet.Serialize(stringChanged, 1);
        string newString;
        if (stringChanged)
            packet.SerializeString(newString);
        else
            newString = oldString;
        newSnapshot.SerializeString(newString);
 
        float oldFloat;
        oldSnapshot.SerializeFloat(oldFloat);
        bool floatChanged;
        packet.Serialize(floatChanged, 1);
        float newFloat;
        if (floatChanged)
            packet.Serialize(newFloat, 32);
        else
            newFloat = oldFloat;
        newSnapshot.SerializeFloat(newFloat);
 
        WorldTimestamp oldTimestamp;
        oldSnapshot.SerializeBytes(oldTimestamp, 8);
        bool isUsingDelta;
        packet.Serialize(isUsingDelta, 1);
        WorldTimestamp newTimestamp;
        if (isUsingDelta)
        {
            int deltaMsInt;
            packet.SerializeInt(deltaMsInt);
            float deltaMs = deltaMsInt;
            newTimestamp = oldTimestamp.PlusMilliseconds(deltaMs);
        }
        else
        {
            packet.Serialize(newTimestamp, 64);
        }
        newSnapshot.SerializeBytes(newTimestamp, 8);
 
        vector oldVector;
        oldSnapshot.SerializeVector(oldVector);
        bool vectorChanged;
        packet.Serialize(vectorChanged, 1);
        vector newVector;
        if (vectorChanged)
            packet.Serialize(newVector, 96);
        else
            newVector = oldVector;
        newSnapshot.SerializeVector(newVector);
    }
}

class RplExampleDebugShapeClass: GenericEntityClass {}
RplExampleDebugShapeClass g_RplExampleDebugShapeClassInst;
 
class RplExampleDebugShape : GenericEntity
{
    static const int COLOR_COUNT = 4;
    static const int COLORS[] = {
        Color.BLACK,
        Color.RED,
        Color.GREEN,
        Color.BLUE,
    };
 
    private int m_Color;
 
    void RplExampleDebugShape(IEntitySource src, IEntity parent)
    {
        this.SetEventMask(EntityEvent.FRAME);
    }
 
    override void EOnFrame(IEntity owner, float timeSlice)
    {
        vector worldTransform[4];
        this.GetWorldTransform(worldTransform);
        Shape.CreateSphere(m_Color, ShapeFlags.ONCE, worldTransform[3], 0.5);
    }
 
    bool SetColorByIdx(int colorIdx)
    {
        if (colorIdx < 0 || colorIdx >= COLOR_COUNT)
            return false;
 
        m_Color = COLORS[colorIdx];
        return true;
    }
}

class RplExample1ComponentColorAnimClass : ScriptComponentClass { }
RplExample1ComponentColorAnimClass g_RplExample1ComponentColorAnimClass;
 
class RplExample1ComponentColorAnim : ScriptComponent
{
    // Constant specifying how often (in seconds) to change the color index. For
    // example, setting this to 5 will change the color index every 5 seconds.
    private static const float COLOR_CHANGE_PERIOD_S = 5.0;
 
    // Helper variable for accumulating time (in seconds) every frame and to calculate
    // color index changes.
    private float m_TimeAccumulator_s;
 
    // Color index currently used for drawing the sphere.
    private int m_ColorIdx;
 
    override void OnPostInit(IEntity owner)
    {
        // We check whether this component is attached to entity of correct type and
        // report a problem if not. Once this test passes during initialization, we
        // do not need to worry about owner entity being wrong type anymore.
        auto shapeEnt = RplExampleDebugShape.Cast(owner);
        if (!shapeEnt)
        {
            Print("This example requires that the entity is of type `RplExampleDebugShape`.", LogLevel.WARNING);
            return;
        }
 
        // We initialize shape entity to correct color.
        shapeEnt.SetColorByIdx(m_ColorIdx);
 
        // We subscribe to "frame" events, so that we can run our logic in `EOnFrame`
        // event handler.
        SetEventMask(owner, EntityEvent.FRAME);
    }
 
    override void EOnFrame(IEntity owner, float timeSlice)
    {
        // We calculate change of color index based on time (and configured color
        // change period), then apply the change in color.
        int colorIdxDelta = CalculateColorIdxDelta(timeSlice);
        ApplyColorIdxDelta(owner, colorIdxDelta);
    }
 
    private int CalculateColorIdxDelta(float timeSlice)
    {
        // We first accumulate time and then calculate how many color change periods
        // have occurred, giving us number of colors we've cycled through.
        m_TimeAccumulator_s += timeSlice;
        int colorIdxDelta = m_TimeAccumulator_s / COLOR_CHANGE_PERIOD_S;
 
        // We remove full periods from the accumulator, only carrying over how much
        // time from current period has elapsed.
        m_TimeAccumulator_s -= colorIdxDelta * COLOR_CHANGE_PERIOD_S;
 
        return colorIdxDelta;
    }
 
    private void ApplyColorIdxDelta(IEntity owner, int colorIdxDelta)
    {
        // If there is no change to color index, we do nothing.
        if (colorIdxDelta == 0)
            return;
 
        // We calculate new color index.
        int newColorIdx = (m_ColorIdx + colorIdxDelta) % RplExampleDebugShape.COLOR_COUNT;
 
        // We check also new color index, since shorter periods and lower frame-rate
        // may result in new and old color index values being the same.
        if (newColorIdx == m_ColorIdx)
            return;
 
        // Now we can update the color index ...
        m_ColorIdx = newColorIdx;
 
        // ... and set new color based on new color index value.
        RplExampleDebugShape.Cast(owner).SetColorByIdx(m_ColorIdx);
    }
}

class RplExample2ComponentColorAnimClass : ScriptComponentClass { }
RplExample2ComponentColorAnimClass g_RplExample2ComponentColorAnimClass;
 
class RplExample2ComponentColorAnim : ScriptComponent
{
    private static const float COLOR_CHANGE_PERIOD_S = 5.0;
 
    private float m_TimeAccumulator_s;

    // We mark color index as replicated property using RplProp attribute, making
    // it part of replicated state. We also say we want OnColorIdxChanged function
    // to be invoked whenever replication updates value of color index.
    [RplProp(onRplName: "OnColorIdxChanged")]
    private int m_ColorIdx;

    override void OnPostInit(IEntity owner)
    {
        auto shapeEnt = RplExampleDebugShape.Cast(owner);
        if (!shapeEnt)
        {
            Print("This example requires that the entity is of type `RplExampleDebugShape`.", LogLevel.WARNING);
            return;
        }
 
        shapeEnt.SetColorByIdx(m_ColorIdx);
 
        // We must belong to some RplComponent in order for replication to work.
        // We search for it and warn user when we can't find it.
        auto rplComponent = BaseRplComponent.Cast(shapeEnt.FindComponent(BaseRplComponent));
        if (!rplComponent)
        {
            Print("This example requires that the entity has an RplComponent.", LogLevel.WARNING);
            return;
        }
 
        // We only perform simulation on the authority instance, while all proxy
        // instances just show result of the simulation. Therefore, we only have to
        // subscribe to "frame" events on authority, leaving proxy instances as
        // passive components that do something only when necessary.
        if (rplComponent.Role() == RplRole.Authority)
        {
            SetEventMask(owner, EntityEvent.FRAME);
        }
    }
 
    override void EOnFrame(IEntity owner, float timeSlice)
    {
        int colorIdxDelta = CalculateColorIdxDelta(timeSlice);
        ApplyColorIdxDelta(owner, colorIdxDelta);
    }
 
    private int CalculateColorIdxDelta(float timeSlice)
    {
        m_TimeAccumulator_s += timeSlice;
        int colorIdxDelta = m_TimeAccumulator_s / COLOR_CHANGE_PERIOD_S;
        m_TimeAccumulator_s -= colorIdxDelta * COLOR_CHANGE_PERIOD_S;
        return colorIdxDelta;
    }

    private void ApplyColorIdxDelta(IEntity owner, int colorIdxDelta)
    {
        if (colorIdxDelta == 0)
            return;
 
        int newColorIdx = (m_ColorIdx + colorIdxDelta) % RplExampleDebugShape.COLOR_COUNT;
        if (newColorIdx == m_ColorIdx)
            return;
 
        // Update replicated state with results from the simulation.
        m_ColorIdx = newColorIdx;
 
        // After we have written new value of color index, we let replication know
        // that there are changes in our state that need to be replicated to proxies.
        // Without this call, even if we change our color index, new value would not
        // be replicated to proxies.
        Replication.BumpMe();
 
        // Presentation of replicated state on authority.
        RplExampleDebugShape.Cast(owner).SetColorByIdx(m_ColorIdx);
    }
 
    // Presentation of replicated state on proxy.
    private void OnColorIdxChanged()
    {
        RplExampleDebugShape.Cast(GetOwner()).SetColorByIdx(m_ColorIdx);
    }
}

class RplExample3ComponentColorAnimClass : ScriptComponentClass { }
RplExample3ComponentColorAnimClass g_RplExample3ComponentColorAnimClass;
 
class RplExample3ComponentColorAnim : ScriptComponent
{
    [RplProp(onRplName: "OnColorIdxChanged")]
    private int m_ColorIdx;
 
    override void OnPostInit(IEntity owner)
    {
        auto shapeEnt = RplExampleDebugShape.Cast(owner);
        if (!shapeEnt)
        {
            Print("This example requires that the entity is of type `RplExampleDebugShape`.", LogLevel.WARNING);
            return;
        }
 
        shapeEnt.SetColorByIdx(m_ColorIdx);
 
        auto rplComponent = BaseRplComponent.Cast(shapeEnt.FindComponent(BaseRplComponent));
        if (!rplComponent)
        {
            Print("This example requires that the entity has an RplComponent.", LogLevel.WARNING);
            return;
        }
    }
 
    void NextColor()
    {
        m_ColorIdx = (m_ColorIdx + 1) % RplExampleDebugShape.COLOR_COUNT;
        Replication.BumpMe();
        RplExampleDebugShape.Cast(GetOwner()).SetColorByIdx(m_ColorIdx);
    }
 
    private void OnColorIdxChanged()
    {
        RplExampleDebugShape.Cast(GetOwner()).SetColorByIdx(m_ColorIdx);
    }
}
 
class RplExample3SystemClass : ScriptComponentClass { }
RplExample3SystemClass g_RplExample3SystemClassInst;
 
class RplExample3System : ScriptComponent
{
    static const ResourceName s_ControllerPrefab = "{65B426E2CD4049C3}kroslakmar/RplExampleController.et";
    static const ResourceName s_SpherePrefab = "{1AD0012447ACCE3F}kroslakmar/RplExampleShape.et";
 
    ref RplExample3SessionListener m_SessionListener = new RplExample3SessionListener(this);
    ref map<RplIdentity, RplExample3Controller> m_Controllers = new map<RplIdentity, RplExample3Controller>();
 
    ref array<RplExample3ComponentColorAnim> m_Spheres = new array<RplExample3ComponentColorAnim>();
 
    override void OnPostInit(IEntity owner)
    {
        if (g_Game.InPlayMode())
            SetEventMask(owner, EntityEvent.INIT);
    }
 
    override void EOnInit(IEntity owner)
    {
        RplMode mode = RplSession.Mode();
        if (mode != RplMode.Client)
        {
            RplSession.RegisterCallbacks(m_SessionListener);
        }
 
        if (mode == RplMode.None || mode == RplMode.Listen)
        {
            RplExample3Controller controller = NewController(RplIdentity.Local());
            controller.RplGiven(null);
        }
 
        Resource prefab = Resource.Load(s_SpherePrefab);
        EntitySpawnParams spawnParams = new EntitySpawnParams();
        spawnParams.TransformMode = ETransformMode.WORLD;
        owner.GetWorldTransform(spawnParams.Transform);
        float xBase = spawnParams.Transform[3][0];
        float yBase = spawnParams.Transform[3][1] + 2.0;
        for (int y = -1; y <= 1; y++)
        for (int x = -1; x <= 1; x++)
        {
            spawnParams.Transform[3][0] = xBase + x;
            spawnParams.Transform[3][1] = yBase + y;
            IEntity ent = g_Game.SpawnEntityPrefab(prefab, owner.GetWorld(), spawnParams);
            m_Spheres.Insert(RplExample3ComponentColorAnim.Cast(
                ent.FindComponent(RplExample3ComponentColorAnim)
            ));
        }
    }
 
    RplExample3Controller NewController(RplIdentity identity)
    {
        ref Resource controllerPrefab = Resource.Load(s_ControllerPrefab);
        auto controller = RplExample3Controller.Cast(
            g_Game.SpawnEntityPrefab(controllerPrefab, GetOwner().GetWorld(), null)
        );
        controller.m_System = this;
        m_Controllers.Set(identity, controller);
 
        return controller;
    }
 
    void DeleteController(RplIdentity identity)
    {
        auto controller = m_Controllers.Get(identity);
        delete controller;
        m_Controllers.Remove(identity);
    }
 
    void ChangeColor(int idx)
    {
        m_Spheres[idx].NextColor();
    }
}
 
class RplExample3SessionListener: RplSessionCallbacks
{
    RplExample3System m_System;
 
    void RplExample3SessionListener(RplExample3System system)
    {
        m_System = system;
    }
 
    override void EOnConnected(RplIdentity identity)
    {
        RplExample3Controller controller = m_System.NewController(identity);
        auto rplComponent = BaseRplComponent.Cast(controller.FindComponent(BaseRplComponent));
        rplComponent.Give(identity);
    }
 
    override void EOnDisconnected(RplIdentity identity)
    {
        m_System.DeleteController(identity);
    }
};
 
class RplExample3ControllerClass : GenericEntityClass {}
RplExample3ControllerClass g_RplExample3ControllerClassInst;
 
class RplExample3Controller : GenericEntity
{
    static const KeyCode s_KeyMap[] = {
        KeyCode.KC_NUMPAD1,
        KeyCode.KC_NUMPAD2,
        KeyCode.KC_NUMPAD3,
        KeyCode.KC_NUMPAD4,
        KeyCode.KC_NUMPAD5,
        KeyCode.KC_NUMPAD6,
        KeyCode.KC_NUMPAD7,
        KeyCode.KC_NUMPAD8,
        KeyCode.KC_NUMPAD9,
    };
 
    RplExample3System m_System;
    int m_IsDownMask = 0;
 
    bool RplGiven(ScriptBitReader reader)
    {
        if (false)
        {
            SetEventMask(EntityEvent.FRAME);
        }
        else
        {
            SetEventMask(EntityEvent.FIXEDFRAME);
        }
        return true;
    }
 
    override void EOnFrame(IEntity owner, float timeSlice)
    {
        foreach (int idx, KeyCode kc : s_KeyMap)
        {
            int keyBit = 1 << idx;
            bool isDown = Debug.KeyState(kc);
            bool wasDown = (m_IsDownMask & keyBit);
            if (isDown && !wasDown)
                Rpc(Rpc_ChangeColor_S, idx);
 
            if (isDown)
                m_IsDownMask |= keyBit;
            else
                m_IsDownMask &= ~keyBit;
        }
    }
 
    [RplRpc(RplChannel.Reliable, RplRcver.Server)]
    void Rpc_ChangeColor_S(int idx)
    {
        if (idx < 0 || idx >= 9)
            return;
 
        m_System.ChangeColor(idx);
    }
 
    override void EOnFixedFrame(IEntity owner, float timeSlice)
    {
        int isDownMask = 0;
        int keyBit = 1;
        foreach (KeyCode kc : s_KeyMap)
        {
            if (Debug.KeyState(kc))
                isDownMask |= keyBit;
 
            keyBit <<= 1;
        }
        Rpc(Rpc_OwnerInputs_S, isDownMask);
    }
 
    [RplRpc(RplChannel.Unreliable, RplRcver.Server)]
    void Rpc_OwnerInputs_S(int isDownMask)
    {
        int inputsChanged = m_IsDownMask ^ isDownMask;
        if (!inputsChanged)
            return;
 
        for (int idx = 0; idx < 9; idx++)
        {
            int keyBit = 1 << idx;
            bool isDown = isDownMask & keyBit;
            bool wasDown = m_IsDownMask & keyBit;
            if (isDown && !wasDown)
                m_System.ChangeColor(idx);
        }
 
        m_IsDownMask = isDownMask;
    }
};
 
#endif