Removal and Replacement of the CryTimer (gEnv->pTimer) (#5409)

Replaced and removed the CryTimer (gEnv->pTimer). The new TimeSystem is a merger of the current time functionality found in the engine.

* Rename TimeSystemComponent.h/.cpp to TimeSystem.h/.cpp
* Adding New TimeSystem
* remove old timer cvars
* small improvements to the time system.
 - updated parts to use the time conversion functions.
 - in AdvanceTickDeltaTimes applying t_simulationTickScale is now uses doubles instead of floats.
* Replace gEnv->pTimer / ITimer usages with TimeSystem
* Updating usages of AZ::TimeMs{ 0 } and AZ::TimeUs{ 0 } to AZ::Time::ZeroTimeMs and AZ::Time::ZeroTimeUs
* red code the CryTimer
* using TimeUs instead of TimeMs is some cases + updating usages of old cvars to new

Signed-off-by: amzn-sean <75276488+amzn-sean@users.noreply.github.com>

Gems/Multiplayer/Code/Include/Multiplayer/Components/LocalPredictionPlayerInputComponent.h

@@ -99,8 +99,8 @@ namespace Multiplayer
         double m_moveAccumulator = 0.0;
         double m_clientBankedTime = 0.0;
 
-        AZ::TimeMs m_lastInputReceivedTimeMs = AZ::TimeMs{ 0 };
-        AZ::TimeMs m_lastCorrectionSentTimeMs = AZ::TimeMs{ 0 };
+        AZ::TimeMs m_lastInputReceivedTimeMs = AZ::Time::ZeroTimeMs;
+        AZ::TimeMs m_lastCorrectionSentTimeMs = AZ::Time::ZeroTimeMs;
 
         ClientInputId m_clientInputId = ClientInputId{ 0 }; // Clients incrementing inputId
         ClientInputId m_lastClientInputId = ClientInputId{ 0 }; // Last inputId processed by the server

Gems/Multiplayer/Code/Include/Multiplayer/IMultiplayer.h

@@ -265,7 +265,7 @@ namespace Multiplayer
         }
     private:
         HostFrameId m_previousHostFrameId = InvalidHostFrameId;
-        AZ::TimeMs m_previousHostTimeMs = AZ::TimeMs{ 0 };
+        AZ::TimeMs m_previousHostTimeMs = AZ::Time::ZeroTimeMs;
         AzNetworking::ConnectionId m_previousRewindConnectionId = AzNetworking::InvalidConnectionId;
         float m_previousBlendFactor = DefaultBlendFactor;
     };

Gems/Multiplayer/Code/Include/Multiplayer/MultiplayerStats.h

@@ -27,7 +27,7 @@ namespace Multiplayer
         uint64_t m_serverConnectionCount = 0;
 
         uint64_t m_recordMetricIndex = 0;
-        AZ::TimeMs m_totalHistoryTimeMs = AZ::TimeMs{ 0 };
+        AZ::TimeMs m_totalHistoryTimeMs = AZ::Time::ZeroTimeMs;
 
         static const uint32_t RingbufferSamples = 32;
         using MetricRingbuffer = AZStd::array<uint64_t, RingbufferSamples>;

Gems/Multiplayer/Code/Include/Multiplayer/NetworkEntity/EntityReplication/EntityReplicationManager.h

@@ -201,9 +201,9 @@ namespace Multiplayer
         AZStd::unique_ptr<IReplicationWindow> m_replicationWindow;
         AZStd::unique_ptr<IEntityDomain> m_remoteEntityDomain;
 
-        AZ::TimeMs m_entityActivationTimeSliceMs = AZ::TimeMs{ 0 };
-        AZ::TimeMs m_entityPendingRemovalMs = AZ::TimeMs{ 0 };
-        AZ::TimeMs m_frameTimeMs = AZ::TimeMs{ 0 };
+        AZ::TimeMs m_entityActivationTimeSliceMs = AZ::Time::ZeroTimeMs;
+        AZ::TimeMs m_entityPendingRemovalMs = AZ::Time::ZeroTimeMs;
+        AZ::TimeMs m_frameTimeMs = AZ::Time::ZeroTimeMs;
         HostId m_remoteHostId = InvalidHostId;
         uint32_t m_maxRemoteEntitiesPendingCreationCount = AZStd::numeric_limits<uint32_t>::max();
         uint32_t m_maxPayloadSize = 0;

