Integrating latest 47acbe8

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

@@ -0,0 +1,114 @@
+/*
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
+
+#pragma once
+
+#include <AzCore/Time/ITime.h>
+#include <AzNetworking/ConnectionLayer/IConnection.h>
+
+namespace Multiplayer
+{
+    //! This is a strong typedef for representing the number of application frames since application start.
+    AZ_TYPE_SAFE_INTEGRAL(ApplicationFrameId, uint32_t);
+    static constexpr ApplicationFrameId InvalidApplicationFrameId = ApplicationFrameId{0xFFFFFFFF};
+
+    //! @class INetworkTime
+    //! @brief This is an AZ::Interface<> for managing multiplayer specific time related operations.
+    class INetworkTime
+    {
+    public:
+        AZ_RTTI(INetworkTime, "{7D468063-255B-4FEE-86E1-6D750EEDD42A}");
+
+        INetworkTime() = default;
+        virtual ~INetworkTime() = default;
+
+        //! Converts from an ApplicationFrameId to a corresponding TimeMs.
+        //! @param frameId the ApplicationFrameId to convert to a TimeMs
+        //! @return the TimeMs that corresponds to the provided ApplicationFrameId
+        virtual AZ::TimeMs ConvertFrameIdToTimeMs(ApplicationFrameId frameId) const = 0;
+
+        //! Converts from a TimeMs to an ApplicationFrameId.
+        //! @param timeMs the TimeMs to convert to an ApplicationFrameId
+        //! @return the ApplicationFrameId that corresponds to the provided TimeMs
+        virtual ApplicationFrameId ConvertTimeMsToFrameId(AZ::TimeMs timeMs) const = 0;
+
+        //! Returns true if the application frameId has been temporarily altered.
+        //! @return true if the application frameId has been altered, false otherwise
+        virtual bool IsApplicationFrameIdRewound() const = 0;
+
+        //! Retrieves the applications current frameId (may be rewound on the server during backward reconciliation).
+        //! @return the applications current frameId
+        virtual ApplicationFrameId GetApplicationFrameId() const = 0;
+
+        //! Retrieves the unaltered applications current frameId.
+        //! @return the applications current frameId, unaltered by any scoped time instance
+        virtual ApplicationFrameId GetUnalteredApplicationFrameId() const = 0;
+
+        //! Increments the applications current frameId.
+        virtual void IncrementApplicationFrameId() = 0;
+
+        //! Synchronizes rewindable entity state for the current application time.
+        virtual void SyncRewindableEntityState() = 0;
+
+        //! Get the controlling connection that may be currently altering global game time.
+        //! Note this abstraction is required at a relatively high level to allow for 'don't rewind the shooter' semantics
+        //! @return the ConnectionId of the connection requesting the rewind operation
+        virtual AzNetworking::ConnectionId GetRewindingConnectionId() const = 0;
+
+        //! Get the controlling connection that may be currently altering global game time.
+        //! Note this abstraction is required at a relatively high level to allow for 'don't rewind the shooter' semantics
+        //! @param rewindConnectionId if this parameter matches the current rewindConnectionId, it will return the unaltered applicationFrameId
+        //! @return the ApplicationFrameId taking into account the provided rewinding connectionId
+        virtual ApplicationFrameId GetApplicationFrameIdForRewindingConnection(AzNetworking::ConnectionId rewindConnectionId) const = 0;
+
+        //! Alters the current ApplicationFrameId and binds that alteration to the provided ConnectionId.
+        //! @param frameId the new ApplicationFrameId to use
+        //! @param rewindConnectionId the rewinding ConnectionId 
+        virtual void AlterApplicationFrameId(ApplicationFrameId frameId, AzNetworking::ConnectionId rewindConnectionId) = 0;
+
+        AZ_DISABLE_COPY_MOVE(INetworkTime);
+    };
+
+    // EBus wrapper for ScriptCanvas
+    class INetworkTimeRequests
+        : public AZ::EBusTraits
+    {
+    public:
+        static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
+        static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::Single;
+    };
+    using INetworkTimeRequestBus = AZ::EBus<INetworkTime, INetworkTimeRequests>;
+
+    //! @class ScopedAlterTime
+    //! @brief This is a wrapper that temporarily adjusts global program time for backward reconciliation purposes.
+    class ScopedAlterTime final
+    {
+    public:
+        inline ScopedAlterTime(ApplicationFrameId frameId, AzNetworking::ConnectionId connectionId)
+        {
+            INetworkTime* time = AZ::Interface<INetworkTime>::Get();
+            m_previousApplicationFrameId = time->GetApplicationFrameId();
+            m_previousRewindConnectionId = time->GetRewindingConnectionId();
+            time->AlterApplicationFrameId(frameId, connectionId);
+        }
+        inline ~ScopedAlterTime()
+        {
+            INetworkTime* time = AZ::Interface<INetworkTime>::Get();
+            time->AlterApplicationFrameId(m_previousApplicationFrameId, m_previousRewindConnectionId);
+        }
+    private:
+        ApplicationFrameId m_previousApplicationFrameId = InvalidApplicationFrameId;
+        AzNetworking::ConnectionId m_previousRewindConnectionId = AzNetworking::InvalidConnectionId;
+    };
+}
+
+AZ_TYPE_SAFE_INTEGRAL_SERIALIZEBINDING(Multiplayer::ApplicationFrameId);

Gems/Multiplayer/Code/Source/NetworkTime/NetworkTime.cpp

@@ -0,0 +1,79 @@
+/*
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
+
+#include <Source/NetworkTime/NetworkTime.h>
+
+namespace Multiplayer
+{
+    NetworkTime::NetworkTime()
+    {
+        AZ::Interface<INetworkTime>::Register(this);
+    }
+
+    NetworkTime::~NetworkTime()
+    {
+        AZ::Interface<INetworkTime>::Unregister(this);
+    }
+
+    AZ::TimeMs NetworkTime::ConvertFrameIdToTimeMs([[maybe_unused]] ApplicationFrameId frameId) const
+    {
+        return AZ::TimeMs{0};
+    }
+
+    ApplicationFrameId NetworkTime::ConvertTimeMsToFrameId([[maybe_unused]] AZ::TimeMs timeMs) const
+    {
+        return ApplicationFrameId{0};
+    }
+
+    bool NetworkTime::IsApplicationFrameIdRewound() const
+    {
+        return m_rewindingConnectionId != AzNetworking::InvalidConnectionId;
+    }
+
+    ApplicationFrameId NetworkTime::GetApplicationFrameId() const
+    {
+        return m_applicationFrameId;
+    }
+
+    ApplicationFrameId NetworkTime::GetUnalteredApplicationFrameId() const
+    {
+        return m_unalteredFrameId;
+    }
+
+    void NetworkTime::IncrementApplicationFrameId()
+    {
+        AZ_Assert(!IsApplicationFrameIdRewound(), "Incrementing the global application frameId is unsupported under a rewound time scope");
+        ++m_unalteredFrameId;
+        m_applicationFrameId = m_unalteredFrameId;
+    }
+
+    void NetworkTime::SyncRewindableEntityState()
+    {
+
+    }
+
+    AzNetworking::ConnectionId NetworkTime::GetRewindingConnectionId() const
+    {
+        return m_rewindingConnectionId;
+    }
+
+    ApplicationFrameId NetworkTime::GetApplicationFrameIdForRewindingConnection(AzNetworking::ConnectionId rewindConnectionId) const
+    {
+        return (IsApplicationFrameIdRewound() && (rewindConnectionId == m_rewindingConnectionId)) ? m_unalteredFrameId : m_applicationFrameId;
+    }
+
+    void NetworkTime::AlterApplicationFrameId(ApplicationFrameId frameId, AzNetworking::ConnectionId rewindConnectionId)
+    {
+        m_applicationFrameId = frameId;
+        m_rewindingConnectionId = rewindConnectionId;
+    }
+}

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

@@ -0,0 +1,49 @@
+/*
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
+
+#pragma once
+
+#include <Source/NetworkTime/INetworkTime.h>
+#include <AzCore/Component/Component.h>
+#include <AzCore/Console/IConsole.h>
+
+namespace Multiplayer
+{
+    //! Implementation of the INetworkTime interface.
+    class NetworkTime
+        : public INetworkTime
+    {
+    public:
+        NetworkTime();
+        virtual ~NetworkTime();
+
+        //! INetworkTime overrides.
+        //! @{
+        AZ::TimeMs ConvertFrameIdToTimeMs(ApplicationFrameId frameId) const override;
+        ApplicationFrameId ConvertTimeMsToFrameId(AZ::TimeMs timeMs) const override;
+        bool IsApplicationFrameIdRewound() const override;
+        ApplicationFrameId GetApplicationFrameId() const override;
+        ApplicationFrameId GetUnalteredApplicationFrameId() const override;
+        void IncrementApplicationFrameId() override;
+        void SyncRewindableEntityState() override;
+        AzNetworking::ConnectionId GetRewindingConnectionId() const override;
+        ApplicationFrameId GetApplicationFrameIdForRewindingConnection(AzNetworking::ConnectionId rewindConnectionId) const override;
+        void AlterApplicationFrameId(ApplicationFrameId frameId, AzNetworking::ConnectionId rewindConnectionId) override;
+        //! @}
+
+    private:
+
+        ApplicationFrameId m_applicationFrameId = ApplicationFrameId{0};
+        ApplicationFrameId m_unalteredFrameId = ApplicationFrameId{0};
+        AzNetworking::ConnectionId m_rewindingConnectionId = AzNetworking::InvalidConnectionId;
+    };
+}

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

@@ -0,0 +1,109 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#pragma once
+
+#include <Source/NetworkTime/INetworkTime.h>
+#include <AzNetworking/Serialization/ISerializer.h>
+#include <AzNetworking/ConnectionLayer/IConnection.h>
+#include <AzNetworking/Utilities/NetworkCommon.h>
+#include <AzCore/std/containers/array.h>
+#include <AzCore/std/string/string.h>
+#include <AzCore/Console/ILogger.h>
+
+namespace Multiplayer
+{
+    //! @class RewindableObject
+    //! @brief A simple serializable data container that keeps a history of previous values, and can fetch those old values on request.
+    template <typename BASE_TYPE, AZStd::size_t REWIND_SIZE>
+    class RewindableObject
+    {
+    public:
+
+        RewindableObject() = default;
+
+        //! Constructor.
+        //! @param connectionId the connectionId of the connection that owns the object.
+        RewindableObject(AzNetworking::ConnectionId owningConnectionId);
+
+        //! Copy construct from underlying base type.
+        //! @param value base type value to construct from
+        //! @param owningConnectionId the entity id of the owning object
+        explicit RewindableObject(const BASE_TYPE& value, AzNetworking::ConnectionId owningConnectionId);
+
+        //! Copy construct from another rewindable history buffer.
+        //! @param rhs rewindable history buffer to construct from
+        RewindableObject(const RewindableObject& rhs);
+
+        //! Assignment from underlying base type.
+        //! @param rhs base type value to assign from
+        RewindableObject& operator = (const BASE_TYPE& rhs);
+
+        //! Assignment from rewindable history buffer.
+        //! @param rhs rewindable history buffer to assign from
+        RewindableObject& operator = (const RewindableObject& rhs);
+
+        //! Const base type operator.
+        //! @return value in const base type form
+        operator const BASE_TYPE&() const;
+
+        //! Const base type retriever.
+        //! @return value in const base type form
+        const BASE_TYPE& Get() const;
+
+        //! Base type retriever.
+        //! @return value in base type form
+        BASE_TYPE& Modify();
+
+        //! Equality operator.
+        //! @param rhs base type value to compare against
+        //! @return boolean true if this == rhs
+        bool operator == (const BASE_TYPE& rhs) const;
+
+        //! Inequality operator.
+        //! @param rhs base type value to compare against
+        //! @return boolean true if this != rhs
+        bool operator != (const BASE_TYPE& rhs) const;
+
+        //! Base serialize method for all serializable structures or classes to implement
+        //! @param serializer ISerializer instance to use for serialization
+        //! @return boolean true for success, false for serialization failure
+        bool Serialize(AzNetworking::ISerializer& serializer);
+
+    private:
+
+        //! Returns what the appropriate current time is for this rewindable property.
+        //! @return the appropriate current time is for this rewindable property
+        ApplicationFrameId GetCurrentTimeForProperty() const;
+
+        //! Updates the latest value for this object instance, if frameTime represents a current or future time.
+        //! Any attempts to set old values on the object will fail
+        //! @param value     the new value to set in the object history
+        //! @param frameTime the time to set the value for
+        void SetValueForTime(const BASE_TYPE& value, ApplicationFrameId frameTime);
+
+        //! Const value accessor, returns the correct value for the provided input time.
+        //! @param frameTime the frame time to return the associated value for
+        //! @return value given the current input time
+        const BASE_TYPE& GetValueForTime(ApplicationFrameId frameTime) const;
+
+        //! Helper method to compute clamped array index values accounting for the offset head index.
+        AZStd::size_t GetOffsetIndex(AZStd::size_t absoluteIndex) const;
+
+        mutable AzNetworking::ConnectionId m_owningConnectionId = AzNetworking::InvalidConnectionId;
+        ApplicationFrameId m_headTime = ApplicationFrameId{0};
+        uint32_t m_headIndex = 0;
+        AZStd::array<BASE_TYPE, REWIND_SIZE> m_history;
+    };
+}
+
+#include <Source/NetworkTime/RewindableObject.inl>

Gems/Multiplayer/Code/Source/NetworkTime/RewindableObject.inl

@@ -0,0 +1,172 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#pragma once
+
+namespace Multiplayer
+{
+    template <typename BASE_TYPE, AZStd::size_t REWIND_SIZE>
+    inline RewindableObject<BASE_TYPE, REWIND_SIZE>::RewindableObject(AzNetworking::ConnectionId owningConnectionId)
+        : m_owningConnectionId(owningConnectionId)
+    {
+        m_history.fill(BASE_TYPE());
+    }
+
+    template <typename BASE_TYPE, AZStd::size_t REWIND_SIZE>
+    inline RewindableObject<BASE_TYPE, REWIND_SIZE>::RewindableObject(const BASE_TYPE& value, AzNetworking::ConnectionId owningConnectionId)
+        : m_owningConnectionId(owningConnectionId)
+        , m_history(value)
+    {
+        m_history.fill(value);
+    }
+
+    template <typename BASE_TYPE, AZStd::size_t REWIND_SIZE>
+    inline RewindableObject<BASE_TYPE, REWIND_SIZE>::RewindableObject(const RewindableObject<BASE_TYPE, REWIND_SIZE>& rhs)
+        : m_owningConnectionId(rhs.m_owningConnectionId)
+        , m_headTime(GetCurrentTimeForProperty())
+        , m_headIndex(0)
+    {
+        m_history.fill(static_cast<BASE_TYPE>(rhs));
+    }
+
+    template <typename BASE_TYPE, AZStd::size_t REWIND_SIZE>
+    inline RewindableObject<BASE_TYPE, REWIND_SIZE> &RewindableObject<BASE_TYPE, REWIND_SIZE>::operator =(const BASE_TYPE& rhs)
+    {
+        SetValueForTime(rhs, GetCurrentTimeForProperty());
+        return *this;
+    }
+
+    template <typename BASE_TYPE, AZStd::size_t REWIND_SIZE>
+    inline RewindableObject<BASE_TYPE, REWIND_SIZE> &RewindableObject<BASE_TYPE, REWIND_SIZE>::operator =(const RewindableObject<BASE_TYPE, REWIND_SIZE>& rhs)
+    {
+        INetworkTime* networkTime = AZ::Interface<INetworkTime>::Get();
+        SetValueForTime(rhs.GetValueForTime(networkTime->GetApplicationFrameId()), GetCurrentTimeForProperty());
+        return *this;
+    }
+
+    template <typename BASE_TYPE, AZStd::size_t REWIND_SIZE>
+    inline RewindableObject<BASE_TYPE, REWIND_SIZE>::operator const BASE_TYPE& () const
+    {
+        return Get();
+    }
+
+    template <typename BASE_TYPE, AZStd::size_t REWIND_SIZE>
+    inline const BASE_TYPE& RewindableObject<BASE_TYPE, REWIND_SIZE>::Get() const
+    {
+        return GetValueForTime(GetCurrentTimeForProperty());
+    }
+
+    template <typename BASE_TYPE, AZStd::size_t REWIND_SIZE>
+    inline BASE_TYPE& RewindableObject<BASE_TYPE, REWIND_SIZE>::Modify()
+    {
+        ApplicationFrameId frameTime = GetCurrentTimeForProperty();
+        if (frameTime < m_headTime)
+        {
+            AZ_Assert(false, "Trying to mutate a rewindable in the past");
+        }
+        else if (m_headTime < frameTime)
+        {
+            SetValueForTime(GetValueForTime(frameTime), frameTime);
+        }
+        const BASE_TYPE& returnValue = GetValueForTime(GetCurrentTimeForProperty());
+        return const_cast<BASE_TYPE&>(returnValue);
+    }
+
+    template <typename BASE_TYPE, AZStd::size_t REWIND_SIZE>
+    inline bool RewindableObject<BASE_TYPE, REWIND_SIZE>::operator == (const BASE_TYPE& rhs) const
+    {
+        const BASE_TYPE lhs = GetValueForTime(GetCurrentTimeForProperty());
+        return (lhs == rhs);
+    }
+
+    template <typename BASE_TYPE, AZStd::size_t REWIND_SIZE>
+    inline bool RewindableObject<BASE_TYPE, REWIND_SIZE>::operator != (const BASE_TYPE& rhs) const
+    {
+        const BASE_TYPE lhs = GetValueForTime(GetCurrentTimeForProperty());
+        return (lhs != rhs);
+    }
+
+    template <typename BASE_TYPE, AZStd::size_t REWIND_SIZE>
+    inline bool RewindableObject<BASE_TYPE, REWIND_SIZE>::Serialize(AzNetworking::ISerializer& serializer)
+    {
+        BASE_TYPE current = GetValueForTime(GetCurrentTimeForProperty());
+        if (serializer.Serialize(current, "Element") && (serializer.GetSerializerMode() == AzNetworking::SerializerMode::WriteToObject))
+        {
+            SetValueForTime(current, GetCurrentTimeForProperty());
+        }
+        return serializer.IsValid();
+    }
+
+    template <typename BASE_TYPE, AZStd::size_t REWIND_SIZE>
+    inline ApplicationFrameId RewindableObject<BASE_TYPE, REWIND_SIZE>::GetCurrentTimeForProperty() const
+    {
+        INetworkTime* networkTime = AZ::Interface<INetworkTime>::Get();
+        return networkTime->GetApplicationFrameIdForRewindingConnection(m_owningConnectionId);
+    }
+
+    template <typename BASE_TYPE, AZStd::size_t REWIND_SIZE>
+    inline void RewindableObject<BASE_TYPE, REWIND_SIZE>::SetValueForTime(const BASE_TYPE& value, ApplicationFrameId frameTime)
+    {
+        if (frameTime < m_headTime)
+        {
+            // Don't try and set values older than our current head value
+            return;
+        }
+
+        // Keeping a reference to copy to head so that delta bitset differences are only applied from the prev version
+        const BASE_TYPE& prevHead = m_history[m_headIndex];
+
+        if (static_cast<size_t>(frameTime - m_headTime) >= m_history.size())
+        {
+            // This update represents a large enough time delta that we'll just flush the whole buffer with the new value
+            m_headTime = frameTime;
+            m_headIndex = 0;
+            for (uint32_t i = 0; i < m_history.size(); ++i)
+            {
+                m_history[i] = value;
+            }
+            return;
+        }
+
+        while (m_headTime < frameTime)
+        {
+            m_history[m_headIndex] = prevHead;
+            m_headIndex = (m_headIndex + 1) % m_history.size();
+            m_headTime++;
+        }
+
+        m_history[m_headIndex] = value;
+        AZ_Assert(m_headTime == frameTime, "Invalid head value");
+    }
+
+    template <typename BASE_TYPE, AZStd::size_t REWIND_SIZE>
+    inline const BASE_TYPE &RewindableObject<BASE_TYPE, REWIND_SIZE>::GetValueForTime(ApplicationFrameId frameTime) const
+    {
+        if (frameTime > m_headTime)
+        {
+            return m_history[m_headIndex];
+        }
+        const AZStd::size_t frameDelta = static_cast<AZStd::size_t>(m_headTime) - static_cast<AZStd::size_t>(frameTime);
+        return m_history[GetOffsetIndex(frameDelta)];
+    }
+
+    template <typename BASE_TYPE, AZStd::size_t REWIND_SIZE>
+    inline AZStd::size_t RewindableObject<BASE_TYPE, REWIND_SIZE>::GetOffsetIndex(AZStd::size_t absoluteIndex) const
+    {
+        if (absoluteIndex >= m_history.size())
+        {
+            AZLOG(NET_Rewind, "Request for value which is too old");
+            absoluteIndex = m_history.size() - 1;
+        }
+        return ((m_headIndex + m_history.size()) - absoluteIndex) % m_history.size();
+    }
+}