Exposing SyncVar<T> for use.

[FirstGearGames]

Exposing SyncVar and eventually making it the new standard opens up a lot of opportunities.

I'd like to make a change where SyncVars are used similarly to SyncObjects, such as: private SyncVar<float> _myFloat. There are many benefits to this approach. Much faster get, read, and set speeds. Considerably less code-generation, which also means more reliable support for future Unity versions. As well a more clear indication of updating SyncVar reference or structure types. The downside however is using the SyncVar will be more complex for the developer. An example, _myfloat = 10 may become _myFloat.Value = 10. Just as getting instead of SomeMethod(_myFloat) it would be SomeMethod(_myFloat.Value).
There is another benefit as well, such as on reference or structure types with fields. On these types you must re-assign the SyncVar to a new reference, or unset current reference and set back to force the SyncVar to understand the field values of your reference has changed. With this change you could simply do _syncVar.Value.SomeField = 10, then _syncVar.Dirty().

Usage difference example...

public class OldSyncVar : NetworkBehaviour
{
    [SyncVar]
    private float _myFloat;
    [SyncVar]
    private SomeStruct _myStruct;
    [SyncVar]
    private SomeClass _myClass = new SomeClass();

    private void MyMethod()
    {

        _myFloat++;

        SomeStruct copy = _myStruct;
        copy.Health += 10;
        _myStruct = copy;

        SomeClass copym = _myClass;
        copym.Health += 10;
        _myClass = copym;
    }
}

public class NewSyncVar : NetworkBehaviour
{
    private SyncVar<float> _myFloat = new SyncVar<float>();
    private SyncVar<SomeStruct> _myStruct = new SyncVar<SomeStruct>();
    private SyncVar<SomeClass> _myClass = new SyncVar<SomeClass>();

    private void MyMethod()
    {
        _myFloat.Value++;

        SomeStruct copy = _myStruct.Value;
        copy.Health += 10;
        _myStruct.Value = copy;

        _myClass.Value.Health += 10;
        _myClass.Dirty();
        //Alternative suggested...but wouldnt work on structs anyway so would prob leave it out...
        _myClass.ValueDirtied.Health += 10;
        
    }
}