Gems/Multiplayer/Code/Include/Multiplayer/NetworkInput/NetworkInput.h

@@ -75,7 +75,7 @@ namespace Multiplayer
         MultiplayerComponentInputVector m_componentInputs;
         ClientInputId m_inputId = ClientInputId{ 0 };
         HostFrameId m_hostFrameId = InvalidHostFrameId;
-        AZ::TimeMs m_hostTimeMs = AZ::TimeMs{ 0 };
+        AZ::TimeMs m_hostTimeMs = AZ::Time::ZeroTimeMs;
         float m_hostBlendFactor = 0.f;
         ConstNetworkEntityHandle m_owner;
         bool m_wasAttached = false;

Gems/Multiplayer/Code/Source/Components/LocalPredictionPlayerInputComponent.cpp

@@ -66,11 +66,6 @@ namespace Multiplayer
         }
     }
 
-    inline double ConvertTimeMsToSeconds(AZ::TimeMs value)
-    {
-        return static_cast<double>(static_cast<AZ::TimeMs>(value)) / 1000.0;
-    }
-
     void LocalPredictionPlayerInputComponent::LocalPredictionPlayerInputComponent::Reflect(AZ::ReflectContext* context)
     {
         AZ::SerializeContext* serializeContext = azrtti_cast<AZ::SerializeContext*>(context);
@@ -162,7 +157,7 @@ namespace Multiplayer
         }
 
         const AZ::TimeMs currentTimeMs = AZ::GetElapsedTimeMs();
-        const double clientInputRateSec = ConvertTimeMsToSeconds(cl_InputRateMs);
+        const double clientInputRateSec = AZ::TimeMsToSecondsDouble(cl_InputRateMs);
         m_lastInputReceivedTimeMs = currentTimeMs;
 
         // Keep track of last inputs received, also allows us to update frame ids
@@ -267,7 +262,7 @@ namespace Multiplayer
             return;
         }
 
-        const double clientInputRateSec = ConvertTimeMsToSeconds(cl_InputRateMs);
+        const double clientInputRateSec = AZ::TimeMsToSecondsDouble(cl_InputRateMs);
 
         // Copy array so we can modify input ids
         NetworkInputMigrationVector inputArrayCopy = inputArray;
@@ -342,7 +337,7 @@ namespace Multiplayer
         // If this correction is for a move outside our input history window, just start replaying from the oldest move we have available
         const uint32_t startReplayIndex = (inputHistorySize > historicalDelta) ? (inputHistorySize - historicalDelta) : 0;
 
