Various bug fixes to get entity replication working

Code/Framework/AzCore/AzCore/Component/TransformBus.h

@@ -26,7 +26,7 @@ namespace AZ
 {
     class Transform;
 
-    using TransformChangedEvent = Event<Transform, Transform>;
+    using TransformChangedEvent = Event<const Transform&, const Transform&>;
 
     using ParentChangedEvent = Event<EntityId, EntityId>;
 

Code/Framework/AzNetworking/AzNetworking/DataStructures/FixedSizeBitset.h

@@ -114,6 +114,9 @@ namespace AzNetworking
         void ClearUnusedBits();
 
         ContainerType m_container;
+
+        template <AZStd::size_t, typename ElementType>
+        friend class FixedSizeVectorBitset;
     };
 }
 

Code/Framework/AzNetworking/AzNetworking/DataStructures/FixedSizeVectorBitset.inl

@@ -192,19 +192,11 @@ namespace AzNetworking
     template <AZStd::size_t CAPACITY, typename ElementType>
     inline void FixedSizeVectorBitset<CAPACITY, ElementType>::ClearUnusedBits()
     {
-        constexpr ElementType AllOnes  = static_cast<ElementType>(~0);
-        const ElementType LastUsedBits = (GetSize() % BitsetType::ElementTypeBits);
-#pragma warning(push)
-#pragma warning(disable : 4293) // shift count negative or too big, undefined behaviour
-#pragma warning(disable : 6326) // constant constant comparison
-        const ElementType ShiftAmount  = (LastUsedBits == 0) ? 0 : BitsetType::ElementTypeBits - LastUsedBits;
-        const ElementType ClearBitMask = AllOnes >> ShiftAmount;
-#pragma warning(pop)
         uint32_t usedElementSize = (GetSize() + BitsetType::ElementTypeBits - 1) / BitsetType::ElementTypeBits;
-        for (uint32_t i = usedElementSize + 1; i < CAPACITY; ++i)
+        for (uint32_t i = usedElementSize + 1; i < BitsetType::ElementCount; ++i)
         {
             m_bitset.GetContainer()[i] = 0;
         }
-        m_bitset.GetContainer()[m_bitset.GetContainer().size() - 1] &= ClearBitMask;
+        m_bitset.ClearUnusedBits();
     }
 }

Code/Framework/AzNetworking/AzNetworking/Serialization/AzContainerSerializers.h

@@ -270,7 +270,7 @@ namespace AzNetworking
             value.StoreToFloat3(values);
             serializer.Serialize(values[0], "xValue");
             serializer.Serialize(values[1], "yValue");
-            serializer.Serialize(values[1], "zValue");
+            serializer.Serialize(values[2], "zValue");
             value = AZ::Vector3::CreateFromFloat3(values);
             return serializer.IsValid();
         }
@@ -285,8 +285,8 @@ namespace AzNetworking
             value.StoreToFloat4(values);
             serializer.Serialize(values[0], "xValue");
             serializer.Serialize(values[1], "yValue");
-            serializer.Serialize(values[1], "zValue");
-            serializer.Serialize(values[1], "wValue");
+            serializer.Serialize(values[2], "zValue");
+            serializer.Serialize(values[3], "wValue");
             value = AZ::Vector4::CreateFromFloat4(values);
             return serializer.IsValid();
         }
@@ -301,8 +301,8 @@ namespace AzNetworking
             value.StoreToFloat4(values);
             serializer.Serialize(values[0], "xValue");
             serializer.Serialize(values[1], "yValue");
-            serializer.Serialize(values[1], "zValue");
-            serializer.Serialize(values[1], "wValue");
+            serializer.Serialize(values[2], "zValue");
+            serializer.Serialize(values[3], "wValue");
             value = AZ::Quaternion::CreateFromFloat4(values);
             return serializer.IsValid();
         }

Gems/Multiplayer/Code/Include/IMultiplayer.h

@@ -95,4 +95,20 @@ namespace Multiplayer
     private:
         MultiplayerStats m_stats;
     };
+
+    inline const char* GetEnumString(MultiplayerAgentType value)
+    {
+        switch (value)
+        {
+        case MultiplayerAgentType::Uninitialized:
+            return "Uninitialized";
+        case MultiplayerAgentType::Client:
+            return "Client";
+        case MultiplayerAgentType::ClientServer:
+            return "ClientServer";
+        case MultiplayerAgentType::DedicatedServer:
+            return "DedicatedServer";
+        }
+        return "INVALID";
+    }
 }

Gems/Multiplayer/Code/Source/AutoGen/AutoComponent_Header.jinja

@@ -33,22 +33,20 @@ const {{ Property.attrib['Type'] }}& Get{{ PropertyName }}() const;
 #}
 {% macro DeclareNetworkPropertySetter(Property) %}
 {% set PropertyName = UpperFirst(Property.attrib['Name']) %}
-{%     if Property.attrib['IsPredictable'] | booleanTrue %}
-{%         if Property.attrib['Container'] == 'Array' %}
-void Set{{ PropertyName }}(const Multiplayer::NetworkInput&, int32_t index, const {{ Property.attrib['Type'] }}& value);
-{{ Property.attrib['Type'] }}& Modify{{ PropertyName }}(const Multiplayer::NetworkInput&, int32_t index);
-{%         elif Property.attrib['Container'] == 'Vector' %}
-void Set{{ PropertyName }}(const Multiplayer::NetworkInput&, int32_t index, const {{ Property.attrib['Type'] }}& value);
-{{ Property.attrib['Type'] }}& Modify{{ PropertyName }}(const Multiplayer::NetworkInput&, int32_t index);
-bool {{ PropertyName }}PushBack(const Multiplayer::NetworkInput&, const {{ Property.attrib['Type'] }}& value);
-bool {{ PropertyName }}PopBack(const Multiplayer::NetworkInput&);
-void {{ PropertyName }}Clear(const Multiplayer::NetworkInput&);
-{%         elif Property.attrib['Container'] == 'Object' %}
-void Set{{ PropertyName }}(const Multiplayer::NetworkInput&, const {{ Property.attrib['Type'] }}& value);
-{{ Property.attrib['Type'] }}& Modify{{ PropertyName }}(const Multiplayer::NetworkInput&);
-{%         else %}
-void Set{{ PropertyName }}(const Multiplayer::NetworkInput&, const {{ Property.attrib['Type'] }}& value);
-{%         endif %}
+{%     if Property.attrib['Container'] == 'Array' %}
+void Set{{ PropertyName }}(int32_t index, const {{ Property.attrib['Type'] }}& value);
+{{ Property.attrib['Type'] }}& Modify{{ PropertyName }}(int32_t index);
+{%     elif Property.attrib['Container'] == 'Vector' %}
+void Set{{ PropertyName }}(int32_t index, const {{ Property.attrib['Type'] }}& value);
+{{ Property.attrib['Type'] }}& Modify{{ PropertyName }}(int32_t index);
+bool {{ PropertyName }}PushBack(const {{ Property.attrib['Type'] }}& value);
+bool {{ PropertyName }}PopBack();
+void {{ PropertyName }}Clear();
+{%     elif Property.attrib['Container'] == 'Object' %}
+void Set{{ PropertyName }}(const {{ Property.attrib['Type'] }}& value);
+{{ Property.attrib['Type'] }}& Modify{{ PropertyName }}();
+{%     else %}
+void Set{{ PropertyName }}(const {{ Property.attrib['Type'] }}& value);
 {%     endif %}
 {% endmacro %}
 {#
@@ -417,6 +415,7 @@ namespace {{ Component.attrib['Namespace'] }}
         static const Multiplayer::NetComponentId s_componentId = static_cast<Multiplayer::NetComponentId>({{ Component.attrib['Namespace'] }}::ComponentTypes::{{ Component.attrib['Name'] }});
 
         static void Reflect(AZ::ReflectContext* context);
+        static void ReflectToEditContext(AZ::ReflectContext* context);
         static void GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& provided);
         static void GetRequiredServices(AZ::ComponentDescriptor::DependencyArrayType& required);
         static void GetDependentServices(AZ::ComponentDescriptor::DependencyArrayType& dependent);

