public void OnPlayAgainClicked()
{
// this should only ever be called by the Host - so just go ahead and switch scenes
NetworkSceneManager.SwitchScene("CharSelect");
// FUTURE: could be improved to better support a dedicated server architecture
}
void ParseForServerMode()
{
if (string.IsNullOrEmpty(GetArg("-server")))
{
return;
}
GameObject serverGo = Instantiate(ServerPrefab);
serverGo.name = "Server";
server = serverGo.GetComponent <NetworkServer>();
server.MaxConnections = 9999;
server.SocketFactory = socketFactory;
serverObjectManager = serverGo.GetComponent <ServerObjectManager>();
NetworkSceneManager networkSceneManager = serverGo.GetComponent <NetworkSceneManager>();
networkSceneManager.Server = server;
serverObjectManager.Server = server;
serverObjectManager.NetworkSceneManager = networkSceneManager;
serverObjectManager.Start();
CharacterSpawner spawner = serverGo.GetComponent <CharacterSpawner>();
spawner.ServerObjectManager = serverObjectManager;
spawner.Server = server;
server.Started.AddListener(OnServerStarted);
server.Authenticated.AddListener(conn => serverObjectManager.SpawnVisibleObjects(conn, true));
server.StartServer();
Console.WriteLine("Starting Server Only Mode");
}
void StartClient(int i, string networkAddress)
{
GameObject clientGo = Instantiate(ClientPrefab);
clientGo.name = $"Client {i}";
NetworkClient client = clientGo.GetComponent <NetworkClient>();
ClientObjectManager objectManager = clientGo.GetComponent <ClientObjectManager>();
CharacterSpawner spawner = clientGo.GetComponent <CharacterSpawner>();
NetworkSceneManager networkSceneManager = clientGo.GetComponent <NetworkSceneManager>();
networkSceneManager.Client = client;
objectManager.Client = client;
objectManager.NetworkSceneManager = networkSceneManager;
objectManager.Start();
objectManager.RegisterPrefab(MonsterPrefab.GetComponent <NetworkIdentity>());
objectManager.RegisterPrefab(PlayerPrefab.GetComponent <NetworkIdentity>());
spawner.Client = client;
spawner.PlayerPrefab = PlayerPrefab.GetComponent <NetworkIdentity>();
spawner.ClientObjectManager = objectManager;
spawner.SceneManager = networkSceneManager;
client.SocketFactory = socketFactory;
try
{
client.Connect(networkAddress);
}
catch (Exception ex)
{
Debug.LogException(ex);
}
}
void ParseForServerMode()
{
if (!string.IsNullOrEmpty(GetArg("-server")))
{
var serverGo = new GameObject($"Server", typeof(NetworkServer), typeof(ServerObjectManager), typeof(NetworkSceneManager), typeof(PlayerSpawner));
server = serverGo.GetComponent <NetworkServer>();
server.MaxConnections = 9999;
server.Transport = transport;
serverObjectManager = serverGo.GetComponent <ServerObjectManager>();
NetworkSceneManager networkSceneManager = serverGo.GetComponent <NetworkSceneManager>();
networkSceneManager.Server = server;
serverObjectManager.Server = server;
serverObjectManager.NetworkSceneManager = networkSceneManager;
serverObjectManager.Start();
PlayerSpawner spawner = serverGo.GetComponent <PlayerSpawner>();
spawner.PlayerPrefab = PlayerPrefab.GetComponent <NetworkIdentity>();
spawner.ServerObjectManager = serverObjectManager;
spawner.Server = server;
server.Started.AddListener(OnServerStarted);
server.Authenticated.AddListener(conn => serverObjectManager.SetClientReady(conn));
_ = server.ListenAsync();
Console.WriteLine("Starting Server Only Mode");
}
}
async UniTask StartClient(int i, string networkAddress)
{
var clientGo = new GameObject($"Client {i}", typeof(NetworkClient), typeof(ClientObjectManager), typeof(PlayerSpawner), typeof(NetworkSceneManager));
NetworkClient client = clientGo.GetComponent <NetworkClient>();
ClientObjectManager objectManager = clientGo.GetComponent <ClientObjectManager>();
PlayerSpawner spawner = clientGo.GetComponent <PlayerSpawner>();
NetworkSceneManager networkSceneManager = clientGo.GetComponent <NetworkSceneManager>();
networkSceneManager.Client = client;
objectManager.Client = client;
objectManager.NetworkSceneManager = networkSceneManager;
objectManager.Start();
objectManager.RegisterPrefab(MonsterPrefab.GetComponent <NetworkIdentity>());
objectManager.RegisterPrefab(PlayerPrefab.GetComponent <NetworkIdentity>());
spawner.Client = client;
spawner.PlayerPrefab = PlayerPrefab.GetComponent <NetworkIdentity>();
spawner.ClientObjectManager = objectManager;
spawner.SceneManager = networkSceneManager;
client.Transport = transport;
try
{
await client.ConnectAsync(networkAddress);
}
catch (Exception ex)
{
Debug.LogException(ex);
}
}
public void Setup()
{
go = new GameObject();
client = go.AddComponent <NetworkClient>();
server = go.AddComponent <NetworkServer>();
spawner = go.AddComponent <CharacterSpawner>();
sceneManager = go.AddComponent <NetworkSceneManager>();
serverObjectManager = go.AddComponent <ServerObjectManager>();
clientObjectManager = go.AddComponent <ClientObjectManager>();
spawner.SceneManager = sceneManager;
sceneManager.Client = client;
sceneManager.Server = server;
serverObjectManager.Server = server;
clientObjectManager.Client = client;
clientObjectManager.NetworkSceneManager = sceneManager;
spawner.Client = client;
spawner.Server = server;
spawner.ServerObjectManager = serverObjectManager;
spawner.ClientObjectManager = clientObjectManager;
playerPrefab = new GameObject();
NetworkIdentity playerId = playerPrefab.AddComponent <NetworkIdentity>();
spawner.PlayerPrefab = playerId;
pos1 = new GameObject().transform;
pos2 = new GameObject().transform;
spawner.startPositions.Add(pos1);
spawner.startPositions.Add(pos2);
}
public IEnumerator SetupHost() => UniTask.ToCoroutine(async() =>
{
networkManagerGo = new GameObject();
networkManagerGo.AddComponent <MockTransport>();
sceneManager = networkManagerGo.AddComponent <NetworkSceneManager>();
serverObjectManager = networkManagerGo.AddComponent <ServerObjectManager>();
clientObjectManager = networkManagerGo.AddComponent <ClientObjectManager>();
manager = networkManagerGo.AddComponent <NetworkManager>();
manager.client = networkManagerGo.GetComponent <NetworkClient>();
manager.server = networkManagerGo.GetComponent <NetworkServer>();
server = manager.server;
client = manager.client;
sceneManager.client = client;
sceneManager.server = server;
serverObjectManager.server = server;
serverObjectManager.networkSceneManager = sceneManager;
clientObjectManager.client = client;
clientObjectManager.networkSceneManager = sceneManager;
ExtraSetup();
// wait for all Start() methods to get invoked
await UniTask.DelayFrame(1);
await StartHost();
playerGO = new GameObject("playerGO", typeof(Rigidbody));
identity = playerGO.AddComponent <NetworkIdentity>();
component = playerGO.AddComponent <T>();
serverObjectManager.AddPlayerForConnection(server.LocalConnection, playerGO);
client.Update();
});
internal static void HandleSwitchScene(uint clientId, Stream stream, int channelId)
{
using (PooledBitReader reader = PooledBitReader.Get(stream))
{
NetworkSceneManager.OnSceneSwitch(reader.ReadUInt32Packed());
}
}
private void CreateServerEnvironment()
{
var progress = NetworkSceneManager.SwitchScene("Ingame");
progress.OnClientLoadedScene += id => {
/*
* var current = 0;
* var bulletsPool = new NetworkedObject[10];
*
* var bulletPrefab = Resources.Load("Prefabs/Bullet");
* for (var i = bulletsPool.Length - 1; i >= 0; i--) {
* bulletsPool[i] = (Instantiate(bulletPrefab, Vector3.zero, Quaternion.identity) as GameObject)?.GetComponent<NetworkedObject>();
* }
*
* SpawnManager.RegisterSpawnHandler(SpawnManager.GetPrefabHashFromGenerator(bulletPrefab.name), (position, rotation) => {
* current = (current + 1) % bulletsPool.Length;
* Debug.Log("Taking bullet number " + current);
* return bulletsPool[current];
* });*/
var asteroidPrefab = Resources.Load("Prefabs/Asteroid");
for (var i = 0; i < 30; i++)
{
var randPosition = new Vector2(Random.Range(-30f, 30f), Random.Range(-20f, 20f));
GameObject asteroid = Instantiate(asteroidPrefab, randPosition, Quaternion.identity) as GameObject;
asteroid.GetComponent <NetworkedObject>().Spawn();
}
};
}
public IEnumerator SetupHost() => RunAsync(async() =>
{
networkManagerGo = new GameObject();
networkManagerGo.AddComponent <MockTransport>();
sceneManager = networkManagerGo.AddComponent <NetworkSceneManager>();
manager = networkManagerGo.AddComponent <NetworkManager>();
manager.client = networkManagerGo.GetComponent <NetworkClient>();
manager.server = networkManagerGo.GetComponent <NetworkServer>();
server = manager.server;
client = manager.client;
sceneManager.client = client;
sceneManager.server = server;
ExtraSetup();
// wait for client and server to initialize themselves
await Task.Delay(1);
// now start the host
await manager.StartHost();
playerGO = new GameObject("playerGO", typeof(Rigidbody));
identity = playerGO.AddComponent <NetworkIdentity>();
component = playerGO.AddComponent <T>();
server.AddPlayerForConnection(server.LocalConnection, playerGO);
client.Update();
});
private void CheckPlayers(ulong client)
{
if (NetworkingManager.Singleton.ConnectedClientsList.Count > 1)
{
NetworkSceneManager.SwitchScene(game);
}
}
internal static void HandleClientSwitchSceneCompleted(uint clientId, Stream stream, int channelId)
{
using (PooledBitReader reader = PooledBitReader.Get(stream))
{
NetworkSceneManager.OnClientSwitchSceneCompleted(clientId, new Guid(reader.ReadByteArray()));
}
}
private void NetworkStart()
{
if (!m_Portal.NetManager.IsServer)
{
enabled = false;
}
else
{
//The "BossRoom" server always advances to CharSelect immediately on start. Different games
//may do this differently.
NetworkSceneManager.SwitchScene("CharSelect");
m_Portal.NetManager.OnClientDisconnectCallback += (ulong clientId) =>
{
m_ClientSceneMap.Remove(clientId);
};
m_Portal.ClientSceneChanged += (ulong clientId, int sceneIndex) =>
{
m_ClientSceneMap[clientId] = sceneIndex;
};
if (m_Portal.NetManager.IsHost)
{
m_ClientSceneMap[m_Portal.NetManager.LocalClientId] = ServerScene;
}
}
}
public void SceneManagerAssigned()
{
var gameObject = new GameObject(nameof(SceneManagerAssigned));
var networkManager = gameObject.AddComponent <NetworkManager>();
var transport = gameObject.AddComponent <DummyTransport>();
// MLAPI sets this in validate
networkManager.NetworkConfig = new NetworkConfig()
{
// Set the current scene to prevent unexpected log messages which would trigger a failure
RegisteredScenes = new List <string>()
{
SceneManager.GetActiveScene().name
}
};
// Set dummy transport that does nothing
networkManager.NetworkConfig.NetworkTransport = transport;
NetworkSceneManager preManager = networkManager.SceneManager;
// Start server to cause init
networkManager.StartServer();
Debug.Assert(preManager == null);
Debug.Assert(networkManager.SceneManager != null);
Object.DestroyImmediate(gameObject);
}
private void CreateServerEnvironment()
{
var progress = NetworkSceneManager.SwitchScene("InteractionScene");
progress.OnClientLoadedScene += id => {
Debug.Log("client " + id + "has changed scene");
};
}
public void LoadNextLevel()
{
_CurrentLevel = _CurrentLevel % 7 + 1;
CBSL.Logging.Logger.Info <NetworkController>($"Switching Scene : Level{_CurrentLevel}");
var progress = NetworkSceneManager.SwitchScene($"Level{_CurrentLevel}");
progress.OnComplete += OnSceneSwitchComplete;
}
void OnNetworkInit()
{
networkSceneManager = NetworkManager.Get().GetModule <NetworkSceneManager>();
networkSceneManager.onClientSceneLoad += OnClientSceneLoad;
networkSceneManager.onClientSceneUnload += OnClientSceneUnload;
networkSceneManager.onServerSceneLoad += OnServerSceneLoad;
networkSceneManager.onServerSceneUnload += OnServerSceneUnload;
}
// Server switches the Scene based on Dropdown selection
public void SwitchScene()
{
// Remove callbacks
NetworkingManager.Singleton.OnClientConnectedCallback -= ConnectionCallbackOnServer;
NetworkingManager.Singleton.OnClientDisconnectCallback -= ConnectionCallbackOnServer;
NetworkSceneManager.SwitchScene(canvas.levelDropdown.captionText.text);
}
internal static void HandleSwitchScene(uint clientId, Stream stream, int channelId)
{
using (PooledBitReader reader = PooledBitReader.Get(stream))
{
uint sceneIndex = reader.ReadUInt32Packed();
Guid switchSceneGuid = new Guid(reader.ReadByteArray());
NetworkSceneManager.OnSceneSwitch(sceneIndex, switchSceneGuid);
}
}
public override void ExtraSetup()
{
sceneManager = networkManagerGo.AddComponent <NetworkSceneManager>();
sceneManager.Client = client;
sceneManager.Server = server;
serverObjectManager.NetworkSceneManager = sceneManager;
clientObjectManager.NetworkSceneManager = sceneManager;
}
void Host(TMP_Dropdown deckC)
{
SC_Player.deckCode = savedData.decks[deckC.options[deckC.value].text];
(NetworkManager.Singleton.NetworkConfig.NetworkTransport as PhotonRealtimeTransport).RoomName = "CFW_Room_" + matchCode.text;
NetworkManager.Singleton.ConnectionApprovalCallback += ApprovalCheck;
NetworkManager.Singleton.StartHost();
NetworkSceneManager.SwitchScene("Play_Scene");
}
static void SubmitNewPosition()
{
if (GUILayout.Button(NetworkManager.Singleton.IsServer ? "Start" : "Waiting for server"))
{
if (NetworkManager.Singleton.IsServer)
{
NetworkSceneManager.SwitchScene("SampleScene");
}
}
}
public void HostAndPlay()
{
NetworkingManager.Singleton.ConnectionApprovalCallback += ApprovalCheck;
NetworkingManager.Singleton.StartHost();
StartListenForDownloadRequests();
NetworkSceneManager.SwitchScene("Game");
CloseLobbyScreen();
}
public void Host()
{
string str = "";
for (int i = 0; i < 6; i++)
{
str += (char)Random.Range(65, 90);
}
transport.RoomName = str;
NetworkManager.Singleton.StartHost();
NetworkSceneManager.SwitchScene("Game");
}
private void SwitchToNextScene()
{
m_ActiveScene = SceneManager.GetActiveScene();
var sceneIndex = NetworkManager.Singleton.NetworkConfig.RegisteredScenes.FindIndex(FindCurrentScene);
sceneIndex++;
if (sceneIndex >= NetworkManager.Singleton.NetworkConfig.RegisteredScenes.Count)
{
sceneIndex = 0;
}
NetworkSceneManager.SwitchScene(NetworkManager.Singleton.NetworkConfig.RegisteredScenes[sceneIndex]);
}
/// <summary>
/// Load the next game floor
/// Currently loads the same level until the floorsUntiGameOver limit is reached
/// Once the limit is reached, proceeds to gameOver scene
/// </summary>
public void LoadNextFloor()
{
if (NetworkingManager.Singleton.IsHost || NetworkingManager.Singleton.IsServer)
{
if (!IsNetworkedGameStateReady())
{
Debug.LogError("Tried to load the next floor when the networked game state is not ready");
return;
}
if (SceneManager.GetActiveScene().name == "Menu")
{
dataRecorder.ResetData();
dataRecorder.StartSession(networkedGameState);
}
StopListeningForControllers();
int nextFloor = networkedGameState.GetCurrentFloor() + 1;
string sceneToLoad;
//Set the next scene based on nextFloor value
if (SceneManager.GetActiveScene().name != "ElevatorInterlude" && SceneManager.GetActiveScene().name != "Menu")
{
sceneToLoad = "ElevatorInterlude";
}
else if (nextFloor > floorsUntilGameOver)
{
sceneToLoad = "LoseScene";
}
else
{
sceneToLoad = "Floor " + nextFloor.ToString();
networkedGameState.SetCurrentFloor(nextFloor);
}
if (IsSceneInBuild(sceneToLoad))
{
NetworkSceneManager.SwitchScene(sceneToLoad);
}
else
{
Debug.LogError("The Scene \"" + sceneToLoad + "\" does not exist in the build, returning to main menu");
ReturnToMainMenu();
}
}
else
{
Debug.LogWarning("Tried to load next floor when not the server");
}
}
internal static void HandleClientSwitchSceneCompleted(ulong clientId, Stream stream)
{
#if DEVELOPMENT_BUILD || UNITY_EDITOR
s_HandleClientSwitchSceneCompleted.Begin();
#endif
using (var reader = PooledNetworkReader.Get(stream))
{
NetworkSceneManager.OnClientSwitchSceneCompleted(clientId, new Guid(reader.ReadByteArray()));
}
#if DEVELOPMENT_BUILD || UNITY_EDITOR
s_HandleClientSwitchSceneCompleted.End();
#endif
}
/// <summary>
/// Switches to a new scene
/// </summary>
/// <param name="scenename"></param>
public void SwitchScene(string scenename)
{
if (NetworkManager.Singleton.IsListening)
{
m_SceneProgress = NetworkSceneManager.SwitchScene(scenename);
m_SceneProgress.OnClientLoadedScene += SceneProgress_OnClientLoadedScene;
}
else
{
SceneManager.LoadSceneAsync(scenename);
}
}
private void OnClientDisconnectCallback(ulong id)
{
_SessionManager.RemovePlayer(id);
if (_SessionManager.Any())
{
return;
}
NetworkSceneManager.SwitchScene("MainMenu");
_CurrentLevel = 0;
CBSL.Logging.Logger.Info <NetworkController>("Server Reset");
}
/// <summary>
/// Override this function to customize what happens when the game quits.
/// Make sure to unspawn network objects.
/// </summary>
/// <param name="clientId"></param>
protected virtual void endGame()
{
// Unspawn paddles and other things
leftPaddle.GetComponent <NetworkedObject>().UnSpawn();
Destroy(leftPaddle.gameObject);
rightPaddle.GetComponent <NetworkedObject>().UnSpawn();
Destroy(rightPaddle.gameObject);
// Remove callbacks
NetworkingManager.Singleton.OnClientDisconnectCallback -= clientDisconnectCallback;
NetworkSceneManager.SwitchScene("Lobby");
}