-        const double clientInputRateSec = ConvertTimeMsToSeconds(cl_InputRateMs);
+        const double clientInputRateSec = AZ::TimeMsToSecondsDouble(cl_InputRateMs);
         for (uint32_t replayIndex = startReplayIndex; replayIndex < inputHistorySize; ++replayIndex)
         {
             // Reprocess the input for this frame
@@ -423,9 +418,9 @@ namespace Multiplayer
 
     void LocalPredictionPlayerInputComponentController::UpdateAutonomous(AZ::TimeMs deltaTimeMs)
     {
-        const double deltaTime = ConvertTimeMsToSeconds(deltaTimeMs);
-        const double clientInputRateSec = ConvertTimeMsToSeconds(cl_InputRateMs);
-        const double maxRewindHistory = ConvertTimeMsToSeconds(cl_MaxRewindHistoryMs);
+        const double deltaTime = AZ::TimeMsToSecondsDouble(deltaTimeMs);
+        const double clientInputRateSec = AZ::TimeMsToSecondsDouble(cl_InputRateMs);
+        const double maxRewindHistory = AZ::TimeMsToSecondsDouble(cl_MaxRewindHistoryMs);
 
 #ifndef AZ_RELEASE_BUILD
         m_moveAccumulator += deltaTime * cl_DebugHackTimeMultiplier;

Gems/Multiplayer/Code/Source/ConnectionData/ClientToServerConnectionData.cpp

@@ -13,7 +13,7 @@ namespace Multiplayer
     // This can be used to help mitigate client side performance when large numbers of entities are created off the network
     AZ_CVAR(uint32_t, cl_ClientMaxRemoteEntitiesPendingCreationCount, AZStd::numeric_limits<uint32_t>::max(), nullptr, AZ::ConsoleFunctorFlags::DontReplicate, "Maximum number of entities that we have sent to the client, but have not had a confirmation back from the client");
     AZ_CVAR(AZ::TimeMs, cl_ClientEntityReplicatorPendingRemovalTimeMs, AZ::TimeMs{ 10000 }, nullptr, AZ::ConsoleFunctorFlags::DontReplicate, "How long should wait prior to removing an entity for the client through a change in the replication window, entity deletes are still immediate");
-    AZ_CVAR(AZ::TimeMs, cl_DefaultNetworkEntityActivationTimeSliceMs, AZ::TimeMs{ 0 }, nullptr, AZ::ConsoleFunctorFlags::DontReplicate, "Max Ms to use to activate entities coming from the network, 0 means instantiate everything");
+    AZ_CVAR(AZ::TimeMs, cl_DefaultNetworkEntityActivationTimeSliceMs, AZ::Time::ZeroTimeMs, nullptr, AZ::ConsoleFunctorFlags::DontReplicate, "Max Ms to use to activate entities coming from the network, 0 means instantiate everything");
 
     ClientToServerConnectionData::ClientToServerConnectionData
     (

Gems/Multiplayer/Code/Source/Debug/MultiplayerDebugHierarchyReporter.cpp

@@ -27,7 +27,7 @@ namespace Multiplayer
         CollectHierarchyRoots();
 
         AZ::EntitySystemBus::Handler::BusConnect();
-        m_updateDebugOverlay.Enqueue(AZ::TimeMs{ 0 }, true);
+        m_updateDebugOverlay.Enqueue(AZ::Time::ZeroTimeMs, true);
     }
 
     MultiplayerDebugHierarchyReporter::~MultiplayerDebugHierarchyReporter()

Gems/Multiplayer/Code/Source/Debug/MultiplayerDebugPerEntityReporter.cpp

@@ -127,7 +127,7 @@ namespace Multiplayer
     MultiplayerDebugPerEntityReporter::MultiplayerDebugPerEntityReporter()
         : m_updateDebugOverlay([this]() { UpdateDebugOverlay(); }, AZ::Name("UpdateDebugPerEntityOverlay"))
     {
-        m_updateDebugOverlay.Enqueue(AZ::TimeMs{ 0 }, true);
+        m_updateDebugOverlay.Enqueue(AZ::Time::ZeroTimeMs, true);
 
         m_eventHandlers.m_entitySerializeStart = decltype(m_eventHandlers.m_entitySerializeStart)([this](AzNetworking::SerializerMode mode, AZ::EntityId entityId, const char* entityName)
             {

Gems/Multiplayer/Code/Source/Editor/MultiplayerEditorConnection.cpp

@@ -35,7 +35,7 @@ namespace Multiplayer
     {
         m_networkEditorInterface = AZ::Interface<INetworking>::Get()->CreateNetworkInterface(
             AZ::Name(MpEditorInterfaceName), ProtocolType::Tcp, TrustZone::ExternalClientToServer, *this);
-        m_networkEditorInterface->SetTimeoutMs(AZ::TimeMs{ 0 }); // Disable timeouts on this network interface
+        m_networkEditorInterface->SetTimeoutMs(AZ::Time::ZeroTimeMs); // Disable timeouts on this network interface
 
         // Wait to activate the editor-server until LegacySystemInterfaceCreated so that the logging system is ready
         // Automated testing listens for these logs

Gems/Multiplayer/Code/Source/MultiplayerSystemComponent.h

@@ -178,7 +178,7 @@ namespace Multiplayer
         AZStd::queue<AZStd::string> m_pendingConnectionTickets;
         AZStd::unordered_map<uint64_t, NetEntityId> m_playerRejoinData;
 
-        AZ::TimeMs m_lastReplicatedHostTimeMs = AZ::TimeMs{ 0 };
+        AZ::TimeMs m_lastReplicatedHostTimeMs = AZ::Time::ZeroTimeMs;
         HostFrameId m_lastReplicatedHostFrameId = HostFrameId(0);
 
         uint64_t m_temporaryUserIdentifier = 0; // Used in the event of a migration or rejoin

Gems/Multiplayer/Code/Source/NetworkEntity/EntityReplication/EntityReplicationManager.cpp

@@ -54,10 +54,10 @@ namespace Multiplayer
         m_maxPayloadSize = connection.GetConnectionMtu() - UdpPacketHeaderSerializeSize - ReplicationManagerPacketOverhead;
 
         // Schedule ClearRemovedReplicators()
-        m_clearRemovedReplicators.Enqueue(AZ::TimeMs{ 0 }, true);
+        m_clearRemovedReplicators.Enqueue(AZ::Time::ZeroTimeMs, true);
 
         // Start window update events
-        m_updateWindow.Enqueue(AZ::TimeMs{ 0 }, true);
+        m_updateWindow.Enqueue(AZ::Time::ZeroTimeMs, true);
 
         INetworkEntityManager* networkEntityManager = GetNetworkEntityManager();
         if (networkEntityManager != nullptr)
@@ -97,7 +97,7 @@ namespace Multiplayer
                     notReadyEntities.push_back(entityId);
                 }
             }
-            if (m_entityActivationTimeSliceMs > AZ::TimeMs{ 0 } && AZ::GetElapsedTimeMs() > endTimeMs)
+            if (m_entityActivationTimeSliceMs > AZ::Time::ZeroTimeMs && AZ::GetElapsedTimeMs() > endTimeMs)
             {
                 // If we go over our timeslice, break out the loop
                 break;

Gems/Multiplayer/Code/Source/NetworkEntity/EntityReplication/EntityReplicator.cpp

@@ -344,7 +344,7 @@ namespace Multiplayer
     void EntityReplicator::SetPendingRemoval(AZ::TimeMs pendingRemovalTimeMs)
     {
         AZ_Assert(m_propertyPublisher, "Only valid if we are publishing updates");
-        if (pendingRemovalTimeMs > AZ::TimeMs{ 0 })
+        if (pendingRemovalTimeMs > AZ::Time::ZeroTimeMs)
         {
             if (!IsPendingRemoval())
             {

Gems/Multiplayer/Code/Source/NetworkEntity/EntityReplication/PropertySubscriber.cpp

@@ -26,7 +26,7 @@ namespace Multiplayer
 
     bool PropertySubscriber::IsDeleting() const
     {
-        return m_markForRemovalTimeMs > AZ::TimeMs{ 0 };
+        return m_markForRemovalTimeMs > AZ::Time::ZeroTimeMs;
     }
 
     bool PropertySubscriber::IsDeleted() const

Gems/Multiplayer/Code/Source/NetworkEntity/EntityReplication/PropertySubscriber.h

@@ -40,6 +40,6 @@ namespace Multiplayer
 
         // The last packet to have been received about this entity
         AzNetworking::PacketId m_lastReceivedPacketId = AzNetworking::InvalidPacketId;
-        AZ::TimeMs m_markForRemovalTimeMs = AZ::TimeMs{ 0 };
+        AZ::TimeMs m_markForRemovalTimeMs = AZ::Time::ZeroTimeMs;
     };
 }

Gems/Multiplayer/Code/Source/NetworkEntity/NetworkEntityManager.cpp

@@ -123,7 +123,7 @@ namespace Multiplayer
                 AZ_Assert(entityHandle.GetNetBindComponent(), "No NetBindComponent found on networked entity");
             }
             m_removeList.push_back(entityHandle.GetNetEntityId());
-            m_removeEntitiesEvent.Enqueue(AZ::TimeMs{ 0 });
+            m_removeEntitiesEvent.Enqueue(AZ::Time::ZeroTimeMs);
         }
     }
 

Gems/Multiplayer/Code/Source/NetworkTime/NetworkTime.h

@@ -44,7 +44,7 @@ namespace Multiplayer
 
         HostFrameId m_hostFrameId = HostFrameId{ 0 };
         HostFrameId m_unalteredFrameId = HostFrameId{ 0 };
-        AZ::TimeMs m_hostTimeMs = AZ::TimeMs{ 0 };
+        AZ::TimeMs m_hostTimeMs = AZ::Time::ZeroTimeMs;
         float m_hostBlendFactor = DefaultBlendFactor;
         AzNetworking::ConnectionId m_rewindingConnectionId = AzNetworking::InvalidConnectionId;
     };

Gems/Multiplayer/Code/Tests/CommonBenchmarkSetup.h

@@ -14,6 +14,7 @@
 #include <AzCore/Console/Console.h>
 #include <AzCore/Name/Name.h>
 #include <AzCore/Serialization/SerializeContext.h>
+#include <AzCore/UnitTest/Mocks/MockITime.h>
 #include <AzFramework/Components/TransformComponent.h>
 #include <benchmark/benchmark.h>
 #include <Multiplayer/Components/NetBindComponent.h>
@@ -92,20 +93,6 @@ namespace Multiplayer
         }
     };
 
