InScenePlaced NetworkObjects Change in Behaviour

[TjDMC]

Description

Not sure if this is a bug or a feature request.

For context, my game features a play session that you can start offline and then later share online if you want to. I'm using enableSceneManagement=false.

NetworkObjects instantiated prior to calling NetworkManager.StartHost() used to count as in-scene-placed netObjs before NGO 2.13. This means that starting the server would automatically spawn these objects. With the recent update however, this is no longer true. You now have to manually spawn these netObjs. That's fine, I can work with that.

The problem is that netObjs that have been parented prior to starting the server no longer retains their parent-child relationship. This is a bit more problematic for my game.

Reproduce Steps

    internal class InScenePlacedObjectsTests : NetcodeIntegrationTest {
        protected override int NumberOfClients => 0;

        NetworkObject prefab;

        protected override bool CanStartServerAndClients() {
            return false;
        }

        protected override void OnServerAndClientsCreated() {
            base.OnServerAndClientsCreated();

            prefab = NetcodeIntegrationTestHelpers.CreateNetworkObjectPrefab(
                "prefab",
                m_ServerNetworkManager
            ).GetComponent<NetworkObject>();

            m_ServerNetworkManager.NetworkConfig.PlayerPrefab = null;
            m_ServerNetworkManager.NetworkConfig.EnableSceneManagement = false;
            m_ServerNetworkManager.LogLevel = LogLevel.Developer;
        }

        [UnityTest]
        public IEnumerator SceneManagementOffSpawningAfter() {
            var parent = Object.Instantiate(prefab).GetComponent<NetworkObject>();
            var child = Object.Instantiate(prefab, parent.gameObject.transform).GetComponent<NetworkObject>();

            m_ServerNetworkManager.StartHost();
            yield return null;

#if NGO_2_13_OR_NEWER //custom preprocessor that just checks for ngo version
            parent.Spawn();
            child.Spawn();
            yield return null;
#else
            Assert.IsTrue(parent.IsSpawned && parent.IsSceneObject == true);
            Assert.IsTrue(child.IsSpawned && child.IsSceneObject == true);
#endif

            //NetworkObject.CurrentParent is null even if NetworkObject.SetSceneObjectStatus(true) is called prior to spawning/starting network session
            Assert.IsTrue(child.transform.parent == parent.transform);

            yield return null;
        }

        protected override IEnumerator OnTearDown() {
            Object.DestroyImmediate(prefab.gameObject);
            return base.OnTearDown();
        }
    }

Outcome

The test works in NGO 2.12, but fails in 2.13

Environment

• Unity Version: 6000.3.16f1
• Netcode Version: 2.13
• Netcode Topology: Client-Server

Additional Context

I guess I'm looking for a feature/bug fix that can support my use case.

I thought about using SinglePlayerTransport, but if I have to share the play session online, I would presumably have to shutdown the server, which would destroy all my NetworkObjects, and reconnect using the real transport. I want to avoid having to go back to the main menu and start the play session as an online-session.

[NoelStephensUnity]

@TjDMC
Not sure if you found your answer elsewhere, but we didn't have any specific location in our documentation that discusses using SinglePlayerTransport with a working example and so I put together PR #4062 that will update our documentation to include a single player session section under the configuration category.

Where the example code provided is a simple example of how to switch from a single player session to a multiplayer session:

using Unity.Netcode;
using Unity.Netcode.Transports.SinglePlayer;
using Unity.Netcode.Transports.UTP;

/// <summary>
/// Example of how to start a single player or multiplayer session.
/// </summary>
public class ExtendedNetworkManager : NetworkManager
{
    public enum StartType
    {
        SinglePlayer,
        Client,
        Host,
        Server
    }

    private UnityTransport m_UnityTransport;
    private SinglePlayerTransport m_SinglePlayerTransport;

    private void Awake()
    {
        m_UnityTransport = GetComponent<UnityTransport>();
        m_SinglePlayerTransport = GetComponent<SinglePlayerTransport>();
    }

    public bool StartSession(StartType startType)
    {
        var startStatus = false;
        NetworkConfig.NetworkTransport = startType == StartType.SinglePlayer ? m_SinglePlayerTransport : m_UnityTransport;
        switch (startType)
        {
            case StartType.Host:
            case StartType.SinglePlayer:
                {
                    startStatus = StartHost();
                    break;
                }
            case StartType.Server:
                {
                    startStatus = StartServer();
                    break;
                }
            case StartType.Client:
                {
                    startStatus = StartClient();
                    break;
                }
        }
        return startStatus;
    }
}

[TjDMC]

I was able to solve my problem by just reparenting every instantiated NetworkObjects on server start.

Anyways, thanks for the documentation update! However, what I wanted was a way to transition an active singeplayer session (that is using SinglePlayerTransport) to a multiplayer session (that is using UnityTransport) WITHOUT shutting down the server and consequently destroying all spawned NetworkObjects.

E.g. From the main menu, player starts an offline play session. Later on, they decide to share this session online. They should be able to do this by just pressing a button in the pause menu, and NOT by shutting down the play session, going back to the main menu, and restarting the session as an online multiplayer session.

Right now, I'm able to accomplish this by not starting the server during a play session, but rather just working with instantiated (but unspawned) NetworkObjects. However, I have to constantly check my NGO api calls to make sure I don't call a method/property that only works when there is an active network session.