Gems/Multiplayer/Code/Source/AutoGen/AutoComponent_Source.jinja

@@ -73,18 +73,17 @@ void {{ ClassName }}::{{ UpperFirst(Property.attrib['Name']) }}AddEvent(AZ::Even
 {#
 
 #}
-{% macro DefineNetworkPropertyPredictableSet(Component, ReplicateFrom, ReplicateTo, ClassName, Property) %}
-{%     if Property.attrib['IsPredictable'] | booleanTrue %}
-{%         if Property.attrib['Container'] == 'Array' %}
-void {{ ClassName }}::Set{{ UpperFirst(Property.attrib['Name']) }}(const Multiplayer::NetworkInput& inputCommand, int32_t index, const {{ Property.attrib['Type'] }}& value)
+{% macro DefineNetworkPropertySet(Component, ReplicateFrom, ReplicateTo, ClassName, Property) %}
+{%     if Property.attrib['Container'] == 'Array' %}
+void {{ ClassName }}::Set{{ UpperFirst(Property.attrib['Name']) }}(int32_t index, const {{ Property.attrib['Type'] }}& value)
 {
     if (GetParent().m_{{ LowerFirst(Property.attrib['Name']) }}[index] != value)
     {
-        Modify{{ UpperFirst(Property.attrib['Name']) }}(inputCommand, index) = value;
+        Modify{{ UpperFirst(Property.attrib['Name']) }}(index) = value;
     }
 }
 
-{{ Property.attrib['Type'] }}& {{ ClassName }}::Modify{{ UpperFirst(Property.attrib['Name']) }}(const Multiplayer::NetworkInput&, int32_t index)
+{{ Property.attrib['Type'] }}& {{ ClassName }}::Modify{{ UpperFirst(Property.attrib['Name']) }}(int32_t index)
 {
     int32_t bitIndex = index + static_cast<int32_t>({{ AutoComponentMacros.GetNetPropertiesQualifiedPropertyDirtyEnum(Component.attrib['Name'], ReplicateFrom, ReplicateTo, Property, 'Start') }});
     GetParent().m_currentRecord->m_{{ LowerFirst(AutoComponentMacros.GetNetPropertiesSetName(ReplicateFrom, ReplicateTo)) }}.SetBit(bitIndex, true);
@@ -92,16 +91,16 @@ void {{ ClassName }}::Set{{ UpperFirst(Property.attrib['Name']) }}(const Multipl
     return GetParent().m_{{ LowerFirst(Property.attrib['Name']) }}[index];
 }
 
-{%         elif Property.attrib['Container'] == 'Vector' %}
-void {{ ClassName }}::Set{{ UpperFirst(Property.attrib['Name']) }}(const Multiplayer::NetworkInput& inputCommand, int32_t index, const {{ Property.attrib['Type'] }}& value)
+{%     elif Property.attrib['Container'] == 'Vector' %}
+void {{ ClassName }}::Set{{ UpperFirst(Property.attrib['Name']) }}(int32_t index, const {{ Property.attrib['Type'] }}& value)
 {
     if (GetParent().m_{{ LowerFirst(Property.attrib['Name']) }}[index] != value)
     {
-        Modify{{ UpperFirst(Property.attrib['Name']) }}(inputCommand, index) = value;
+        Modify{{ UpperFirst(Property.attrib['Name']) }}(index) = value;
     }
 }
 
-{{ Property.attrib['Type'] }}& {{ ClassName }}::Modify{{ UpperFirst(Property.attrib['Name']) }}(const Multiplayer::NetworkInput&, int32_t index)
+{{ Property.attrib['Type'] }}& {{ ClassName }}::Modify{{ UpperFirst(Property.attrib['Name']) }}(int32_t index)
 {
     int32_t bitIndex = index + static_cast<int32_t>({{ AutoComponentMacros.GetNetPropertiesQualifiedPropertyDirtyEnum(Component.attrib['Name'], ReplicateFrom, ReplicateTo, Property, 'Start') }});
     GetParent().m_currentRecord->m_{{ LowerFirst(AutoComponentMacros.GetNetPropertiesSetName(ReplicateFrom, ReplicateTo)) }}.SetBit(bitIndex, true);
@@ -109,7 +108,7 @@ void {{ ClassName }}::Set{{ UpperFirst(Property.attrib['Name']) }}(const Multipl
     return GetParent().m_{{ LowerFirst(Property.attrib['Name']) }}[index];
 }
 
-bool {{ ClassName }}::{{ UpperFirst(Property.attrib['Name']) }}PushBack(const Multiplayer::NetworkInput& inputCommand, const {{ Property.attrib['Type'] }} &value)
+bool {{ ClassName }}::{{ UpperFirst(Property.attrib['Name']) }}PushBack(const {{ Property.attrib['Type'] }} &value)
 {
     int32_t indexToSet = GetParent().m_{{ LowerFirst(Property.attrib['Name']) }}.GetSize();
     GetParent().m_{{ LowerFirst(Property.attrib['Name']) }}.PushBack(value);
@@ -134,24 +133,24 @@ void {{ ClassName }}::{{ UpperFirst(Property.attrib['Name']) }}Clear(const Multi
     GetParent().MarkDirty();
 }
 
-{%         elif Property.attrib['Container'] == 'Object' %}
-void {{ ClassName }}::Set{{ UpperFirst(Property.attrib['Name']) }}(const Multiplayer::NetworkInput& inputCommand, const {{ Property.attrib['Type'] }}& value)
+{%     elif Property.attrib['Container'] == 'Object' %}
+void {{ ClassName }}::Set{{ UpperFirst(Property.attrib['Name']) }}(const {{ Property.attrib['Type'] }}& value)
 {
     if (GetParent().m_{{ LowerFirst(Property.attrib['Name']) }} != value)
     {
-        Modify{{ UpperFirst(Property.attrib['Name']) }}(inputCommand) = value;
+        Modify{{ UpperFirst(Property.attrib['Name']) }}() = value;
     }
 }
 
-{{ Property.attrib['Type'] }}& {{ ClassName }}::Modify{{ UpperFirst(Property.attrib['Name']) }}(const Multiplayer::NetworkInput&)
+{{ Property.attrib['Type'] }}& {{ ClassName }}::Modify{{ UpperFirst(Property.attrib['Name']) }}()
 {
     GetParent().m_currentRecord->m_{{ LowerFirst(AutoComponentMacros.GetNetPropertiesSetName(ReplicateFrom, ReplicateTo)) }}.SetBit(static_cast<int32_t>({{ AutoComponentMacros.GetNetPropertiesQualifiedPropertyDirtyEnum(Component.attrib['Name'], ReplicateFrom, ReplicateTo, Property) }}), true);
     GetParent().MarkDirty();
     return GetParent().m_{{ LowerFirst(Property.attrib['Name']) }}{% if Property.attrib['IsRewindable']|booleanTrue %}.Modify(){% endif %};
 }
 
-{%         else %}
-void {{ ClassName }}::Set{{ UpperFirst(Property.attrib['Name']) }}(const Multiplayer::NetworkInput&, const {{ Property.attrib['Type'] }}& value)
+{%     else %}
+void {{ ClassName }}::Set{{ UpperFirst(Property.attrib['Name']) }}(const {{ Property.attrib['Type'] }}& value)
 {
     if (GetParent().m_{{ LowerFirst(Property.attrib['Name']) }} != value)
     {
@@ -161,7 +160,6 @@ void {{ ClassName }}::Set{{ UpperFirst(Property.attrib['Name']) }}(const Multipl
     }
 }
 
-{%         endif %}
 {%     endif %}
 {% endmacro %}
 {#
@@ -273,7 +271,7 @@ void {{ ClassName }}::Set{{ UpperFirst(Property.attrib['Name']) }}(const {{ Prop
 {% call(Property) AutoComponentMacros.ParseNetworkProperties(Component, ReplicateFrom, ReplicateTo) %}
 {% if Property.attrib['IsPublic'] | booleanTrue != IsProtected %}
 {{ DefineNetworkPropertyGet(ClassName, Property, "GetParent().") }}
-{{ DefineNetworkPropertyPredictableSet(Component, ReplicateFrom, ReplicateTo, ClassName, Property) }}
+{{ DefineNetworkPropertySet(Component, ReplicateFrom, ReplicateTo, ClassName, Property) }}
 {% endif %}
 {% endcall %}
 {% endmacro %}
@@ -478,6 +476,7 @@ bool {{ ClassName }}::Serialize{{ AutoComponentMacros.GetNetPropertiesSetName(Re
 {%-      if networkPropertyCount.update({'value': networkPropertyCount.value + 1}) %}{% endif -%} 
 {% endcall %}
 {% if networkPropertyCount.value > 0 %}
+    MultiplayerStats& stats = AZ::Interface<IMultiplayer>::Get()->GetStats();
     // We modify the record if we are writing an update so that we don't notify for a change that really didn't change the value (just a duplicated send from the server)
     [[maybe_unused]] bool modifyRecord = serializer.GetSerializerMode() == AzNetworking::SerializerMode::WriteToObject;
 {% call(Property) AutoComponentMacros.ParseNetworkProperties(Component, ReplicateFrom, ReplicateTo) %}
@@ -509,7 +508,8 @@ bool {{ ClassName }}::Serialize{{ AutoComponentMacros.GetNetPropertiesSetName(Re
         static_cast<int32_t>({{ AutoComponentMacros.GetNetPropertiesQualifiedPropertyDirtyEnum(Component.attrib['Name'], ReplicateFrom, ReplicateTo, Property) }}), 
         m_{{ LowerFirst(Property.attrib['Name']) }}, 
         "{{ Property.attrib['Name'] }}", 
-        GetNetComponentId()
+        GetNetComponentId(), 
+        stats
     );
 {%     endif %}
 {% endcall %}
@@ -1111,23 +1111,29 @@ namespace {{ Component.attrib['Namespace'] }}
 {{ DefineNetworkPropertyReflection(Component, 'Authority', 'Client', ComponentBaseName)|indent(16) -}}
 {{ DefineNetworkPropertyReflection(Component, 'Authority', 'Autonomous', ComponentBaseName)|indent(16) -}}
 {{ DefineNetworkPropertyReflection(Component, 'Autonomous', 'Authority', ComponentBaseName)|indent(16) }}
-                {{ DefineArchetypePropertyReflection(Component, ComponentBaseName)|indent(16) }}
-                ;
+                {{ DefineArchetypePropertyReflection(Component, ComponentBaseName)|indent(16) }};
+        }
+        ReflectToEditContext(context);
+    }
 
+    void {{ ComponentBaseName }}::{{ ComponentBaseName }}::ReflectToEditContext(AZ::ReflectContext* context)
+    {
+        AZ::SerializeContext* serializeContext = azrtti_cast<AZ::SerializeContext*>(context);
+        if (serializeContext)
+        {
             AZ::EditContext* editContext = serializeContext->GetEditContext();
             if (editContext)
             {
-                editContext->Class<{{ ComponentBaseName }}>("{{ ComponentName }}", "{{ Component.attrib['Description'] }}")
+                editContext->Class<{{ ComponentName }}>("{{ ComponentName }}", "{{ Component.attrib['Description'] }}")
                     ->ClassElement(AZ::Edit::ClassElements::EditorData, "")
                     ->Attribute(AZ::Edit::Attributes::Category, "Multiplayer")
                     ->Attribute(AZ::Edit::Attributes::AppearsInAddComponentMenu, AZ_CRC_CE("Game"))
-                    {{ DefineNetworkPropertyEditReflection(Component, 'Authority', 'Authority', ComponentBaseName)|indent(20) -}}
-{{ DefineNetworkPropertyEditReflection(Component, 'Authority', 'Server', ComponentBaseName)|indent(20) -}}
-{{ DefineNetworkPropertyEditReflection(Component, 'Authority', 'Client', ComponentBaseName)|indent(20) -}}
-{{ DefineNetworkPropertyEditReflection(Component, 'Authority', 'Autonomous', ComponentBaseName)|indent(20) -}}
-{{ DefineNetworkPropertyEditReflection(Component, 'Autonomous', 'Authority', ComponentBaseName)|indent(20) }}
-                    {{ DefineArchetypePropertyEditReflection(Component, ComponentBaseName)|indent(20) }}
-                    ;
+                    {{ DefineNetworkPropertyEditReflection(Component, 'Authority', 'Authority', ComponentName)|indent(20) -}}
+{{ DefineNetworkPropertyEditReflection(Component, 'Authority', 'Server', ComponentName)|indent(20) -}}
+{{ DefineNetworkPropertyEditReflection(Component, 'Authority', 'Client', ComponentName)|indent(20) -}}
+{{ DefineNetworkPropertyEditReflection(Component, 'Authority', 'Autonomous', ComponentName)|indent(20) -}}
+{{ DefineNetworkPropertyEditReflection(Component, 'Autonomous', 'Authority', ComponentName)|indent(20) }}
+                    {{ DefineArchetypePropertyEditReflection(Component, ComponentName)|indent(20) }};
             }
         }
     }

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

@@ -24,7 +24,6 @@ namespace Multiplayer
             serializeContext->Class<LocalPredictionPlayerInputComponent, LocalPredictionPlayerInputComponentBase>()
                 ->Version(1);
         }
-
         LocalPredictionPlayerInputComponentBase::Reflect(context);
     }
 

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

@@ -43,8 +43,12 @@ namespace Multiplayer
 
     NetEntityId MultiplayerComponent::GetNetEntityId() const
     {
-        const NetBindComponent* netBindComponent = GetNetBindComponent();
-        return netBindComponent ? netBindComponent->GetNetEntityId() : InvalidNetEntityId;
+        return m_netBindComponent ? m_netBindComponent->GetNetEntityId() : InvalidNetEntityId;
+    }
+
+    NetEntityRole MultiplayerComponent::GetNetEntityRole() const
+    {
+        return m_netBindComponent ? m_netBindComponent->GetNetEntityRole() : NetEntityRole::InvalidRole;
     }
 
     ConstNetworkEntityHandle MultiplayerComponent::GetEntityHandle() const

Gems/Multiplayer/Code/Source/Components/MultiplayerComponent.h

@@ -62,6 +62,7 @@ namespace Multiplayer
         //! @}
 
         NetEntityId GetNetEntityId() const;
+        NetEntityRole GetNetEntityRole() const;
         ConstNetworkEntityHandle GetEntityHandle() const;
         NetworkEntityHandle GetEntityHandle();
         void MarkDirty();
@@ -109,7 +110,8 @@ namespace Multiplayer
         int32_t bitIndex,
         TYPE& value,
         const char* name,
-        [[maybe_unused]] NetComponentId componentId
+        [[maybe_unused]] NetComponentId componentId,
+        MultiplayerStats& stats
     )
     {
         if (bitset.GetBit(bitIndex))
@@ -119,6 +121,7 @@ namespace Multiplayer
             serializer.Serialize(value, name);
             if (modifyRecord && !serializer.GetTrackedChangesFlag())
             {
+                // If the serializer didn't change any values, then lower the flag so we don't unnecessarily notify
                 bitset.SetBit(bitIndex, false);
             }
             const uint32_t postUpdateSize = serializer.GetSize();
@@ -126,8 +129,7 @@ namespace Multiplayer
             const uint32_t updateSize = (postUpdateSize - prevUpdateSize);
             if (updateSize > 0)
             {
-                MultiplayerStats& stats = AZ::Interface<IMultiplayer>::Get()->GetStats();
-                if (serializer.GetSerializerMode() == AzNetworking::SerializerMode::WriteToObject)
+                if (modifyRecord)
                 {
                     stats.m_propertyUpdatesRecv++;
                     stats.m_propertyUpdatesRecvBytes += updateSize;

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

@@ -27,6 +27,11 @@ namespace Multiplayer
         return m_owner.GetNetEntityId();
     }
 
+    NetEntityRole MultiplayerController::GetNetEntityRole() const
+    {
+        return GetNetBindComponent()->GetNetEntityRole();
+    }
+
     AZ::Entity* MultiplayerController::GetEntity() const
     {
         return m_owner.GetEntity();

Gems/Multiplayer/Code/Source/Components/MultiplayerController.h

@@ -47,6 +47,10 @@ namespace Multiplayer
         //! @return the networkId for the entity that owns this controller
         NetEntityId GetNetEntityId() const;
 
+        //! Returns the networkRole for the entity that owns this controller.
+        //! @return the networkRole for the entity that owns this controller
+        NetEntityRole GetNetEntityRole() const;
+
         //! Returns the raw AZ::Entity pointer for the entity that owns this controller.
         //! @return the raw AZ::Entity pointer for the entity that owns this controller
         AZ::Entity* GetEntity() const;

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

@@ -13,6 +13,8 @@
 #include <Source/Components/NetworkTransformComponent.h>
 #include <AzCore/Serialization/SerializeContext.h>
 #include <AzCore/Serialization/EditContext.h>
+#include <AzCore/EBus/IEventScheduler.h>
+#include <AzFramework/Components/TransformComponent.h>
 
 namespace Multiplayer
 {
@@ -24,7 +26,81 @@ namespace Multiplayer
             serializeContext->Class<NetworkTransformComponent, NetworkTransformComponentBase>()
                 ->Version(1);
         }
-
         NetworkTransformComponentBase::Reflect(context);
     }
+
+    NetworkTransformComponent::NetworkTransformComponent()
+        : m_rotationEventHandler([this](const AZ::Quaternion& rotation) { OnRotationChangedEvent(rotation); })
+        , m_translationEventHandler([this](const AZ::Vector3& translation) { OnTranslationChangedEvent(translation); })
+        , m_scaleEventHandler([this](const AZ::Vector3& scale) { OnScaleChangedEvent(scale); })
+    {
+        ;
+    }
+
+    void NetworkTransformComponent::OnInit()
+    {
+        ;
+    }
+
+    void NetworkTransformComponent::OnActivate([[maybe_unused]] Multiplayer::EntityIsMigrating entityIsMigrating)
+    {
+        RotationAddEvent(m_rotationEventHandler);
+        TranslationAddEvent(m_translationEventHandler);
+        ScaleAddEvent(m_scaleEventHandler);
+    }
+
+    void NetworkTransformComponent::OnDeactivate([[maybe_unused]] Multiplayer::EntityIsMigrating entityIsMigrating)
+    {
+        ;
+    }
+
+    void NetworkTransformComponent::OnRotationChangedEvent(const AZ::Quaternion& rotation)
+    {
+        AZ::Transform worldTm = GetTransformComponent()->GetWorldTM();
+        worldTm.SetRotation(rotation);
+        GetTransformComponent()->SetWorldTM(worldTm);
+    }
+
+    void NetworkTransformComponent::OnTranslationChangedEvent(const AZ::Vector3& translation)
+    {
+        AZ::Transform worldTm = GetTransformComponent()->GetWorldTM();
+        worldTm.SetTranslation(translation);
+        GetTransformComponent()->SetWorldTM(worldTm);
+    }
+
+    void NetworkTransformComponent::OnScaleChangedEvent(const AZ::Vector3& scale)
+    {
+        AZ::Transform worldTm = GetTransformComponent()->GetWorldTM();
+        worldTm.SetScale(scale);
+        GetTransformComponent()->SetWorldTM(worldTm);
+    }
+
+
+    NetworkTransformComponentController::NetworkTransformComponentController(NetworkTransformComponent& parent)
+        : NetworkTransformComponentControllerBase(parent)
+        , m_transformChangedHandler([this](const AZ::Transform&, const AZ::Transform& worldTm) { OnTransformChangedEvent(worldTm); })
+    {
+        ;
+    }
+
+    void NetworkTransformComponentController::OnActivate([[maybe_unused]] Multiplayer::EntityIsMigrating entityIsMigrating)
+    {
+        GetParent().GetTransformComponent()->BindTransformChangedEventHandler(m_transformChangedHandler);
+        OnTransformChangedEvent(GetParent().GetTransformComponent()->GetWorldTM());
+    }
+
+    void NetworkTransformComponentController::OnDeactivate([[maybe_unused]] Multiplayer::EntityIsMigrating entityIsMigrating)
+    {
+        ;
+    }
+
+    void NetworkTransformComponentController::OnTransformChangedEvent(const AZ::Transform& worldTm)
+    {
+        if (GetNetEntityRole() == NetEntityRole::Authority)
+        {
+            SetRotation(worldTm.GetRotation());
+            SetTranslation(worldTm.GetTranslation());
+            SetScale(worldTm.GetScale());
+        }
+    }
 }

Gems/Multiplayer/Code/Source/Components/NetworkTransformComponent.h

@@ -13,6 +13,7 @@
 #pragma once
 
 #include <Source/AutoGen/NetworkTransformComponent.AutoComponent.h>
+#include <AzCore/Component/TransformBus.h>
 
 namespace Multiplayer
 {
@@ -22,20 +23,37 @@ namespace Multiplayer
     public:
         AZ_MULTIPLAYER_COMPONENT(Multiplayer::NetworkTransformComponent, s_networkTransformComponentConcreteUuid, Multiplayer::NetworkTransformComponentBase);
 
-        static void Reflect([[maybe_unused]] AZ::ReflectContext* context);
+        static void Reflect(AZ::ReflectContext* context);
 
-        void OnInit() override {}
-        void OnActivate([[maybe_unused]] Multiplayer::EntityIsMigrating entityIsMigrating) override {}
-        void OnDeactivate([[maybe_unused]] Multiplayer::EntityIsMigrating entityIsMigrating) override {}
+        NetworkTransformComponent();
+
+        void OnInit() override;
+        void OnActivate(Multiplayer::EntityIsMigrating entityIsMigrating) override;
+        void OnDeactivate(Multiplayer::EntityIsMigrating entityIsMigrating) override;
+
+    private:
+        void OnRotationChangedEvent(const AZ::Quaternion& rotation);
+        void OnTranslationChangedEvent(const AZ::Vector3& translation);
+        void OnScaleChangedEvent(const AZ::Vector3& scale);
+
+        AZ::Event<AZ::Quaternion>::Handler m_rotationEventHandler;
+        AZ::Event<AZ::Vector3>::Handler m_translationEventHandler;
+        AZ::Event<AZ::Vector3>::Handler m_scaleEventHandler;
     };
 
     class NetworkTransformComponentController
         : public NetworkTransformComponentControllerBase
     {
     public:
-        NetworkTransformComponentController(NetworkTransformComponent& parent) : NetworkTransformComponentControllerBase(parent) {}
+        NetworkTransformComponentController(NetworkTransformComponent& parent);
+
+        void OnActivate(Multiplayer::EntityIsMigrating entityIsMigrating) override;
+        void OnDeactivate(Multiplayer::EntityIsMigrating entityIsMigrating) override;
+
+    private:
+        void OnTransformChangedEvent(const AZ::Transform& worldTm);
 
-        void OnActivate([[maybe_unused]] Multiplayer::EntityIsMigrating entityIsMigrating) override {}
-        void OnDeactivate([[maybe_unused]] Multiplayer::EntityIsMigrating entityIsMigrating) override {}
+        AZ::TransformChangedEvent::Handler m_transformChangedHandler;
+        AZ::ScheduledEvent m_transformChangeEvent;
     };
 }

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

@@ -0,0 +1,59 @@
+/*
+* 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/ConnectionData/ClientToServerConnectionData.h>
+
+namespace Multiplayer
+{
+    static constexpr uint32_t Uint32Max = AZStd::numeric_limits<uint32_t>::max();
+
+    // 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, Uint32Max, 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");
+
+    ClientToServerConnectionData::ClientToServerConnectionData
+    (
+        AzNetworking::IConnection* connection,
+        AzNetworking::IConnectionListener& connectionListener
+    )
+        : m_connection(connection)
+        , m_entityReplicationManager(*connection, connectionListener, EntityReplicationManager::Mode::LocalClientToRemoteServer)
+    {
+        m_entityReplicationManager.SetMaxRemoteEntitiesPendingCreationCount(cl_ClientMaxRemoteEntitiesPendingCreationCount);
+        m_entityReplicationManager.SetEntityPendingRemovalMs(cl_ClientEntityReplicatorPendingRemovalTimeMs);
+    }
+
+    ClientToServerConnectionData::~ClientToServerConnectionData()
+    {
+        m_entityReplicationManager.Clear(false);
+    }
+
+    ConnectionDataType ClientToServerConnectionData::GetConnectionDataType() const
+    {
+        return ConnectionDataType::ClientToServer;
+    }
+
+    AzNetworking::IConnection* ClientToServerConnectionData::GetConnection() const
+    {
+        return m_connection;
+    }
+
+    EntityReplicationManager& ClientToServerConnectionData::GetReplicationManager()
+    {
+        return m_entityReplicationManager;
+    }
+
+    void ClientToServerConnectionData::Update([[maybe_unused]] AZ::TimeMs serverGameTimeMs)
+    {
+        m_entityReplicationManager.ActivatePendingEntities();
+    }
+}

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

@@ -0,0 +1,47 @@
+/*
+* 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/ConnectionData/IConnectionData.h>
+
+namespace Multiplayer
+{
+    class ClientToServerConnectionData final
+        : public IConnectionData
+    {
+    public:
+        ClientToServerConnectionData
+        (
+            AzNetworking::IConnection* connection,
+            AzNetworking::IConnectionListener& connectionListener
+        );
+        ~ClientToServerConnectionData() override;
+
+        //! IConnectionData interface
+        //! @{
+        ConnectionDataType GetConnectionDataType() const override;
+        AzNetworking::IConnection* GetConnection() const override;
+        EntityReplicationManager& GetReplicationManager() override;
+        void Update(AZ::TimeMs serverGameTimeMs) override;
+        //! @}
+
+        bool CanSendUpdates();
+
+    private:
+        EntityReplicationManager m_entityReplicationManager;
+        AzNetworking::IConnection* m_connection = nullptr;
+        bool m_canSendUpdates = true;
+    };
+}
+
+#include <Source/ConnectionData/ClientToServerConnectionData.inl>

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

@@ -0,0 +1,19 @@
+/*
+* 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.
+*
+*/
+
+namespace Multiplayer
+{
+    inline bool ClientToServerConnectionData::CanSendUpdates()
+    {
+        return m_canSendUpdates;
+    }
+}

Gems/Multiplayer/Code/Source/ConnectionData/IConnectionData.h

@@ -19,6 +19,7 @@ namespace Multiplayer
 {
     enum class ConnectionDataType
     {
+        ClientToServer,
         ServerToClient,
         ServerToServer
     };

Gems/Multiplayer/Code/Source/MultiplayerSystemComponent.cpp

@@ -13,7 +13,9 @@
 #include <Source/MultiplayerSystemComponent.h>
 #include <Source/Components/MultiplayerComponent.h>
 #include <Source/AutoGen/AutoComponentTypes.h>
+#include <Source/ConnectionData/ClientToServerConnectionData.h>
 #include <Source/ConnectionData/ServerToClientConnectionData.h>
+#include <Source/ReplicationWindows/NullReplicationWindow.h>
 #include <Source/ReplicationWindows/ServerToClientReplicationWindow.h>
 #include <Source/EntityDomains/FullOwnershipEntityDomain.h>
 #include <AzNetworking/Framework/INetworking.h>
@@ -66,6 +68,7 @@ namespace Multiplayer
     AZ_CVAR(AZ::CVarFixedString, sv_gamerules, "norules", nullptr, AZ::ConsoleFunctorFlags::DontReplicate, "GameRules server works with");
     AZ_CVAR(ProtocolType, sv_protocol, ProtocolType::Udp, nullptr, AZ::ConsoleFunctorFlags::DontReplicate, "This flag controls whether we use TCP or UDP for game networking");
     AZ_CVAR(bool, sv_isDedicated, true, nullptr, AZ::ConsoleFunctorFlags::DontReplicate, "Whether the host command creates an independent or client hosted server");
+    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");
 
     void MultiplayerSystemComponent::Reflect(AZ::ReflectContext* context)
     {
@@ -126,23 +129,26 @@ namespace Multiplayer
         // Handle deferred local rpc messages that were generated during the updates
         m_networkEntityManager.DispatchLocalDeferredRpcMessages();
         m_networkEntityManager.NotifyEntitiesChanged();
+
         // Let the network system know the frame is done and we can collect dirty bits
         m_networkEntityManager.NotifyEntitiesDirtied();
 
-        MultiplayerStats& stats = GetStats();
-        stats.m_entityCount = GetNetworkEntityManager()->GetEntityCount();
-
-        auto sendNetworkUpdates = [serverGameTimeMs](IConnection& connection)
+        // Send out the game state update to all connections
         {
-            if (connection.GetUserData() != nullptr)
+            auto sendNetworkUpdates = [serverGameTimeMs](IConnection& connection)
             {
-                IConnectionData* connectionData = reinterpret_cast<IConnectionData*>(connection.GetUserData());
-                connectionData->Update(serverGameTimeMs);
-            }
-        };
+                if (connection.GetUserData() != nullptr)
+                {
+                    IConnectionData* connectionData = reinterpret_cast<IConnectionData*>(connection.GetUserData());
+                    connectionData->Update(serverGameTimeMs);
+                }
+            };
 
-        // Send out the game state update to all connections
-        m_networkInterface->GetConnectionSet().VisitConnections(sendNetworkUpdates);
+            m_networkInterface->GetConnectionSet().VisitConnections(sendNetworkUpdates);
+        }
+
+        MultiplayerStats& stats = GetStats();
+        stats.m_entityCount = GetNetworkEntityManager()->GetEntityCount();
 
         MultiplayerPackets::SyncConsole packet;
         AZ::ThreadSafeDeque<AZStd::string>::DequeType cvarUpdates;
@@ -245,12 +251,8 @@ namespace Multiplayer
         AZ::CVarFixedString commandString = "sv_map " + packet.GetMap();
         AZ::Interface<AZ::IConsole>::Get()->PerformCommand(commandString.c_str());
 
-        // This is a bit tricky, so it warrants extra commenting
-        // The cry level loader has a 'map' command used to invoke the level load system
-        // We don't want any explicit cry dependencies, so instead we rely on the 
-        // az console binding inside SystemInit to echo any unhandled commands to
-        // the cry console by stripping off the prefix 'sv_'
-        AZ::Interface<AZ::IConsole>::Get()->PerformCommand(commandString.c_str() + 3);
+        AZ::CVarFixedString loadLevelString = "LoadLevel " + packet.GetMap();
+        AZ::Interface<AZ::IConsole>::Get()->PerformCommand(loadLevelString.c_str());
         return true;
     }
 
@@ -410,6 +412,16 @@ namespace Multiplayer
             AZStd::unique_ptr<IReplicationWindow> window = AZStd::make_unique<ServerToClientReplicationWindow>(controlledEntity, connection);
             reinterpret_cast<ServerToClientConnectionData*>(connection->GetUserData())->GetReplicationManager().SetReplicationWindow(AZStd::move(window));
         }
+        else
+        {
+            if (connection->GetUserData() == nullptr) // Only add user data if the connect event handler has not already done so
+            {
+                connection->SetUserData(new ClientToServerConnectionData(connection, *this));
+            }
+
+            AZStd::unique_ptr<IReplicationWindow> window = AZStd::make_unique<NullReplicationWindow>();
+            reinterpret_cast<ServerToClientConnectionData*>(connection->GetUserData())->GetReplicationManager().SetEntityActivationTimeSliceMs(cl_defaultNetworkEntityActivationTimeSliceMs);
+        }
     }
 
     bool MultiplayerSystemComponent::OnPacketReceived(AzNetworking::IConnection* connection, const IPacketHeader& packetHeader, ISerializer& serializer)
@@ -463,6 +475,7 @@ namespace Multiplayer
             }
         }
         m_agentType = multiplayerType;
+        AZLOG_INFO("Multiplayer operating in %s mode", GetEnumString(m_agentType));
     }
 
     void MultiplayerSystemComponent::AddConnectionAcquiredHandler(ConnectionAcquiredEvent::Handler& handler)
@@ -535,14 +548,15 @@ namespace Multiplayer
     void host([[maybe_unused]] const AZ::ConsoleCommandContainer& arguments)
     {
         Multiplayer::MultiplayerAgentType serverType = sv_isDedicated ? MultiplayerAgentType::DedicatedServer : MultiplayerAgentType::ClientServer;
+        AZ::Interface<IMultiplayer>::Get()->InitializeMultiplayer(serverType);
         INetworkInterface* networkInterface = AZ::Interface<INetworking>::Get()->RetrieveNetworkInterface(AZ::Name(s_networkInterfaceName));
         networkInterface->Listen(sv_port);
-        AZ::Interface<IMultiplayer>::Get()->InitializeMultiplayer(serverType);
     }
     AZ_CONSOLEFREEFUNC(host, AZ::ConsoleFunctorFlags::DontReplicate, "Opens a multiplayer connection as a host for other clients to connect to");
 
     void connect([[maybe_unused]] const AZ::ConsoleCommandContainer& arguments)
     {
+        AZ::Interface<IMultiplayer>::Get()->InitializeMultiplayer(MultiplayerAgentType::Client);
         INetworkInterface* networkInterface = AZ::Interface<INetworking>::Get()->RetrieveNetworkInterface(AZ::Name(s_networkInterfaceName));
 
         if (arguments.size() < 1)
@@ -567,12 +581,12 @@ namespace Multiplayer
         int32_t portNumber = atol(portStr);
         const IpAddress ipAddress(addressStr, aznumeric_cast<uint16_t>(portNumber), networkInterface->GetType());
         networkInterface->Connect(ipAddress);
-        AZ::Interface<IMultiplayer>::Get()->InitializeMultiplayer(MultiplayerAgentType::Client);
     }
     AZ_CONSOLEFREEFUNC(connect, AZ::ConsoleFunctorFlags::DontReplicate, "Opens a multiplayer connection to a remote host");
 
     void disconnect([[maybe_unused]] const AZ::ConsoleCommandContainer& arguments)
     {
+        AZ::Interface<IMultiplayer>::Get()->InitializeMultiplayer(MultiplayerAgentType::Uninitialized);
         INetworkInterface* networkInterface = AZ::Interface<INetworking>::Get()->RetrieveNetworkInterface(AZ::Name(s_networkInterfaceName));
         auto visitor = [](IConnection& connection) { connection.Disconnect(DisconnectReason::TerminatedByUser, TerminationEndpoint::Local); };
         networkInterface->GetConnectionSet().VisitConnections(visitor);

Gems/Multiplayer/Code/Source/MultiplayerSystemComponent.h

@@ -21,8 +21,8 @@
 #include <AzNetworking/ConnectionLayer/IConnectionListener.h>
 #include <Include/IMultiplayer.h>
 #include <Source/NetworkTime/NetworkTime.h>
-#include <Source/AutoGen/Multiplayer.AutoPacketDispatcher.h>
 #include <Source/NetworkEntity/NetworkEntityManager.h>
+#include <Source/AutoGen/Multiplayer.AutoPacketDispatcher.h>
 
 namespace AzNetworking
 {

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

@@ -25,6 +25,7 @@
 #include <AzNetworking/PacketLayer/IPacketHeader.h>
 #include <AzNetworking/Serialization/NetworkInputSerializer.h>
 #include <AzNetworking/Serialization/NetworkOutputSerializer.h>
+#include <AzNetworking/Serialization/TrackChangedSerializer.h>
 #include <AzCore/Component/ComponentApplicationBus.h>
 #include <AzCore/Console/IConsole.h>
 #include <AzCore/Console/ILogger.h>
@@ -126,9 +127,9 @@ namespace Multiplayer
         MultiplayerPackets::EntityUpdates entityUpdatePacket;
         entityUpdatePacket.SetHostTimeMs(serverGameTimeMs);
         // Serialize everything
-        for (auto it = toSendList.begin(); it != toSendList.end();)
+        while (!toSendList.empty())
         {
-            EntityReplicator* replicator = *it;
+            EntityReplicator* replicator = toSendList.front();
             NetworkEntityUpdateMessage updateMessage(replicator->GenerateUpdatePacket());
 
             const uint32_t nextMessageSize = updateMessage.GetEstimatedSerializeSize();
@@ -144,15 +145,15 @@ namespace Multiplayer
 
             pendingPacketSize += nextMessageSize;
             entityUpdatePacket.ModifyEntityMessages().push_back(updateMessage);
-            replicatorUpdatedList.push_back(*it);
-            it = toSendList.erase(it);
+            replicatorUpdatedList.push_back(replicator);
+            toSendList.pop_front();
 
             if (largeEntityDetected)
             {
                 AZLOG_WARN("\n\n*******************************");
                 AZLOG_WARN
                 (
-                    "Serializing Extremely Large Entity (%u) - MaxPayload: %d NeededSize %d",
+                    "Serializing extremely large entity (%u) - MaxPayload: %d NeededSize %d",
                     aznumeric_cast<uint32_t>(replicator->GetEntityHandle().GetNetEntityId()),
                     maxPayloadSize,
                     nextMessageSize
@@ -173,16 +174,16 @@ namespace Multiplayer
 
     EntityReplicationManager::EntityReplicatorList EntityReplicationManager::GenerateEntityUpdateList()
     {
+        if (m_replicationWindow == nullptr)
+        {
+            return EntityReplicatorList();
+        }
+
         // Generate a list of all our entities that need updates
-        EntityReplicatorList autonomousReplicators;
-        autonomousReplicators.reserve(m_replicatorsPendingSend.size());
-        EntityReplicatorList proxyReplicators;
-        proxyReplicators.reserve(m_replicatorsPendingSend.size());
+        EntityReplicatorList toSendList;
 
         uint32_t elementsAdded = 0;
-        for (auto iter = m_replicatorsPendingSend.begin(); 
-            iter != m_replicatorsPendingSend.end()
-            && elementsAdded < m_replicationWindow->GetMaxEntityReplicatorSendCount();)
+        for (auto iter = m_replicatorsPendingSend.begin(); iter != m_replicatorsPendingSend.end() && elementsAdded < m_replicationWindow->GetMaxEntityReplicatorSendCount(); )
         {
             EntityReplicator* replicator = GetEntityReplicator(*iter);
             bool clearPendingSend = true;
@@ -218,13 +219,13 @@ namespace Multiplayer
 
                         if (replicator->GetRemoteNetworkRole() == NetEntityRole::Autonomous)
                         {
-                            autonomousReplicators.push_back(replicator);
+                            toSendList.push_back(replicator);
                         }
                         else
                         {
                             if (elementsAdded < m_replicationWindow->GetMaxEntityReplicatorSendCount())
                             {
-                                proxyReplicators.push_back(replicator);
+                                toSendList.push_back(replicator);
                             }
                         }
                     }
@@ -243,9 +244,6 @@ namespace Multiplayer
             }
         }
 
-        EntityReplicatorList toSendList;
-        toSendList.swap(autonomousReplicators);
-        toSendList.insert(toSendList.end(), proxyReplicators.begin(), proxyReplicators.end());
         return toSendList;
     }
 
@@ -543,6 +541,7 @@ namespace Multiplayer
         // Create an entity if we don't have one
         if (createEntity)
         {
+            // @pereslav
             //replicatorEntity = GetNetworkEntityManager()->CreateSingleEntityImmediateInternal(prefabEntityId, EntitySpawnType::Replicate, AutoActivate::DoNotActivate, netEntityId, localNetworkRole, AZ::Transform::Identity());
             AZ_Assert(replicatorEntity != nullptr, "Failed to create entity from prefab");// %s", prefabEntityId.GetString());
             if (replicatorEntity == nullptr)
@@ -765,7 +764,7 @@ namespace Multiplayer
             return HandleEntityDeleteMessage(entityReplicator, packetHeader, updateMessage);
         }
 
-        AzNetworking::NetworkOutputSerializer outputSerializer(updateMessage.GetData()->GetBuffer(), updateMessage.GetData()->GetSize());
+        AzNetworking::TrackChangedSerializer<AzNetworking::NetworkOutputSerializer> outputSerializer(updateMessage.GetData()->GetBuffer(), updateMessage.GetData()->GetSize());
 
         PrefabEntityId prefabEntityId;
         if (updateMessage.GetHasValidPrefabId())
@@ -1125,7 +1124,7 @@ namespace Multiplayer
         {
             if (message.GetPropertyUpdateData().GetSize() > 0)
             {
-                AzNetworking::NetworkOutputSerializer outputSerializer(message.ModifyPropertyUpdateData().GetBuffer(), message.ModifyPropertyUpdateData().GetSize());
+                AzNetworking::TrackChangedSerializer<AzNetworking::NetworkOutputSerializer> outputSerializer(message.ModifyPropertyUpdateData().GetBuffer(), message.ModifyPropertyUpdateData().GetSize());
                 if (!HandlePropertyChangeMessage
                 (
                     replicator,

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

@@ -22,6 +22,7 @@
 #include <AzNetworking/PacketLayer/IPacketHeader.h>
 #include <AzCore/std/containers/map.h>
 #include <AzCore/std/containers/vector.h>
+#include <AzCore/std/containers/deque.h>
 #include <AzCore/std/limits.h>
 #include <AzCore/EBus/Event.h>
 #include <AzCore/EBus/ScheduledEvent.h>
@@ -114,7 +115,7 @@ namespace Multiplayer
         using RpcMessages = AZStd::list<NetworkEntityRpcMessage>;
         bool DispatchOrphanedRpc(NetworkEntityRpcMessage& message, EntityReplicator* entityReplicator);
 
-        using EntityReplicatorList = AZStd::vector<EntityReplicator*>;
+        using EntityReplicatorList = AZStd::deque<EntityReplicator*>;
         EntityReplicatorList GenerateEntityUpdateList();
 
         void SendEntityUpdatesPacketHelper(AZ::TimeMs serverGameTimeMs, EntityReplicatorList& toSendList, uint32_t maxPayloadSize, AzNetworking::IConnection& connection);

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

@@ -283,7 +283,7 @@ namespace Multiplayer
             AZ_Assert(netBindComponent, "No Multiplayer::NetBindComponent");
 
             bool isAuthority = (GetBoundLocalNetworkRole() == NetEntityRole::Authority)
-                                  && (GetBoundLocalNetworkRole() == netBindComponent->GetNetEntityRole());
+                            && (GetBoundLocalNetworkRole() == netBindComponent->GetNetEntityRole());
             bool isClient = GetRemoteNetworkRole() == NetEntityRole::Client;
             bool isAutonomous = GetBoundLocalNetworkRole() == NetEntityRole::Autonomous;
             if (isAuthority || isClient || isAutonomous)
@@ -311,9 +311,9 @@ namespace Multiplayer
     {
         bool ret(false);
         bool isServer = (GetBoundLocalNetworkRole() == NetEntityRole::Server)
-                               && (GetRemoteNetworkRole() == NetEntityRole::Authority);
+                     && (GetRemoteNetworkRole() == NetEntityRole::Authority);
         bool isClient = (GetBoundLocalNetworkRole() == NetEntityRole::Client)
-                               || (GetBoundLocalNetworkRole() == NetEntityRole::Autonomous);
+                     || (GetBoundLocalNetworkRole() == NetEntityRole::Autonomous);
         if (isServer || isClient)
         {
             ret = true;

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

@@ -12,6 +12,7 @@
 
 #include <Source/NetworkEntity/NetworkEntityManager.h>
 #include <Source/Components/NetBindComponent.h>
+#include <Include/IMultiplayer.h>
 #include <AzCore/Interface/Interface.h>
 #include <AzCore/Console/IConsole.h>
 #include <AzCore/Console/ILogger.h>
@@ -34,6 +35,12 @@ namespace Multiplayer
         , m_entityRemovedEventHandler([this](AZ::Entity* entity) { OnEntityRemoved(entity); })
     {
         AZ::Interface<INetworkEntityManager>::Register(this);
+        if (AZ::Interface<AZ::ComponentApplicationRequests>::Get() != nullptr)
+        {
+            // Null guard needed for unit tests
+            AZ::Interface<AZ::ComponentApplicationRequests>::Get()->RegisterEntityAddedEventHandler(m_entityAddedEventHandler);
+            AZ::Interface<AZ::ComponentApplicationRequests>::Get()->RegisterEntityRemovedEventHandler(m_entityRemovedEventHandler);
+        }
     }
 
     NetworkEntityManager::~NetworkEntityManager()
@@ -43,13 +50,6 @@ namespace Multiplayer
 
     void NetworkEntityManager::Initialize(HostId hostId, AZStd::unique_ptr<IEntityDomain> entityDomain)
     {
-        if (AZ::Interface<AZ::ComponentApplicationRequests>::Get() != nullptr)
-        {
-            // Null guard needed for unit tests
-            AZ::Interface<AZ::ComponentApplicationRequests>::Get()->RegisterEntityAddedEventHandler(m_entityAddedEventHandler);
-            AZ::Interface<AZ::ComponentApplicationRequests>::Get()->RegisterEntityRemovedEventHandler(m_entityRemovedEventHandler);
-        }
-
         m_hostId = hostId;
         m_entityDomain = AZStd::move(entityDomain);
         m_updateEntityDomainEvent.Enqueue(net_EntityDomainUpdateMs, true);
@@ -282,8 +282,13 @@ namespace Multiplayer
         NetBindComponent* netBindComponent = entity->FindComponent<NetBindComponent>();
         if (netBindComponent != nullptr)
         {
+            // @pereslav
+            // Note that this is a total hack.. we should not be listening to this event on a client
+            // Entities should instead be spawned by the prefabEntityId inside EntityReplicationManager::HandlePropertyChangeMessage()
+            const bool isClient = AZ::Interface<IMultiplayer>::Get()->GetAgentType() == MultiplayerAgentType::Client;
+            const NetEntityRole netEntityRole = isClient ? NetEntityRole::Client: NetEntityRole::Authority;
             const NetEntityId netEntityId = m_nextEntityId++;
-            netBindComponent->PreInit(entity, PrefabEntityId(), netEntityId, NetEntityRole::Authority);
+            netBindComponent->PreInit(entity, PrefabEntityId(), netEntityId, netEntityRole);
         }
     }
 

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

@@ -73,7 +73,7 @@ namespace Multiplayer
     template <typename BASE_TYPE, AZStd::size_t REWIND_SIZE>
     inline BASE_TYPE& RewindableObject<BASE_TYPE, REWIND_SIZE>::Modify()
     {
-        ApplicationFrameId frameTime = GetCurrentTimeForProperty();
+        const ApplicationFrameId frameTime = GetCurrentTimeForProperty();
         if (frameTime < m_headTime)
         {
             AZ_Assert(false, "Trying to mutate a rewindable in the past");
@@ -82,7 +82,7 @@ namespace Multiplayer
         {
             SetValueForTime(GetValueForTime(frameTime), frameTime);
         }
-        const BASE_TYPE& returnValue = GetValueForTime(GetCurrentTimeForProperty());
+        const BASE_TYPE& returnValue = GetValueForTime(frameTime);
         return const_cast<BASE_TYPE&>(returnValue);
     }
 
@@ -103,10 +103,11 @@ namespace Multiplayer
     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))
+        const ApplicationFrameId frameTime = GetCurrentTimeForProperty();
+        BASE_TYPE value = GetValueForTime(frameTime);
+        if (serializer.Serialize(value, "Element") && (serializer.GetSerializerMode() == AzNetworking::SerializerMode::WriteToObject))
         {
-            SetValueForTime(current, GetCurrentTimeForProperty());
+            SetValueForTime(value, frameTime);
         }
         return serializer.IsValid();
     }

Gems/Multiplayer/Code/Source/ReplicationWindows/NullReplicationWindow.cpp

@@ -0,0 +1,47 @@
+/*
+* 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 "NullReplicationWindow.h"
+
+namespace Multiplayer
+{
+    bool NullReplicationWindow::ReplicationSetUpdateReady()
+    {
+        return true;
+    }
+
+    const ReplicationSet& NullReplicationWindow::GetReplicationSet() const
+    {
+        return m_emptySet;
+    }
+
+    uint32_t NullReplicationWindow::GetMaxEntityReplicatorSendCount() const
+    {
+        return 0;
+    }
+
+    bool NullReplicationWindow::IsInWindow([[maybe_unused]] const ConstNetworkEntityHandle& entityHandle, NetEntityRole& outNetworkRole) const
+    {
+        outNetworkRole = NetEntityRole::InvalidRole;
+        return false;
+    }
+
+    void NullReplicationWindow::UpdateWindow()
+    {
+        ;
+    }
+
+    void NullReplicationWindow::DebugDraw() const
+    {
+        // Nothing to draw
+    }
+}

Gems/Multiplayer/Code/Source/ReplicationWindows/NullReplicationWindow.h

@@ -0,0 +1,38 @@
+/*
+* 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/ReplicationWindows/IReplicationWindow.h>
+
+namespace Multiplayer
+{
+    class NullReplicationWindow
+        : public IReplicationWindow
+    {
+    public:
+        NullReplicationWindow() = default;
+
+        //! IReplicationWindow interface
+        //! @{
+        bool ReplicationSetUpdateReady() override;
+        const ReplicationSet& GetReplicationSet() const override;
+        uint32_t GetMaxEntityReplicatorSendCount() const override;
+        bool IsInWindow(const ConstNetworkEntityHandle& entityPtr, NetEntityRole& outNetworkRole) const override;
+        void UpdateWindow() override;
+        void DebugDraw() const override;
+        //! @}
+
+    private:
+        ReplicationSet m_emptySet;
+    };
+}

Gems/Multiplayer/Code/Source/ReplicationWindows/ServerToClientReplicationWindow.cpp

@@ -202,8 +202,7 @@ namespace Multiplayer
 
     void ServerToClientReplicationWindow::OnEntityActivated(const AZ::EntityId& entityId)
     {
-        AZ::Entity* entity = nullptr;
-        EBUS_EVENT_RESULT(entity, AZ::ComponentApplicationBus, FindEntity, entityId);
+        AZ::Entity* entity = AZ::Interface<AZ::ComponentApplicationRequests>::Get()->FindEntity(entityId);
 
         ConstNetworkEntityHandle entityHandle(entity, GetNetworkEntityTracker());
         NetBindComponent* netBindComponent = entityHandle.GetNetBindComponent();
@@ -234,8 +233,7 @@ namespace Multiplayer
 
     void ServerToClientReplicationWindow::OnEntityDeactivated(const AZ::EntityId& entityId)
     {
-        AZ::Entity* entity = nullptr;
-        EBUS_EVENT_RESULT(entity, AZ::ComponentApplicationBus, FindEntity, entityId);
+        AZ::Entity* entity = AZ::Interface<AZ::ComponentApplicationRequests>::Get()->FindEntity(entityId);
 
         ConstNetworkEntityHandle entityHandle(entity, GetNetworkEntityTracker());
         NetBindComponent* netBindComponent = entityHandle.GetNetBindComponent();

Gems/Multiplayer/Code/multiplayer_files.cmake

@@ -34,6 +34,9 @@ set(FILES
     Source/Components/NetBindComponent.h
     Source/Components/NetworkTransformComponent.cpp
     Source/Components/NetworkTransformComponent.h
+    Source/ConnectionData/ClientToServerConnectionData.cpp
+    Source/ConnectionData/ClientToServerConnectionData.h
+    Source/ConnectionData/ClientToServerConnectionData.inl
     Source/ConnectionData/IConnectionData.h
     Source/ConnectionData/ServerToClientConnectionData.cpp
     Source/ConnectionData/ServerToClientConnectionData.h
@@ -81,6 +84,8 @@ set(FILES
     Source/NetworkTime/NetworkTime.h
     Source/NetworkTime/RewindableObject.h
     Source/NetworkTime/RewindableObject.inl
+    Source/ReplicationWindows/NullReplicationWindow.cpp
+    Source/ReplicationWindows/NullReplicationWindow.h
     Source/ReplicationWindows/IReplicationWindow.h
     Source/ReplicationWindows/ServerToClientReplicationWindow.cpp
     Source/ReplicationWindows/ServerToClientReplicationWindow.h