-    class BenchmarkTime : public AZ::ITime
-    {
-    public:
-        AZ::TimeMs GetElapsedTimeMs() const override
-        {
-            return {};
-        }
-
-        AZ::TimeUs GetElapsedTimeUs() const override
-        {
-            return {};
-        }
-    };
-
     class BenchmarkNetworkTime : public Multiplayer::INetworkTime
     {
     public:
@@ -349,8 +336,7 @@ namespace Multiplayer
             // Without Multiplayer::RegisterMultiplayerComponents() the stats go to invalid id, which is fine for unit tests
             GetMultiplayer()->GetStats().ReserveComponentStats(Multiplayer::InvalidNetComponentId, 50, 0);
 
-            m_Time = AZStd::make_unique<BenchmarkTime>();
-            AZ::Interface<AZ::ITime>::Register(m_Time.get());
+            m_Time = AZStd::make_unique<AZ::StubTimeSystem>();
 
             m_NetworkTime = AZStd::make_unique<BenchmarkNetworkTime>();
             AZ::Interface<INetworkTime>::Register(m_NetworkTime.get());
@@ -381,7 +367,6 @@ namespace Multiplayer
             m_ConnectionListener.reset();
 
             AZ::Interface<INetworkTime>::Unregister(m_NetworkTime.get());
-            AZ::Interface<AZ::ITime>::Unregister(m_Time.get());
             AZ::Interface<IMultiplayer>::Unregister(m_Multiplayer.get());
             AZ::Interface<AZ::ComponentApplicationRequests>::Unregister(m_ComponentApplicationRequests.get());
 
@@ -414,7 +399,7 @@ namespace Multiplayer
 
         AZStd::unique_ptr<BenchmarkMultiplayer> m_Multiplayer;
         AZStd::unique_ptr<BenchmarkNetworkEntityManager> m_NetworkEntityManager;
-        AZStd::unique_ptr<BenchmarkTime> m_Time;
+        AZStd::unique_ptr<AZ::StubTimeSystem> m_Time;
         AZStd::unique_ptr<BenchmarkNetworkTime> m_NetworkTime;
 
         AZStd::unique_ptr<BenchmarkMultiplayerConnection> m_Connection;

Gems/Multiplayer/Code/Tests/CommonHierarchySetup.h

@@ -18,6 +18,7 @@
 #include <AzCore/Serialization/SerializeContext.h>
 #include <AzCore/UnitTest/TestTypes.h>
 #include <AzCore/UnitTest/UnitTest.h>
+#include <AzCore/UnitTest/Mocks/MockITime.h>
 #include <AzFramework/Components/TransformComponent.h>
 #include <AzNetworking/Serialization/NetworkInputSerializer.h>
 #include <AzNetworking/Serialization/NetworkOutputSerializer.h>
@@ -117,8 +118,7 @@ namespace Multiplayer
             ON_CALL(*m_mockNetworkEntityManager, GetEntity(_)).WillByDefault(Invoke(this, &HierarchyTests::GetEntity));
             ON_CALL(*m_mockNetworkEntityManager, GetNetEntityIdById(_)).WillByDefault(Invoke(this, &HierarchyTests::GetNetEntityIdById));
 
-            m_mockTime = AZStd::make_unique<NiceMock<MockTime>>();
-            AZ::Interface<AZ::ITime>::Register(m_mockTime.get());
+            m_mockTime = AZStd::make_unique<AZ::NiceTimeSystemMock>();
 
             m_eventScheduler = AZStd::make_unique<AZ::EventSchedulerSystemComponent>();
 
@@ -168,7 +168,6 @@ namespace Multiplayer
             m_networkEntityAuthorityTracker.reset();
 
             AZ::Interface<INetworkTime>::Unregister(m_mockNetworkTime.get());
-            AZ::Interface<AZ::ITime>::Unregister(m_mockTime.get());
             AZ::Interface<INetworkEntityManager>::Unregister(m_mockNetworkEntityManager.get());
             AZ::Interface<IMultiplayer>::Unregister(m_mockMultiplayer.get());
             AZ::Interface<AZ::ComponentApplicationRequests>::Unregister(m_mockComponentApplicationRequests.get());
@@ -207,8 +206,8 @@ namespace Multiplayer
 
         AZStd::unique_ptr<NiceMock<MockMultiplayer>> m_mockMultiplayer;
         AZStd::unique_ptr<MockNetworkEntityManager> m_mockNetworkEntityManager;
-        AZStd::unique_ptr<NiceMock<MockTime>> m_mockTime;
         AZStd::unique_ptr<AZ::EventSchedulerSystemComponent> m_eventScheduler;
+        AZStd::unique_ptr<AZ::NiceTimeSystemMock> m_mockTime;
         AZStd::unique_ptr<NiceMock<MockNetworkTime>> m_mockNetworkTime;
 
         AZStd::unique_ptr<NiceMock<IMultiplayerConnectionMock>> m_mockConnection;

Gems/Multiplayer/Code/Tests/MockInterfaces.h

@@ -103,13 +103,6 @@ namespace UnitTest
         MOCK_METHOD3(OnDisconnect, void(IConnection*, DisconnectReason, TerminationEndpoint));
     };
 
