Skip to content

Commit c027110

Browse files
Ignore a late half float base sync older than the applied base
A base sync from a former owner can reach a non-authority after the new owner's teleport; it must not replace the newer base.
1 parent d6ff9b0 commit c027110

2 files changed

Lines changed: 95 additions & 29 deletions

File tree

‎com.unity.netcode.gameobjects/Runtime/Components/NetworkTransform.cs‎

Lines changed: 9 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1869,6 +1869,9 @@ private void AddLogEntry(ref NetworkTransformState networkTransformState, ulong
18691869
/// </summary>
18701870
private NetworkDeltaPosition m_HalfPositionState = new NetworkDeltaPosition(Vector3.zero, 0);
18711871

1872+
// Non-authority only: the network tick of the state that last set the half float base position.
1873+
private int m_HalfPositionBaseTick;
1874+
18721875
internal void UpdatePositionSlerp()
18731876
{
18741877
if (m_PositionInterpolator != null)
@@ -2989,6 +2992,7 @@ private void ApplyTeleportingState(NetworkTransformState newState)
29892992
{
29902993
// With delta position teleport updates or synchronization, we create a new instance and provide the current network tick.
29912994
m_HalfPositionState = new NetworkDeltaPosition(newState.CurrentPosition, newState.NetworkTick, math.bool3(SyncPositionX, SyncPositionY, SyncPositionZ));
2995+
m_HalfPositionBaseTick = newState.NetworkTick;
29922996

29932997
// When first synchronizing we determine if we need to apply the current delta position
29942998
// offset or not. This is specific to owner authoritative mode on the owner side only
@@ -3192,6 +3196,7 @@ internal void ApplyUpdatedState(NetworkTransformState newState)
31923196
if (flagStates.SynchronizeBaseHalfFloat)
31933197
{
31943198
m_HalfPositionState = m_LocalAuthoritativeNetworkState.NetworkDeltaPosition;
3199+
m_HalfPositionBaseTick = newState.NetworkTick;
31953200
}
31963201
else
31973202
{
@@ -3345,11 +3350,13 @@ private void OnNetworkStateChanged(NetworkTransformState oldState, NetworkTransf
33453350
if (UseUnreliableDeltas && oldState.NetworkTick > newState.NetworkTick && !newState.FlagStates.IsTeleportingNextFrame && !newState.FlagStates.UnreliableFrameSync)
33463351
{
33473352
// A half float base sync is sent reliably and the deltas after it unreliably, so it can arrive after them.
3348-
// Its position is stale but its base is not: every later delta is relative to it.
3353+
// Its position is stale but its base is not: every later delta is relative to it. A base sync older than
3354+
// the applied base (from a former owner, after an ownership change) is still dropped.
33493355
var flagStates = newState.FlagStates;
3350-
if (flagStates.SynchronizeBaseHalfFloat && flagStates.UseHalfFloatPrecision && flagStates.HasPositionChange)
3356+
if (flagStates.SynchronizeBaseHalfFloat && flagStates.UseHalfFloatPrecision && flagStates.HasPositionChange && newState.NetworkTick > m_HalfPositionBaseTick)
33513357
{
33523358
m_HalfPositionState.CurrentBasePosition = newState.NetworkDeltaPosition.CurrentBasePosition;
3359+
m_HalfPositionBaseTick = newState.NetworkTick;
33533360
}
33543361
return;
33553362
}

‎com.unity.netcode.gameobjects/Tests/Runtime/NetworkTransform/NetworkTransformHalfFloatLateBaseTests.cs‎

Lines changed: 86 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -9,7 +9,7 @@ namespace Unity.Netcode.RuntimeTests
99
{
1010
/// <summary>
1111
/// Validates that a half float base sync arriving after the unreliable deltas that depend on it still updates
12-
/// the non-authority's base position.
12+
/// the non-authority's base position, unless a newer base has already been applied.
1313
/// </summary>
1414
[TestFixture(HostOrServer.Host)]
1515
[TestFixture(HostOrServer.DAHost)]
@@ -20,6 +20,8 @@ internal class NetworkTransformHalfFloatLateBaseTests : IntegrationTestWithAppro
2020
private const float k_DeltaStep = 0.5f;
2121

2222
private GameObject m_TestPrefab;
23+
private NetworkTransform m_NonAuthority;
24+
private int m_NetworkTick;
2325

2426
public NetworkTransformHalfFloatLateBaseTests(HostOrServer hostOrServer) : base(hostOrServer)
2527
{
@@ -36,6 +38,17 @@ protected override void OnServerAndClientsCreated()
3638
base.OnServerAndClientsCreated();
3739
}
3840

41+
private IEnumerator SpawnTestObject()
42+
{
43+
var authority = GetAuthorityNetworkManager();
44+
var authorityInstance = SpawnObject(m_TestPrefab, authority).GetComponent<NetworkObject>();
45+
yield return WaitForSpawnedOnAllOrTimeOut(authorityInstance);
46+
AssertOnTimeout($"Timed out waiting for {authorityInstance.name} to spawn on all clients!");
47+
48+
m_NonAuthority = GetNonAuthorityNetworkManager().SpawnManager.SpawnedObjects[authorityInstance.NetworkObjectId].GetComponent<NetworkTransform>();
49+
m_NetworkTick = authority.ServerTime.Tick + 10;
50+
}
51+
3952
private static NetworkTransform.NetworkTransformState CreateState(NetworkDeltaPosition networkDeltaPosition, int networkTick)
4053
{
4154
return new NetworkTransform.NetworkTransformState()
@@ -54,46 +67,92 @@ private static NetworkTransform.NetworkTransformState CreateState(NetworkDeltaPo
5467
};
5568
}
5669

57-
private static void Receive(NetworkTransform nonAuthority, NetworkTransform.NetworkTransformState state)
70+
/// <summary>
71+
/// Encodes the way the authority does: crossing MaxDeltaBeforeAdjustment collapses the delta into a new base.
72+
/// </summary>
73+
private NetworkTransform.NetworkTransformState CreateBaseSync(ref NetworkDeltaPosition networkDeltaPosition, ref Vector3 position)
5874
{
59-
nonAuthority.InboundState = state;
60-
nonAuthority.TransformStateUpdate();
75+
position = new Vector3(NetworkDeltaPosition.MaxDeltaBeforeAdjustment + k_DeltaStep, 0.0f, 0.0f);
76+
networkDeltaPosition.UpdateFrom(ref position, ++m_NetworkTick);
77+
Assert.IsTrue(networkDeltaPosition.CollapsedDeltaIntoBase, "The update did not collapse into a new base!");
78+
return CreateState(networkDeltaPosition, m_NetworkTick);
79+
}
80+
81+
private void Receive(NetworkTransform.NetworkTransformState state)
82+
{
83+
m_NonAuthority.InboundState = state;
84+
m_NonAuthority.TransformStateUpdate();
85+
}
86+
87+
private void AssertNonAuthorityPosition(Vector3 position, string reason)
88+
{
89+
Assert.IsTrue(Approximately(m_NonAuthority.transform.position, position),
90+
$"{m_NonAuthority.NetworkManager.name} is at {m_NonAuthority.transform.position} but the authority is at {position}. {reason}");
6191
}
6292

6393
[UnityTest]
6494
public IEnumerator LateBaseSyncStillUpdatesBase()
6595
{
66-
var authority = GetAuthorityNetworkManager();
67-
var authorityInstance = SpawnObject(m_TestPrefab, authority).GetComponent<NetworkObject>();
68-
yield return WaitForSpawnedOnAllOrTimeOut(authorityInstance);
69-
AssertOnTimeout($"Timed out waiting for {authorityInstance.name} to spawn on all clients!");
70-
71-
var nonAuthority = GetNonAuthorityNetworkManager().SpawnManager.SpawnedObjects[authorityInstance.NetworkObjectId].GetComponent<NetworkTransform>();
96+
yield return SpawnTestObject();
7297

73-
// Encode the way the authority does: crossing MaxDeltaBeforeAdjustment collapses the delta into a new base.
74-
var networkTick = authority.ServerTime.Tick + 10;
75-
var authorityDeltaPosition = new NetworkDeltaPosition(Vector3.zero, networkTick);
76-
var position = new Vector3(NetworkDeltaPosition.MaxDeltaBeforeAdjustment + k_DeltaStep, 0.0f, 0.0f);
77-
authorityDeltaPosition.UpdateFrom(ref position, ++networkTick);
78-
Assert.IsTrue(authorityDeltaPosition.CollapsedDeltaIntoBase, "The first update did not collapse into a new base!");
79-
var baseSync = CreateState(authorityDeltaPosition, networkTick);
98+
var authorityDeltaPosition = new NetworkDeltaPosition(Vector3.zero, m_NetworkTick);
99+
var position = Vector3.zero;
100+
var baseSync = CreateBaseSync(ref authorityDeltaPosition, ref position);
80101

81102
position.x += k_DeltaStep;
82-
authorityDeltaPosition.UpdateFrom(ref position, ++networkTick);
83-
var firstDelta = CreateState(authorityDeltaPosition, networkTick);
103+
authorityDeltaPosition.UpdateFrom(ref position, ++m_NetworkTick);
104+
var firstDelta = CreateState(authorityDeltaPosition, m_NetworkTick);
84105

85106
position.x += k_DeltaStep;
86-
authorityDeltaPosition.UpdateFrom(ref position, ++networkTick);
87-
var secondDelta = CreateState(authorityDeltaPosition, networkTick);
107+
authorityDeltaPosition.UpdateFrom(ref position, ++m_NetworkTick);
108+
var secondDelta = CreateState(authorityDeltaPosition, m_NetworkTick);
88109

89110
// The unreliable delta overtakes the reliable base sync it depends on.
90-
Receive(nonAuthority, firstDelta);
91-
Receive(nonAuthority, baseSync);
92-
Receive(nonAuthority, secondDelta);
111+
Receive(firstDelta);
112+
Receive(baseSync);
113+
Receive(secondDelta);
114+
115+
AssertNonAuthorityPosition(position, "The late base sync was not applied, so the delta was decoded against the previous base.");
116+
}
117+
118+
[UnityTest]
119+
public IEnumerator BaseSyncOlderThanAppliedBaseIsIgnored()
120+
{
121+
yield return SpawnTestObject();
122+
123+
// The former owner's base sync, delayed past an ownership change.
124+
var formerOwnerDeltaPosition = new NetworkDeltaPosition(Vector3.zero, m_NetworkTick);
125+
var position = Vector3.zero;
126+
var staleBaseSync = CreateBaseSync(ref formerOwnerDeltaPosition, ref position);
127+
128+
// The new owner teleports to its current position when it gains ownership, which sets a new base.
129+
m_NetworkTick += 10;
130+
position = new Vector3(10.0f, 0.0f, 0.0f);
131+
var teleport = new NetworkTransform.NetworkTransformState()
132+
{
133+
NetworkTick = m_NetworkTick,
134+
CurrentPosition = position,
135+
FlagStates =
136+
{
137+
HasPositionX = true,
138+
HasPositionChange = true,
139+
UseHalfFloatPrecision = true,
140+
UseUnreliableDeltas = true,
141+
IsTeleportingNextFrame = true,
142+
ReliableSequenced = true,
143+
},
144+
};
145+
146+
var newOwnerDeltaPosition = new NetworkDeltaPosition(position, m_NetworkTick);
147+
position.x += k_DeltaStep;
148+
newOwnerDeltaPosition.UpdateFrom(ref position, ++m_NetworkTick);
149+
var newOwnerDelta = CreateState(newOwnerDeltaPosition, m_NetworkTick);
150+
151+
Receive(teleport);
152+
Receive(staleBaseSync);
153+
Receive(newOwnerDelta);
93154

94-
Assert.IsTrue(Approximately(nonAuthority.transform.position, position),
95-
$"{nonAuthority.NetworkManager.name} is at {nonAuthority.transform.position} but the authority is at {position}. " +
96-
$"The late base sync was not applied, so the delta was decoded against the previous base.");
155+
AssertNonAuthorityPosition(position, "The former owner's base sync replaced the new owner's base.");
97156
}
98157
}
99158
}

0 commit comments

Comments
 (0)