Unity-Technologies
diff --git a/‎com.unity.netcode.gameobjects/Editor/NetworkObjectEditor.cs‎
Lines changed: 3 additions & 0 deletions b/‎com.unity.netcode.gameobjects/Editor/NetworkObjectEditor.cs‎
Lines changed: 3 additions & 0 deletions
diff --git a/‎com.unity.netcode.gameobjects/Editor/Unity.Netcode.Editor.asmdef‎
Lines changed: 12 additions & 1 deletion b/‎com.unity.netcode.gameobjects/Editor/Unity.Netcode.Editor.asmdef‎
Lines changed: 12 additions & 1 deletion
diff --git a/‎com.unity.netcode.gameobjects/Runtime/Components/Helpers/NetworkObjectBridge.cs‎
Lines changed: 72 additions & 0 deletions b/‎com.unity.netcode.gameobjects/Runtime/Components/Helpers/NetworkObjectBridge.cs‎
Lines changed: 72 additions & 0 deletions
diff --git a/‎com.unity.netcode.gameobjects/Runtime/Components/Helpers/NetworkObjectBridge.cs.meta‎
Lines changed: 11 additions & 0 deletions b/‎com.unity.netcode.gameobjects/Runtime/Components/Helpers/NetworkObjectBridge.cs.meta‎
Lines changed: 11 additions & 0 deletions
diff --git a/‎com.unity.netcode.gameobjects/Runtime/Components/Helpers/UnifiedBootstrap.cs‎
Lines changed: 95 additions & 0 deletions b/‎com.unity.netcode.gameobjects/Runtime/Components/Helpers/UnifiedBootstrap.cs‎
Lines changed: 95 additions & 0 deletions
diff --git a/‎com.unity.netcode.gameobjects/Runtime/Components/Helpers/UnifiedBootstrap.cs.meta‎
Lines changed: 2 additions & 0 deletions b/‎com.unity.netcode.gameobjects/Runtime/Components/Helpers/UnifiedBootstrap.cs.meta‎
Lines changed: 2 additions & 0 deletions
diff --git a/‎com.unity.netcode.gameobjects/Runtime/Components/Helpers/UnifiedUpdateConnections.cs‎
Lines changed: 129 additions & 0 deletions b/‎com.unity.netcode.gameobjects/Runtime/Components/Helpers/UnifiedUpdateConnections.cs‎
Lines changed: 129 additions & 0 deletions
diff --git a/‎com.unity.netcode.gameobjects/Runtime/Components/Helpers/UnifiedUpdateConnections.cs.meta‎
Lines changed: 2 additions & 0 deletions b/‎com.unity.netcode.gameobjects/Runtime/Components/Helpers/UnifiedUpdateConnections.cs.meta‎
Lines changed: 2 additions & 0 deletions
@@ -32,6 +32,9 @@ private void Initialize()
 
             m_Initialized = true;
             m_NetworkObject = (NetworkObject)target;
+#if UNIFIED_NETCODE
+            m_NetworkObject.UnifiedValidation();
+#endif
         }
 
         /// <inheritdoc/>
 
@@ -7,7 +7,8 @@
         "Unity.Services.Relay",
         "Unity.Networking.Transport",
         "Unity.Services.Core",
-        "Unity.Services.Authentication"
+        "Unity.Services.Authentication",
+        "Unity.NetCode"
     ],
     "includePlatforms": [
         "Editor"
@@ -43,6 +44,16 @@
             "name": "com.unity.services.multiplayer",
             "expression": "0.2.0",
             "define": "MULTIPLAYER_SERVICES_SDK_INSTALLED"
+        },
+        {
+            "name": "com.unity.netcode",
+            "expression": "1.10.1",
+            "define": "UNIFIED_NETCODE"
+        },
+        {
+            "name": "com.unity.multiplayer.playmode",
+            "expression": "0.1.0",
+            "define": "UNITY_MULTIPLAYER_PLAYMODE"
         }
     ],
     "noEngineReferences": false
 