-    class MockTime : public AZ::ITime
-    {
-    public:
-        MOCK_CONST_METHOD0(GetElapsedTimeUs, AZ::TimeUs());
-        MOCK_CONST_METHOD0(GetElapsedTimeMs, AZ::TimeMs());
-    };
-
     class MockNetworkTime : public Multiplayer::INetworkTime
     {
     public:

Gems/Multiplayer/Code/Tests/RewindableContainerTests.cpp

@@ -12,7 +12,7 @@
 #include <Multiplayer/NetworkTime/RewindableObject.h>
 #include <Source/NetworkTime/NetworkTime.h>
 #include <AzCore/Console/LoggerSystemComponent.h>
-#include <AzCore/Time/TimeSystemComponent.h>
+#include <AzCore/Time/TimeSystem.h>
 #include <AzCore/UnitTest/TestTypes.h>
 
 namespace UnitTest
@@ -23,7 +23,7 @@ namespace UnitTest
     public:
         Multiplayer::NetworkTime m_networkTime;
         AZ::LoggerSystemComponent m_loggerComponent;
-        AZ::TimeSystemComponent m_timeComponent;
+        AZ::TimeSystem m_timeSystem;
     };
 
     static constexpr uint32_t RewindableContainerSize = 7;
@@ -43,7 +43,7 @@ namespace UnitTest
         // Test rewind for all pushed values and overall size
         for (uint32_t idx = 0; idx < RewindableContainerSize; ++idx)
         {
-            Multiplayer::ScopedAlterTime time(static_cast<Multiplayer::HostFrameId>(idx), AZ::TimeMs{ 0 }, 1.f, AzNetworking::InvalidConnectionId);
+            Multiplayer::ScopedAlterTime time(static_cast<Multiplayer::HostFrameId>(idx), AZ::Time::ZeroTimeMs, 1.f, AzNetworking::InvalidConnectionId);
             EXPECT_EQ(idx + 1, test.size());
             EXPECT_EQ(idx, test.back());
         }
