Instant Syncing of SyncType<T> RPC SyncVar.SyncNow();

[Katerlad]

Per our discussion in Open Development, have the ability to Sync a SyncType instantly by using an RPC.

EDIT: This suggestion was created before I knew that RPCs and SyncTypes are both still sent by by Tick by default, its just that RPCs are added to the Iterating packet queue instantly and Synctypes are not.
So when saying "Instant Syncing of SyncTypes, I guess this suggestion now means to also make the SyncTypes be added to the Packet Queue Instantly in order with Other RPCs.

This Is asking for Multi Requirements

• Ability to Call a Method After Setting the Value in the SyncType - Something like SyncVar.SyncNow();
• Ability to Change Value and Call RPC at the Same time - Something like SyncVar.ValueRPC = 10;
• Ability to Change to override each individual sync var options to always send as an RPC.
  • SyncVar _ health = new(1, new SyncVarSetting()
    {
    SyncTiming= Instant; <= default is Tick Options are Instant,Frame,Tick
    });

Allows users to update their Syncvars in the order they are updated inline with Rpcs.

If Implemented, Keep OnChange Hook to not callback until Tick is Called.
Will put separate suggestion to add OnHook override option to invoke at the time it was received.

Need feedback on what the best Syntax is for calling this behavior.

Example

SyncType<int> foo = new SyncType<int>();
SyncType<string> bar = new SyncType<string>();

[Server]
public void UpdateValuesOnServer()
{
    foo.ValueRPC = 10;
    bar.ValueRPC = "Hello";
    
    ShowUpdatedValuesOnClients() 
}

[ObserversRpc]
public void ShowUpdatedValuesOnClients()
{
   //Normally this would show old data, because the syncvars wouldnt sync down until after this RPC was called.
    Debug.Log(foo + Bar);
}

FirstGearsGames Example of Syntax

/// <summary>
        /// Gets and sets the current value for this SyncVar.
        /// </summary>
        public T Value
        {
            get => _value;
            set => SetValue(value, true);
        }
        /// <summary>
        /// Sets the current value for this SyncVar while sending it immediately.
        /// </summary>
        public T ValueRpc
        {
            set => SetValue(value, true, true);
        }
        /// <summary>
        /// Gets the current value for this SyncVar while marking it dirty. This could be useful to change properties or fields on a reference type SyncVar and have the SyncVar be dirtied after.
        /// </summary>
        public T ValueDirty
        {
            get
            {
                base.Dirty();
                return _value;
            }
        }

[FirstGearGames]

The main issue is that SyncTypes are sent with a single header indicating number written among other things. SyncTypes could be broken up to send independently but this would mean including a header for each SyncType.

EG: as of current you have 10 SyncTypes then the header would be roughly 4 + (1 * syncTypes dirtied). So under the assumption 5 were dirty the header would be about 9 bytes.

If SyncTypes were to send independently it would be 5 bytes per. Under the same assumption of 5 dirty this would cost (5 * 5) 25 bytes.

It's not something that's completely undoable, we may even be able to have a special packetId for 'rpc' sync types which would use the 5 byte header. I know this option has come up often enough so perhaps we can work something out after v4 hits stable.

[FirstGearGames]

Revisiting this again, realizing a problem outside the bandwidth comment.

A SyncType sending immediately would also mean you essentially lose the interval option. At that point you're literally just using a RPC. When this is true you may as well just use a RPC...

private int _health;
[ObserversRpc(RunLocally = true)]
private void ObsSet_health(int value) { _health = value; } //also could be your callback.