@@ -0,0 +1,72 @@
+#if UNIFIED_NETCODE
+using Unity.NetCode;
+#if UNITY_EDITOR
+using UnityEditor;
+#endif
+using UnityEngine;
+
+namespace Unity.Netcode
+{
+    /// <summary>
+    /// TODO-UNIFIED: Needs further peer review and exploring alternate ways of handling this.
+    /// This is a component that is added to the root of all N4E-spawned hybrid prefab instances. It is used to link
+    /// <see cref="NetworkObject.SerializedObject"/> the N4E-spawned hybrid prefab instances to the incoming <see cref="CreateObjectMessage"/>
+    /// specific to the N4E-spawned hybrid prefab instance that has the matching <see cref="NetworkObjectId"/>.
+    /// </summary>
+    public partial class NetworkObjectBridge : GhostBehaviour
+    {
+#if UNITY_EDITOR
+        [HideInInspector]
+        [SerializeField]
+        private bool m_Sorted = false;
+        private void OnValidate()
+        {
+            // TODO-UNIFIED: GhostAdapter must be above all GhostBehaviours in order to assure the GhostAdapter is initialized before any GhostBehaviour.
+            // This auto-sorting is required because the GhostBehaviours rely on the GhostAdapter.Awake being invoked before any GhostBehaviour.Awake.
+            if (!m_Sorted && !EditorApplication.isPlaying)
+            {
+                while (UnityEditorInternal.ComponentUtility.MoveComponentUp(this))
+                {
+                    // Keep moving until it can't go higher
+                }
+                var ghostAdapter = gameObject.GetComponent<GhostAdapter>();
+                // Now move the GhostAdapter to the top so it is above NetworkObjectBridge
+                while (ghostAdapter != null && UnityEditorInternal.ComponentUtility.MoveComponentUp(ghostAdapter))
+                {
+                    // Keep moving until it can't go higher
+                }
+
+                m_Sorted = true;
+            }
+        }
+#endif
+
+        /// <summary>
+        /// This is used to link <see cref="NetworkObject.SerializedObject"/> data to
+        /// N4E-spawned hybrid prefab instances.
+        /// </summary>
+        internal GhostField<ulong> NetworkObjectId = new GhostField<ulong>();
+        public void SetNetworkObjectId(ulong networkObjectId)
+        {
+            NetworkObjectId.PresetValue(networkObjectId);
+            NetworkObjectId.Value = networkObjectId;
+        }
+
+        /// <summary>
+        /// Currently, NGO provides the parenting event handling via <see cref="ParentSyncMessage"/>.
+        /// Once <see cref="GhostField{InternalTypeT}"/> can provide a form of event notification that
+        /// the value has changed, we can then invert this flow such that the change in the parent value
+        /// drives the event.
+        /// </summary>
+        /// <param name="scale">We use NGO scale, delivered via ParentSyncMessage, that is applied to this
+        /// instance's entity's PostTransformMatrix.</param>
+        internal void HybridParentUpdate(Vector3 scale)
+        {
+            var current = Ghost.GetPositionAndRotation();
+            //Debug.Log($"---- Current LT: {current.Position} | {current.Rotation.eulerAngles}");
+            //Debug.Log($"---- New LT: {transform.localPosition} | {transform.localRotation}");
+            Ghost.ApplyPostTransformMatrixScale(scale);
+        }
+    }
+}
+#endif
@@ -0,0 +1,95 @@
+#if UNIFIED_NETCODE
+using System;
+using Unity.Entities;
+using Unity.NetCode;
+using UnityEngine;
+
+namespace Unity.Netcode
+{
+    /// <summary>
+    /// TODO-UNIFIED: Needs furthery review and proper error messaging using the new logging context.
+    /// Handles the bootstrap process for both client and server in unified mode. This is used to create the world and set it on the
+    /// NetworkManager during initialization.
+    /// </summary>
+    internal class UnifiedBootstrap : ClientServerBootstrap
+    {
+        public static UnifiedBootstrap Instance { get; private set; }
+        public static Action OnInitialized;
+        public static ushort Port = 7979;
+        public static NetworkManager CurrentNetworkManagerForInitialization;
+
+        public static World LastCreatedWorld { get; private set; }
+
+        private static int s_WorldCounter = 0;
+
+        public override bool Initialize(string defaultWorldName)
+        {
+            var networkManager = CurrentNetworkManagerForInitialization;
+            if (networkManager == NetworkManager.Singleton)
+            {
+                Instance = this;
+            }
+
+            AutoConnectPort = Port;
+            if (base.Initialize(defaultWorldName))
+            {
+                Debug.LogError($"[{nameof(UnifiedBootstrap)}] Auto-bootstrap is enabled!!! This will break the POC!");
+                return true;
+            }
+
+            if (networkManager != null)
+            {
+                Debug.Log($"Starting a world for {(networkManager.IsServer ? "Host" : "Client")}");
+                s_WorldCounter++;
+                LastCreatedWorld = networkManager.IsServer ? CreateSingleWorldHost($"HostSingleWorld-{s_WorldCounter}")
+                    : CreateClientWorld($"ClientWorld-{s_WorldCounter}");
+
+                if (LastCreatedWorld == null)
+                {
+                    s_WorldCounter--;
+                    Debug.LogError($"[{nameof(UnifiedBootstrap)}] World is null!");
+                    return false;
+                }
+
+                if (!LastCreatedWorld.IsCreated)
+                {
+                    s_WorldCounter--;
+                    Debug.LogError($"[{nameof(UnifiedBootstrap)}] World was not created!");
+                    return false;
+                }
+
+                if (networkManager.LogLevel <= LogLevel.Developer)
+                {
+                    NetworkLog.LogInfo($"[{nameof(UnifiedBootstrap)}] Created world: {LastCreatedWorld.Name} / {LastCreatedWorld.SequenceNumber}");
+                }
+
+                networkManager.NetcodeWorld = (NetcodeWorld)LastCreatedWorld;
+#if UNIFIED_NGO_REGISTERS_PREFABS
+                if (networkManager.NetworkConfig.Prefabs.HasPendingGhostPrefabs)
+                {
+                    if (networkManager.LogLevel <= LogLevel.Developer)
+                    {
+                        NetworkLog.LogInfo($"[{nameof(UnifiedBootstrap)}] Registering hybrid prefabs...");
+                    }
+                    networkManager.NetworkConfig.Prefabs.RegisterGhostPrefabs(networkManager);
+                }
+#endif
+            }
+            else
+            {
+                LastCreatedWorld = CreateLocalWorld("LocalWorld");
+            }
+
+            OnInitialized?.Invoke();
+
+            return true;
+        }
+
+        ~UnifiedBootstrap()
+        {
+            LastCreatedWorld = null;
+            Instance = null;
+        }
+    }
+}
+#endif
@@ -0,0 +1,129 @@
+#if UNIFIED_NETCODE
+using System.Collections.Generic;
+using Unity.Collections;
+using Unity.Entities;
+using Unity.NetCode;
+using UnityEngine;
+
+namespace Unity.Netcode.Components
+{
+
+    public struct NetcodeConnection
+    {
+        internal World World;
+        internal Entity Entity;
+        public int NetworkId;
+
+        public bool IsServer => World.IsServer();
+        public void GoInGame()
+        {
+            World.EntityManager.AddComponentData(Entity, default(NetworkStreamInGame));
+        }
+        public void SendMessage<T>(T message) where T : unmanaged, IRpcCommand
+        {
+            var req = World.EntityManager.CreateEntity();
+            World.EntityManager.AddComponentData(req, new SendRpcCommandRequest { TargetConnection = Entity });
+            World.EntityManager.AddComponentData(req, message);
+        }
+    }
+
+    internal partial class UnifiedUpdateConnections : SystemBase
+    {
+        private List<NetcodeConnection> m_TempConnections = new List<NetcodeConnection>();
+
+        private Dictionary<int, NetcodeConnection> m_NewConnections = new Dictionary<int, NetcodeConnection>();
+
+        protected override void OnUpdate()
+        {
+            var isServer = World.IsServer();
+            var commandBuffer = new EntityCommandBuffer(Allocator.Temp);
+            foreach (var networkManager in Object.FindObjectsByType<NetworkManager>())
+            {
+                foreach (var (networkId, connectionState, entity) in SystemAPI.Query<NetworkId, ConnectionState>().WithNone<NetworkStreamConnection>().WithEntityAccess())
+                {
+                    commandBuffer.RemoveComponent<ConnectionState>(entity);
+                    m_TempConnections.Add(new NetcodeConnection
+                    {
+                        World = World,
+                        Entity = entity,
+                        NetworkId = networkId.Value
+                    });
+                }
+
+                foreach (var con in m_TempConnections)
+                {
+                    NetworkManager.OnNetCodeDisconnect?.Invoke(con);
+                }
+
+                m_TempConnections.Clear();
+
+                // TODO: We should figure out how to associate the N4E NetworkId with the NGO ClientId
+                foreach (var (networkId, entity) in SystemAPI.Query<NetworkId>().WithAll<NetworkStreamConnection>()
+                             .WithNone<NetworkStreamInGame>().WithEntityAccess())
+                {
+                    if (!m_NewConnections.ContainsKey(networkId.Value))
+                    {
+                        var newConnection = new NetcodeConnection
+                        { World = World, Entity = entity, NetworkId = networkId.Value };
+                        m_NewConnections.Add(networkId.Value, newConnection);
+                    }
+                }
+
+                // If we have any pending connections
+                if (m_NewConnections.Count > 0)
+                {
+                    foreach (var entry in m_NewConnections)
+                    {
+                        // Server: always connect
+                        // Client: wait until we have synchronized before announcing we are ready to receive snapshots
+                        if (networkManager.IsServer || (!networkManager.IsServer && networkManager.IsConnectedClient))
+                        {
+                            // Set the connection in-game
+                            commandBuffer.AddComponent<NetworkStreamInGame>(entry.Value.Entity);
+                            commandBuffer.AddComponent(entry.Value.Entity, default(ConnectionState));
+                            NetworkManager.OnNetCodeConnect?.Invoke(entry.Value);
+                            m_TempConnections.Add(entry.Value);
+                        }
+                    }
+
+                    // Remove any connections that have "gone in-game".
+                    foreach (var connection in m_TempConnections)
+                    {
+                        m_NewConnections.Remove(connection.NetworkId);
+                    }
+                }
+
+                m_TempConnections.Clear();
+
+                // If the local NetworkManager is shutting down or no longer connected, then
+                // make sure we have disconnected all known connections.
+                if (networkManager.ShutdownInProgress || !networkManager.IsListening)
+                {
+                    foreach (var (networkId, entity) in SystemAPI.Query<NetworkId>().WithEntityAccess())
+                    {
+                        commandBuffer.RemoveComponent<ConnectionState>(entity);
+                        NetworkManager.OnNetCodeDisconnect?.Invoke(new NetcodeConnection
+                        { World = World, Entity = entity, NetworkId = networkId.Value });
+                    }
+                }
+            }
+            commandBuffer.Playback(EntityManager);
+        }
+
+        /// <summary>
+        /// Always disconnect all known connections when being destroyed.
+        /// </summary>
+        protected override void OnDestroy()
+        {
+            var commandBuffer = new EntityCommandBuffer(Allocator.Temp);
+            foreach (var (networkId, entity) in SystemAPI.Query<NetworkId>().WithEntityAccess())
+            {
+                commandBuffer.RemoveComponent<ConnectionState>(entity);
+                NetworkManager.OnNetCodeDisconnect?.Invoke(new NetcodeConnection { World = World, Entity = entity, NetworkId = networkId.Value });
+            }
+            commandBuffer.Playback(EntityManager);
+            base.OnDestroy();
+        }
+    }
+}
+#endif
Original file line number	Diff line number	Diff line change
`@@ -32,6 +32,9 @@ private void Initialize()`
`32`	`32`
`33`	`33`	`m_Initialized = true;`
`34`	`34`	`m_NetworkObject = (NetworkObject)target;`
	`35`	`+#if UNIFIED_NETCODE`
	`36`	`+ m_NetworkObject.UnifiedValidation();`
	`37`	`+#endif`
`35`	`38`	`}`
`36`	`39`
`37`	`40`	`/// <inheritdoc/>`