@@ -70,9 +70,9 @@ namespace UnitTest
         EXPECT_TRUE(test.empty());
 
         // Test rewind for pop_back and clear
-        Multiplayer::ScopedAlterTime pop_time(static_cast<Multiplayer::HostFrameId>(RewindableContainerSize), AZ::TimeMs{ 0 }, 1.f, AzNetworking::InvalidConnectionId);
+        Multiplayer::ScopedAlterTime pop_time(static_cast<Multiplayer::HostFrameId>(RewindableContainerSize), AZ::Time::ZeroTimeMs, 1.f, AzNetworking::InvalidConnectionId);
         EXPECT_EQ(RewindableContainerSize - 1, test.size());
-        Multiplayer::ScopedAlterTime clear_time(static_cast<Multiplayer::HostFrameId>(RewindableContainerSize + 1), AZ::TimeMs{ 0 }, 1.f, AzNetworking::InvalidConnectionId);
+        Multiplayer::ScopedAlterTime clear_time(static_cast<Multiplayer::HostFrameId>(RewindableContainerSize + 1), AZ::Time::ZeroTimeMs, 1.f, AzNetworking::InvalidConnectionId);
         EXPECT_EQ(0, test.size());
 
         // Test copy_values and resize_no_construct
@@ -100,7 +100,7 @@ namespace UnitTest
         // Test rewind for all values and overall size
         for (uint32_t idx = 1; idx <= RewindableContainerSize; ++idx)
         {
-            Multiplayer::ScopedAlterTime time(static_cast<Multiplayer::HostFrameId>(idx), AZ::TimeMs{ 0 }, 1.f, AzNetworking::InvalidConnectionId);
+            Multiplayer::ScopedAlterTime time(static_cast<Multiplayer::HostFrameId>(idx), AZ::Time::ZeroTimeMs, 1.f, AzNetworking::InvalidConnectionId);
             for (uint32_t testIdx = 0; testIdx < RewindableContainerSize; ++testIdx)
             {
                 if (testIdx < idx)

Gems/Multiplayer/Code/Tests/RewindableObjectTests.cpp

@@ -10,7 +10,7 @@
 #include <Multiplayer/NetworkTime/RewindableObject.h>
 #include <Source/NetworkTime/NetworkTime.h>
 #include <AzCore/Console/LoggerSystemComponent.h>
-#include <AzCore/Time/TimeSystemComponent.h>
+#include <AzCore/Time/TimeSystem.h>
 #include <AzCore/UnitTest/TestTypes.h>
 
 namespace UnitTest
@@ -21,7 +21,7 @@ namespace UnitTest
     public:
         Multiplayer::NetworkTime m_networkTime;
         AZ::LoggerSystemComponent m_loggerComponent;
-        AZ::TimeSystemComponent m_timeComponent;
+        AZ::TimeSystem m_timeSystem;
     };
 
     static constexpr uint32_t RewindableBufferFrames = 32;
@@ -39,7 +39,7 @@ namespace UnitTest
 
         for (uint32_t i = 0; i < 16; ++i)
         {
-            Multiplayer::ScopedAlterTime time(static_cast<Multiplayer::HostFrameId>(i), AZ::TimeMs{ 0 }, 1.f, AzNetworking::InvalidConnectionId);
+            Multiplayer::ScopedAlterTime time(static_cast<Multiplayer::HostFrameId>(i), AZ::Time::ZeroTimeMs, 1.f, AzNetworking::InvalidConnectionId);
             EXPECT_EQ(i, test);
         }
 
@@ -52,7 +52,7 @@ namespace UnitTest
 
         for (uint32_t i = 16; i < 48; ++i)
         {
-            Multiplayer::ScopedAlterTime time(static_cast<Multiplayer::HostFrameId>(i), AZ::TimeMs{ 0 }, 1.f, AzNetworking::InvalidConnectionId);
+            Multiplayer::ScopedAlterTime time(static_cast<Multiplayer::HostFrameId>(i), AZ::Time::ZeroTimeMs, 1.f, AzNetworking::InvalidConnectionId);
             EXPECT_EQ(i, test);
         }
     }
@@ -70,15 +70,15 @@ namespace UnitTest
 
         {
             // Test that Get/GetPrevious return different value when not on the owning connection
-            Multiplayer::ScopedAlterTime time(static_cast<Multiplayer::HostFrameId>(RewindableBufferFrames - 1), AZ::TimeMs{ 0 }, 1.f, AzNetworking::InvalidConnectionId);
+            Multiplayer::ScopedAlterTime time(static_cast<Multiplayer::HostFrameId>(RewindableBufferFrames - 1), AZ::Time::ZeroTimeMs, 1.f, AzNetworking::InvalidConnectionId);
             EXPECT_EQ(RewindableBufferFrames - 1, test.Get());
             EXPECT_EQ(RewindableBufferFrames - 2, test.GetPrevious());
         }
 
         // Test that Get/GetPrevious return the unaltered frame on the owning conection
-        Multiplayer::GetNetworkTime()->AlterTime(static_cast<Multiplayer::HostFrameId>(RewindableBufferFrames - 1), AZ::TimeMs{ 0 }, 1.f, AzNetworking::ConnectionId(0));
+        Multiplayer::GetNetworkTime()->AlterTime(static_cast<Multiplayer::HostFrameId>(RewindableBufferFrames - 1), AZ::Time::ZeroTimeMs, 1.f, AzNetworking::ConnectionId(0));
         {
-            Multiplayer::ScopedAlterTime time(static_cast<Multiplayer::HostFrameId>(RewindableBufferFrames - 1), AZ::TimeMs{ 0 }, 1.f, AzNetworking::ConnectionId(0));
+            Multiplayer::ScopedAlterTime time(static_cast<Multiplayer::HostFrameId>(RewindableBufferFrames - 1), AZ::Time::ZeroTimeMs, 1.f, AzNetworking::ConnectionId(0));
             test.SetOwningConnectionId(AzNetworking::ConnectionId(0));
             EXPECT_EQ(RewindableBufferFrames - 1, test.Get());
             EXPECT_EQ(RewindableBufferFrames - 1, test.GetPrevious());
@@ -99,7 +99,7 @@ namespace UnitTest
 
         {
             // Note that we didn't actually set any value for time rewindableBufferFrames, so we're testing fetching a value past the last time set
-            Multiplayer::ScopedAlterTime time(static_cast<Multiplayer::HostFrameId>(RewindableBufferFrames), AZ::TimeMs{ 0 }, 1.f, AzNetworking::InvalidConnectionId);
+            Multiplayer::ScopedAlterTime time(static_cast<Multiplayer::HostFrameId>(RewindableBufferFrames), AZ::Time::ZeroTimeMs, 1.f, AzNetworking::InvalidConnectionId);
             EXPECT_EQ(RewindableBufferFrames - 1, test);
         }
     }
@@ -122,7 +122,7 @@ namespace UnitTest
 
         for (uint32_t i = 0; i < RewindableBufferFrames; ++i)
         {
-            Multiplayer::ScopedAlterTime time(static_cast<Multiplayer::HostFrameId>(i), AZ::TimeMs{ 0 }, 1.f, AzNetworking::InvalidConnectionId);
+            Multiplayer::ScopedAlterTime time(static_cast<Multiplayer::HostFrameId>(i), AZ::Time::ZeroTimeMs, 1.f, AzNetworking::InvalidConnectionId);
             const Object& value = test;
             EXPECT_EQ(value.value, i);
         }
@@ -131,19 +131,19 @@ namespace UnitTest
     TEST_F(RewindableObjectTests, TestBackfillOnLargeTimestep)
     {
         Multiplayer::RewindableObject<uint32_t, RewindableBufferFrames> test(0);
-        Multiplayer::ScopedAlterTime time1(static_cast<Multiplayer::HostFrameId>(0), AZ::TimeMs{ 0 }, 1.f, AzNetworking::InvalidConnectionId);
+        Multiplayer::ScopedAlterTime time1(static_cast<Multiplayer::HostFrameId>(0), AZ::Time::ZeroTimeMs, 1.f, AzNetworking::InvalidConnectionId);
         test = 1;
 
-        Multiplayer::ScopedAlterTime time2(static_cast<Multiplayer::HostFrameId>(31), AZ::TimeMs{ 0 }, 1.f, AzNetworking::InvalidConnectionId);
+        Multiplayer::ScopedAlterTime time2(static_cast<Multiplayer::HostFrameId>(31), AZ::Time::ZeroTimeMs, 1.f, AzNetworking::InvalidConnectionId);
         test = 2;
 
         for (uint32_t i = 0; i < 31; ++i)
         {
-            Multiplayer::ScopedAlterTime time(static_cast<Multiplayer::HostFrameId>(i), AZ::TimeMs{ 0 }, 1.f, AzNetworking::InvalidConnectionId);
+            Multiplayer::ScopedAlterTime time(static_cast<Multiplayer::HostFrameId>(i), AZ::Time::ZeroTimeMs, 1.f, AzNetworking::InvalidConnectionId);
             EXPECT_EQ(1, test);
         }
 
-        Multiplayer::ScopedAlterTime time3(static_cast<Multiplayer::HostFrameId>(31), AZ::TimeMs{ 0 }, 1.f,  AzNetworking::InvalidConnectionId);
+        Multiplayer::ScopedAlterTime time3(static_cast<Multiplayer::HostFrameId>(31), AZ::Time::ZeroTimeMs, 1.f,  AzNetworking::InvalidConnectionId);
         EXPECT_EQ(2, test);
     }
 
@@ -159,7 +159,7 @@ namespace UnitTest
 
         for (uint32_t i = 0; i < 1000; ++i)
         {
-            Multiplayer::ScopedAlterTime time(static_cast<Multiplayer::HostFrameId>(1000 - i), AZ::TimeMs{ 0 }, 1.f, AzNetworking::InvalidConnectionId);
+            Multiplayer::ScopedAlterTime time(static_cast<Multiplayer::HostFrameId>(1000 - i), AZ::Time::ZeroTimeMs, 1.f, AzNetworking::InvalidConnectionId);
             EXPECT_EQ(1000, test);
         }
     }