niko
962 lines
27 KiB
C#
962 lines
27 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using UnityEngine.Networking.NetworkSystem;
|
|
using UnityEngine.SceneManagement;
|
|
|
|
namespace UnityEngine.Networking
|
|
{
|
|
// Token: 0x02000048 RID: 72
|
|
[AddComponentMenu("Network/NetworkLobbyManager")]
|
|
public class NetworkLobbyManager : NetworkManager
|
|
{
|
|
// Token: 0x17000060 RID: 96
|
|
// (get) Token: 0x06000254 RID: 596 RVA: 0x0000FE78 File Offset: 0x0000E078
|
|
// (set) Token: 0x06000255 RID: 597 RVA: 0x0000FE93 File Offset: 0x0000E093
|
|
public bool showLobbyGUI
|
|
{
|
|
get
|
|
{
|
|
return this.m_ShowLobbyGUI;
|
|
}
|
|
set
|
|
{
|
|
this.m_ShowLobbyGUI = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000061 RID: 97
|
|
// (get) Token: 0x06000256 RID: 598 RVA: 0x0000FEA0 File Offset: 0x0000E0A0
|
|
// (set) Token: 0x06000257 RID: 599 RVA: 0x0000FEBB File Offset: 0x0000E0BB
|
|
public int maxPlayers
|
|
{
|
|
get
|
|
{
|
|
return this.m_MaxPlayers;
|
|
}
|
|
set
|
|
{
|
|
this.m_MaxPlayers = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000062 RID: 98
|
|
// (get) Token: 0x06000258 RID: 600 RVA: 0x0000FEC8 File Offset: 0x0000E0C8
|
|
// (set) Token: 0x06000259 RID: 601 RVA: 0x0000FEE3 File Offset: 0x0000E0E3
|
|
public int maxPlayersPerConnection
|
|
{
|
|
get
|
|
{
|
|
return this.m_MaxPlayersPerConnection;
|
|
}
|
|
set
|
|
{
|
|
this.m_MaxPlayersPerConnection = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000063 RID: 99
|
|
// (get) Token: 0x0600025A RID: 602 RVA: 0x0000FEF0 File Offset: 0x0000E0F0
|
|
// (set) Token: 0x0600025B RID: 603 RVA: 0x0000FF0B File Offset: 0x0000E10B
|
|
public int minPlayers
|
|
{
|
|
get
|
|
{
|
|
return this.m_MinPlayers;
|
|
}
|
|
set
|
|
{
|
|
this.m_MinPlayers = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000064 RID: 100
|
|
// (get) Token: 0x0600025C RID: 604 RVA: 0x0000FF18 File Offset: 0x0000E118
|
|
// (set) Token: 0x0600025D RID: 605 RVA: 0x0000FF33 File Offset: 0x0000E133
|
|
public NetworkLobbyPlayer lobbyPlayerPrefab
|
|
{
|
|
get
|
|
{
|
|
return this.m_LobbyPlayerPrefab;
|
|
}
|
|
set
|
|
{
|
|
this.m_LobbyPlayerPrefab = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000065 RID: 101
|
|
// (get) Token: 0x0600025E RID: 606 RVA: 0x0000FF40 File Offset: 0x0000E140
|
|
// (set) Token: 0x0600025F RID: 607 RVA: 0x0000FF5B File Offset: 0x0000E15B
|
|
public GameObject gamePlayerPrefab
|
|
{
|
|
get
|
|
{
|
|
return this.m_GamePlayerPrefab;
|
|
}
|
|
set
|
|
{
|
|
this.m_GamePlayerPrefab = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000066 RID: 102
|
|
// (get) Token: 0x06000260 RID: 608 RVA: 0x0000FF68 File Offset: 0x0000E168
|
|
// (set) Token: 0x06000261 RID: 609 RVA: 0x0000FF83 File Offset: 0x0000E183
|
|
public string lobbyScene
|
|
{
|
|
get
|
|
{
|
|
return this.m_LobbyScene;
|
|
}
|
|
set
|
|
{
|
|
this.m_LobbyScene = value;
|
|
base.offlineScene = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x17000067 RID: 103
|
|
// (get) Token: 0x06000262 RID: 610 RVA: 0x0000FF94 File Offset: 0x0000E194
|
|
// (set) Token: 0x06000263 RID: 611 RVA: 0x0000FFAF File Offset: 0x0000E1AF
|
|
public string playScene
|
|
{
|
|
get
|
|
{
|
|
return this.m_PlayScene;
|
|
}
|
|
set
|
|
{
|
|
this.m_PlayScene = value;
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000264 RID: 612 RVA: 0x0000FFBC File Offset: 0x0000E1BC
|
|
private void OnValidate()
|
|
{
|
|
if (this.m_MaxPlayers <= 0)
|
|
{
|
|
this.m_MaxPlayers = 1;
|
|
}
|
|
if (this.m_MaxPlayersPerConnection <= 0)
|
|
{
|
|
this.m_MaxPlayersPerConnection = 1;
|
|
}
|
|
if (this.m_MaxPlayersPerConnection > this.maxPlayers)
|
|
{
|
|
this.m_MaxPlayersPerConnection = this.maxPlayers;
|
|
}
|
|
if (this.m_MinPlayers < 0)
|
|
{
|
|
this.m_MinPlayers = 0;
|
|
}
|
|
if (this.m_MinPlayers > this.m_MaxPlayers)
|
|
{
|
|
this.m_MinPlayers = this.m_MaxPlayers;
|
|
}
|
|
if (this.m_LobbyPlayerPrefab != null)
|
|
{
|
|
NetworkIdentity component = this.m_LobbyPlayerPrefab.GetComponent<NetworkIdentity>();
|
|
if (component == null)
|
|
{
|
|
this.m_LobbyPlayerPrefab = null;
|
|
Debug.LogWarning("LobbyPlayer prefab must have a NetworkIdentity component.");
|
|
}
|
|
}
|
|
if (this.m_GamePlayerPrefab != null)
|
|
{
|
|
NetworkIdentity component2 = this.m_GamePlayerPrefab.GetComponent<NetworkIdentity>();
|
|
if (component2 == null)
|
|
{
|
|
this.m_GamePlayerPrefab = null;
|
|
Debug.LogWarning("GamePlayer prefab must have a NetworkIdentity component.");
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000265 RID: 613 RVA: 0x000100C4 File Offset: 0x0000E2C4
|
|
private byte FindSlot()
|
|
{
|
|
byte b = 0;
|
|
while ((int)b < this.maxPlayers)
|
|
{
|
|
if (this.lobbySlots[(int)b] == null)
|
|
{
|
|
return b;
|
|
}
|
|
b += 1;
|
|
}
|
|
return byte.MaxValue;
|
|
}
|
|
|
|
// Token: 0x06000266 RID: 614 RVA: 0x00010114 File Offset: 0x0000E314
|
|
private void SceneLoadedForPlayer(NetworkConnection conn, GameObject lobbyPlayerGameObject)
|
|
{
|
|
NetworkLobbyPlayer component = lobbyPlayerGameObject.GetComponent<NetworkLobbyPlayer>();
|
|
if (!(component == null))
|
|
{
|
|
string name = SceneManager.GetSceneAt(0).name;
|
|
if (LogFilter.logDebug)
|
|
{
|
|
Debug.Log(string.Concat(new object[] { "NetworkLobby SceneLoadedForPlayer scene:", name, " ", conn }));
|
|
}
|
|
if (name == this.m_LobbyScene)
|
|
{
|
|
NetworkLobbyManager.PendingPlayer pendingPlayer;
|
|
pendingPlayer.conn = conn;
|
|
pendingPlayer.lobbyPlayer = lobbyPlayerGameObject;
|
|
this.m_PendingPlayers.Add(pendingPlayer);
|
|
}
|
|
else
|
|
{
|
|
short playerControllerId = lobbyPlayerGameObject.GetComponent<NetworkIdentity>().playerControllerId;
|
|
GameObject gameObject = this.OnLobbyServerCreateGamePlayer(conn, playerControllerId);
|
|
if (gameObject == null)
|
|
{
|
|
Transform startPosition = base.GetStartPosition();
|
|
if (startPosition != null)
|
|
{
|
|
gameObject = Object.Instantiate<GameObject>(this.gamePlayerPrefab, startPosition.position, startPosition.rotation);
|
|
}
|
|
else
|
|
{
|
|
gameObject = Object.Instantiate<GameObject>(this.gamePlayerPrefab, Vector3.zero, Quaternion.identity);
|
|
}
|
|
}
|
|
if (this.OnLobbyServerSceneLoadedForPlayer(lobbyPlayerGameObject, gameObject))
|
|
{
|
|
NetworkServer.ReplacePlayerForConnection(conn, gameObject, playerControllerId);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000267 RID: 615 RVA: 0x00010248 File Offset: 0x0000E448
|
|
private static int CheckConnectionIsReadyToBegin(NetworkConnection conn)
|
|
{
|
|
int num = 0;
|
|
for (int i = 0; i < conn.playerControllers.Count; i++)
|
|
{
|
|
PlayerController playerController = conn.playerControllers[i];
|
|
if (playerController.IsValid)
|
|
{
|
|
NetworkLobbyPlayer component = playerController.gameObject.GetComponent<NetworkLobbyPlayer>();
|
|
if (component.readyToBegin)
|
|
{
|
|
num++;
|
|
}
|
|
}
|
|
}
|
|
return num;
|
|
}
|
|
|
|
// Token: 0x06000268 RID: 616 RVA: 0x000102B8 File Offset: 0x0000E4B8
|
|
public void CheckReadyToBegin()
|
|
{
|
|
string name = SceneManager.GetSceneAt(0).name;
|
|
if (!(name != this.m_LobbyScene))
|
|
{
|
|
int num = 0;
|
|
int num2 = 0;
|
|
for (int i = 0; i < NetworkServer.connections.Count; i++)
|
|
{
|
|
NetworkConnection networkConnection = NetworkServer.connections[i];
|
|
if (networkConnection != null)
|
|
{
|
|
num2++;
|
|
num += NetworkLobbyManager.CheckConnectionIsReadyToBegin(networkConnection);
|
|
}
|
|
}
|
|
if (this.m_MinPlayers <= 0 || num >= this.m_MinPlayers)
|
|
{
|
|
if (num >= num2)
|
|
{
|
|
this.m_PendingPlayers.Clear();
|
|
this.OnLobbyServerPlayersReady();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000269 RID: 617 RVA: 0x00010375 File Offset: 0x0000E575
|
|
public void ServerReturnToLobby()
|
|
{
|
|
if (!NetworkServer.active)
|
|
{
|
|
Debug.Log("ServerReturnToLobby called on client");
|
|
}
|
|
else
|
|
{
|
|
this.ServerChangeScene(this.m_LobbyScene);
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600026A RID: 618 RVA: 0x000103A0 File Offset: 0x0000E5A0
|
|
private void CallOnClientEnterLobby()
|
|
{
|
|
this.OnLobbyClientEnter();
|
|
for (int i = 0; i < this.lobbySlots.Length; i++)
|
|
{
|
|
NetworkLobbyPlayer networkLobbyPlayer = this.lobbySlots[i];
|
|
if (!(networkLobbyPlayer == null))
|
|
{
|
|
networkLobbyPlayer.readyToBegin = false;
|
|
networkLobbyPlayer.OnClientEnterLobby();
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600026B RID: 619 RVA: 0x000103F8 File Offset: 0x0000E5F8
|
|
private void CallOnClientExitLobby()
|
|
{
|
|
this.OnLobbyClientExit();
|
|
for (int i = 0; i < this.lobbySlots.Length; i++)
|
|
{
|
|
NetworkLobbyPlayer networkLobbyPlayer = this.lobbySlots[i];
|
|
if (!(networkLobbyPlayer == null))
|
|
{
|
|
networkLobbyPlayer.OnClientExitLobby();
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600026C RID: 620 RVA: 0x00010448 File Offset: 0x0000E648
|
|
public bool SendReturnToLobby()
|
|
{
|
|
bool flag;
|
|
if (this.client == null || !this.client.isConnected)
|
|
{
|
|
flag = false;
|
|
}
|
|
else
|
|
{
|
|
EmptyMessage emptyMessage = new EmptyMessage();
|
|
this.client.Send(46, emptyMessage);
|
|
flag = true;
|
|
}
|
|
return flag;
|
|
}
|
|
|
|
// Token: 0x0600026D RID: 621 RVA: 0x00010498 File Offset: 0x0000E698
|
|
public override void OnServerConnect(NetworkConnection conn)
|
|
{
|
|
if (base.numPlayers > this.maxPlayers)
|
|
{
|
|
if (LogFilter.logWarn)
|
|
{
|
|
Debug.LogWarning("NetworkLobbyManager can't accept new connection [" + conn + "], too many players connected.");
|
|
}
|
|
conn.Disconnect();
|
|
}
|
|
else
|
|
{
|
|
string name = SceneManager.GetSceneAt(0).name;
|
|
if (name != this.m_LobbyScene)
|
|
{
|
|
if (LogFilter.logWarn)
|
|
{
|
|
Debug.LogWarning("NetworkLobbyManager can't accept new connection [" + conn + "], not in lobby and game already in progress.");
|
|
}
|
|
conn.Disconnect();
|
|
}
|
|
else
|
|
{
|
|
base.OnServerConnect(conn);
|
|
for (int i = 0; i < this.lobbySlots.Length; i++)
|
|
{
|
|
if (this.lobbySlots[i])
|
|
{
|
|
this.lobbySlots[i].SetDirtyBit(1U);
|
|
}
|
|
}
|
|
this.OnLobbyServerConnect(conn);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600026E RID: 622 RVA: 0x0001057C File Offset: 0x0000E77C
|
|
public override void OnServerDisconnect(NetworkConnection conn)
|
|
{
|
|
base.OnServerDisconnect(conn);
|
|
for (int i = 0; i < this.lobbySlots.Length; i++)
|
|
{
|
|
NetworkLobbyPlayer networkLobbyPlayer = this.lobbySlots[i];
|
|
if (!(networkLobbyPlayer == null))
|
|
{
|
|
if (networkLobbyPlayer.connectionToClient == conn)
|
|
{
|
|
this.lobbySlots[i] = null;
|
|
NetworkServer.Destroy(networkLobbyPlayer.gameObject);
|
|
}
|
|
}
|
|
}
|
|
this.OnLobbyServerDisconnect(conn);
|
|
}
|
|
|
|
// Token: 0x0600026F RID: 623 RVA: 0x000105F0 File Offset: 0x0000E7F0
|
|
public override void OnServerAddPlayer(NetworkConnection conn, short playerControllerId)
|
|
{
|
|
string name = SceneManager.GetSceneAt(0).name;
|
|
if (!(name != this.m_LobbyScene))
|
|
{
|
|
int num = 0;
|
|
for (int i = 0; i < conn.playerControllers.Count; i++)
|
|
{
|
|
if (conn.playerControllers[i].IsValid)
|
|
{
|
|
num++;
|
|
}
|
|
}
|
|
if (num >= this.maxPlayersPerConnection)
|
|
{
|
|
if (LogFilter.logWarn)
|
|
{
|
|
Debug.LogWarning("NetworkLobbyManager no more players for this connection.");
|
|
}
|
|
EmptyMessage emptyMessage = new EmptyMessage();
|
|
conn.Send(45, emptyMessage);
|
|
}
|
|
else
|
|
{
|
|
byte b = this.FindSlot();
|
|
if (b == 255)
|
|
{
|
|
if (LogFilter.logWarn)
|
|
{
|
|
Debug.LogWarning("NetworkLobbyManager no space for more players");
|
|
}
|
|
EmptyMessage emptyMessage2 = new EmptyMessage();
|
|
conn.Send(45, emptyMessage2);
|
|
}
|
|
else
|
|
{
|
|
GameObject gameObject = this.OnLobbyServerCreateLobbyPlayer(conn, playerControllerId);
|
|
if (gameObject == null)
|
|
{
|
|
gameObject = Object.Instantiate<GameObject>(this.lobbyPlayerPrefab.gameObject, Vector3.zero, Quaternion.identity);
|
|
}
|
|
NetworkLobbyPlayer component = gameObject.GetComponent<NetworkLobbyPlayer>();
|
|
component.slot = b;
|
|
this.lobbySlots[(int)b] = component;
|
|
NetworkServer.AddPlayerForConnection(conn, gameObject, playerControllerId);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000270 RID: 624 RVA: 0x00010738 File Offset: 0x0000E938
|
|
public override void OnServerRemovePlayer(NetworkConnection conn, PlayerController player)
|
|
{
|
|
short playerControllerId = player.playerControllerId;
|
|
byte slot = player.gameObject.GetComponent<NetworkLobbyPlayer>().slot;
|
|
this.lobbySlots[(int)slot] = null;
|
|
base.OnServerRemovePlayer(conn, player);
|
|
for (int i = 0; i < this.lobbySlots.Length; i++)
|
|
{
|
|
NetworkLobbyPlayer networkLobbyPlayer = this.lobbySlots[i];
|
|
if (networkLobbyPlayer != null)
|
|
{
|
|
networkLobbyPlayer.GetComponent<NetworkLobbyPlayer>().readyToBegin = false;
|
|
NetworkLobbyManager.s_LobbyReadyToBeginMessage.slotId = networkLobbyPlayer.slot;
|
|
NetworkLobbyManager.s_LobbyReadyToBeginMessage.readyState = false;
|
|
NetworkServer.SendToReady(null, 43, NetworkLobbyManager.s_LobbyReadyToBeginMessage);
|
|
}
|
|
}
|
|
this.OnLobbyServerPlayerRemoved(conn, playerControllerId);
|
|
}
|
|
|
|
// Token: 0x06000271 RID: 625 RVA: 0x000107E0 File Offset: 0x0000E9E0
|
|
public override void ServerChangeScene(string sceneName)
|
|
{
|
|
if (sceneName == this.m_LobbyScene)
|
|
{
|
|
for (int i = 0; i < this.lobbySlots.Length; i++)
|
|
{
|
|
NetworkLobbyPlayer networkLobbyPlayer = this.lobbySlots[i];
|
|
if (!(networkLobbyPlayer == null))
|
|
{
|
|
NetworkIdentity component = networkLobbyPlayer.GetComponent<NetworkIdentity>();
|
|
PlayerController playerController;
|
|
if (component.connectionToClient.GetPlayerController(component.playerControllerId, out playerController))
|
|
{
|
|
NetworkServer.Destroy(playerController.gameObject);
|
|
}
|
|
if (NetworkServer.active)
|
|
{
|
|
networkLobbyPlayer.GetComponent<NetworkLobbyPlayer>().readyToBegin = false;
|
|
NetworkServer.ReplacePlayerForConnection(component.connectionToClient, networkLobbyPlayer.gameObject, component.playerControllerId);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
base.ServerChangeScene(sceneName);
|
|
}
|
|
|
|
// Token: 0x06000272 RID: 626 RVA: 0x0001089C File Offset: 0x0000EA9C
|
|
public override void OnServerSceneChanged(string sceneName)
|
|
{
|
|
if (sceneName != this.m_LobbyScene)
|
|
{
|
|
for (int i = 0; i < this.m_PendingPlayers.Count; i++)
|
|
{
|
|
NetworkLobbyManager.PendingPlayer pendingPlayer = this.m_PendingPlayers[i];
|
|
this.SceneLoadedForPlayer(pendingPlayer.conn, pendingPlayer.lobbyPlayer);
|
|
}
|
|
this.m_PendingPlayers.Clear();
|
|
}
|
|
this.OnLobbyServerSceneChanged(sceneName);
|
|
}
|
|
|
|
// Token: 0x06000273 RID: 627 RVA: 0x00010910 File Offset: 0x0000EB10
|
|
private void OnServerReadyToBeginMessage(NetworkMessage netMsg)
|
|
{
|
|
if (LogFilter.logDebug)
|
|
{
|
|
Debug.Log("NetworkLobbyManager OnServerReadyToBeginMessage");
|
|
}
|
|
netMsg.ReadMessage<LobbyReadyToBeginMessage>(NetworkLobbyManager.s_ReadyToBeginMessage);
|
|
PlayerController playerController;
|
|
if (!netMsg.conn.GetPlayerController((short)NetworkLobbyManager.s_ReadyToBeginMessage.slotId, out playerController))
|
|
{
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError("NetworkLobbyManager OnServerReadyToBeginMessage invalid playerControllerId " + NetworkLobbyManager.s_ReadyToBeginMessage.slotId);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
NetworkLobbyPlayer component = playerController.gameObject.GetComponent<NetworkLobbyPlayer>();
|
|
component.readyToBegin = NetworkLobbyManager.s_ReadyToBeginMessage.readyState;
|
|
NetworkServer.SendToReady(null, 43, new LobbyReadyToBeginMessage
|
|
{
|
|
slotId = component.slot,
|
|
readyState = NetworkLobbyManager.s_ReadyToBeginMessage.readyState
|
|
});
|
|
this.CheckReadyToBegin();
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000274 RID: 628 RVA: 0x000109DC File Offset: 0x0000EBDC
|
|
private void OnServerSceneLoadedMessage(NetworkMessage netMsg)
|
|
{
|
|
if (LogFilter.logDebug)
|
|
{
|
|
Debug.Log("NetworkLobbyManager OnSceneLoadedMessage");
|
|
}
|
|
netMsg.ReadMessage<IntegerMessage>(NetworkLobbyManager.s_SceneLoadedMessage);
|
|
PlayerController playerController;
|
|
if (!netMsg.conn.GetPlayerController((short)NetworkLobbyManager.s_SceneLoadedMessage.value, out playerController))
|
|
{
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError("NetworkLobbyManager OnServerSceneLoadedMessage invalid playerControllerId " + NetworkLobbyManager.s_SceneLoadedMessage.value);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
this.SceneLoadedForPlayer(netMsg.conn, playerController.gameObject);
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000275 RID: 629 RVA: 0x00010A6A File Offset: 0x0000EC6A
|
|
private void OnServerReturnToLobbyMessage(NetworkMessage netMsg)
|
|
{
|
|
if (LogFilter.logDebug)
|
|
{
|
|
Debug.Log("NetworkLobbyManager OnServerReturnToLobbyMessage");
|
|
}
|
|
this.ServerReturnToLobby();
|
|
}
|
|
|
|
// Token: 0x06000276 RID: 630 RVA: 0x00010A8C File Offset: 0x0000EC8C
|
|
public override void OnStartServer()
|
|
{
|
|
if (string.IsNullOrEmpty(this.m_LobbyScene))
|
|
{
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError("NetworkLobbyManager LobbyScene is empty. Set the LobbyScene in the inspector for the NetworkLobbyMangaer");
|
|
}
|
|
}
|
|
else if (string.IsNullOrEmpty(this.m_PlayScene))
|
|
{
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError("NetworkLobbyManager PlayScene is empty. Set the PlayScene in the inspector for the NetworkLobbyMangaer");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (this.lobbySlots.Length == 0)
|
|
{
|
|
this.lobbySlots = new NetworkLobbyPlayer[this.maxPlayers];
|
|
}
|
|
NetworkServer.RegisterHandler(43, new NetworkMessageDelegate(this.OnServerReadyToBeginMessage));
|
|
NetworkServer.RegisterHandler(44, new NetworkMessageDelegate(this.OnServerSceneLoadedMessage));
|
|
NetworkServer.RegisterHandler(46, new NetworkMessageDelegate(this.OnServerReturnToLobbyMessage));
|
|
this.OnLobbyStartServer();
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000277 RID: 631 RVA: 0x00010B51 File Offset: 0x0000ED51
|
|
public override void OnStartHost()
|
|
{
|
|
this.OnLobbyStartHost();
|
|
}
|
|
|
|
// Token: 0x06000278 RID: 632 RVA: 0x00010B5A File Offset: 0x0000ED5A
|
|
public override void OnStopHost()
|
|
{
|
|
this.OnLobbyStopHost();
|
|
}
|
|
|
|
// Token: 0x06000279 RID: 633 RVA: 0x00010B64 File Offset: 0x0000ED64
|
|
public override void OnStartClient(NetworkClient lobbyClient)
|
|
{
|
|
if (this.lobbySlots.Length == 0)
|
|
{
|
|
this.lobbySlots = new NetworkLobbyPlayer[this.maxPlayers];
|
|
}
|
|
if (this.m_LobbyPlayerPrefab == null || this.m_LobbyPlayerPrefab.gameObject == null)
|
|
{
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError("NetworkLobbyManager no LobbyPlayer prefab is registered. Please add a LobbyPlayer prefab.");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ClientScene.RegisterPrefab(this.m_LobbyPlayerPrefab.gameObject);
|
|
}
|
|
if (this.m_GamePlayerPrefab == null)
|
|
{
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError("NetworkLobbyManager no GamePlayer prefab is registered. Please add a GamePlayer prefab.");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ClientScene.RegisterPrefab(this.m_GamePlayerPrefab);
|
|
}
|
|
lobbyClient.RegisterHandler(43, new NetworkMessageDelegate(this.OnClientReadyToBegin));
|
|
lobbyClient.RegisterHandler(45, new NetworkMessageDelegate(this.OnClientAddPlayerFailedMessage));
|
|
this.OnLobbyStartClient(lobbyClient);
|
|
}
|
|
|
|
// Token: 0x0600027A RID: 634 RVA: 0x00010C52 File Offset: 0x0000EE52
|
|
public override void OnClientConnect(NetworkConnection conn)
|
|
{
|
|
this.OnLobbyClientConnect(conn);
|
|
this.CallOnClientEnterLobby();
|
|
base.OnClientConnect(conn);
|
|
}
|
|
|
|
// Token: 0x0600027B RID: 635 RVA: 0x00010C69 File Offset: 0x0000EE69
|
|
public override void OnClientDisconnect(NetworkConnection conn)
|
|
{
|
|
this.OnLobbyClientDisconnect(conn);
|
|
base.OnClientDisconnect(conn);
|
|
}
|
|
|
|
// Token: 0x0600027C RID: 636 RVA: 0x00010C7A File Offset: 0x0000EE7A
|
|
public override void OnStopClient()
|
|
{
|
|
this.OnLobbyStopClient();
|
|
this.CallOnClientExitLobby();
|
|
}
|
|
|
|
// Token: 0x0600027D RID: 637 RVA: 0x00010C8C File Offset: 0x0000EE8C
|
|
public override void OnClientSceneChanged(NetworkConnection conn)
|
|
{
|
|
string name = SceneManager.GetSceneAt(0).name;
|
|
if (name == this.m_LobbyScene)
|
|
{
|
|
if (this.client.isConnected)
|
|
{
|
|
this.CallOnClientEnterLobby();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
this.CallOnClientExitLobby();
|
|
}
|
|
base.OnClientSceneChanged(conn);
|
|
this.OnLobbyClientSceneChanged(conn);
|
|
}
|
|
|
|
// Token: 0x0600027E RID: 638 RVA: 0x00010CF0 File Offset: 0x0000EEF0
|
|
private void OnClientReadyToBegin(NetworkMessage netMsg)
|
|
{
|
|
netMsg.ReadMessage<LobbyReadyToBeginMessage>(NetworkLobbyManager.s_LobbyReadyToBeginMessage);
|
|
if ((int)NetworkLobbyManager.s_LobbyReadyToBeginMessage.slotId >= this.lobbySlots.Count<NetworkLobbyPlayer>())
|
|
{
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError("NetworkLobbyManager OnClientReadyToBegin invalid lobby slot " + NetworkLobbyManager.s_LobbyReadyToBeginMessage.slotId);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
NetworkLobbyPlayer networkLobbyPlayer = this.lobbySlots[(int)NetworkLobbyManager.s_LobbyReadyToBeginMessage.slotId];
|
|
if (networkLobbyPlayer == null || networkLobbyPlayer.gameObject == null)
|
|
{
|
|
if (LogFilter.logError)
|
|
{
|
|
Debug.LogError("NetworkLobbyManager OnClientReadyToBegin no player at lobby slot " + NetworkLobbyManager.s_LobbyReadyToBeginMessage.slotId);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
networkLobbyPlayer.readyToBegin = NetworkLobbyManager.s_LobbyReadyToBeginMessage.readyState;
|
|
networkLobbyPlayer.OnClientReady(NetworkLobbyManager.s_LobbyReadyToBeginMessage.readyState);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x0600027F RID: 639 RVA: 0x00010DD2 File Offset: 0x0000EFD2
|
|
private void OnClientAddPlayerFailedMessage(NetworkMessage netMsg)
|
|
{
|
|
if (LogFilter.logDebug)
|
|
{
|
|
Debug.Log("NetworkLobbyManager Add Player failed.");
|
|
}
|
|
this.OnLobbyClientAddPlayerFailed();
|
|
}
|
|
|
|
// Token: 0x06000280 RID: 640 RVA: 0x00010DF1 File Offset: 0x0000EFF1
|
|
public virtual void OnLobbyStartHost()
|
|
{
|
|
}
|
|
|
|
// Token: 0x06000281 RID: 641 RVA: 0x00010DF4 File Offset: 0x0000EFF4
|
|
public virtual void OnLobbyStopHost()
|
|
{
|
|
}
|
|
|
|
// Token: 0x06000282 RID: 642 RVA: 0x00010DF7 File Offset: 0x0000EFF7
|
|
public virtual void OnLobbyStartServer()
|
|
{
|
|
}
|
|
|
|
// Token: 0x06000283 RID: 643 RVA: 0x00010DFA File Offset: 0x0000EFFA
|
|
public virtual void OnLobbyServerConnect(NetworkConnection conn)
|
|
{
|
|
}
|
|
|
|
// Token: 0x06000284 RID: 644 RVA: 0x00010DFD File Offset: 0x0000EFFD
|
|
public virtual void OnLobbyServerDisconnect(NetworkConnection conn)
|
|
{
|
|
}
|
|
|
|
// Token: 0x06000285 RID: 645 RVA: 0x00010E00 File Offset: 0x0000F000
|
|
public virtual void OnLobbyServerSceneChanged(string sceneName)
|
|
{
|
|
}
|
|
|
|
// Token: 0x06000286 RID: 646 RVA: 0x00010E04 File Offset: 0x0000F004
|
|
public virtual GameObject OnLobbyServerCreateLobbyPlayer(NetworkConnection conn, short playerControllerId)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x06000287 RID: 647 RVA: 0x00010E1C File Offset: 0x0000F01C
|
|
public virtual GameObject OnLobbyServerCreateGamePlayer(NetworkConnection conn, short playerControllerId)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
// Token: 0x06000288 RID: 648 RVA: 0x00010E32 File Offset: 0x0000F032
|
|
public virtual void OnLobbyServerPlayerRemoved(NetworkConnection conn, short playerControllerId)
|
|
{
|
|
}
|
|
|
|
// Token: 0x06000289 RID: 649 RVA: 0x00010E38 File Offset: 0x0000F038
|
|
public virtual bool OnLobbyServerSceneLoadedForPlayer(GameObject lobbyPlayer, GameObject gamePlayer)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
// Token: 0x0600028A RID: 650 RVA: 0x00010E4E File Offset: 0x0000F04E
|
|
public virtual void OnLobbyServerPlayersReady()
|
|
{
|
|
this.ServerChangeScene(this.m_PlayScene);
|
|
}
|
|
|
|
// Token: 0x0600028B RID: 651 RVA: 0x00010E5D File Offset: 0x0000F05D
|
|
public virtual void OnLobbyClientEnter()
|
|
{
|
|
}
|
|
|
|
// Token: 0x0600028C RID: 652 RVA: 0x00010E60 File Offset: 0x0000F060
|
|
public virtual void OnLobbyClientExit()
|
|
{
|
|
}
|
|
|
|
// Token: 0x0600028D RID: 653 RVA: 0x00010E63 File Offset: 0x0000F063
|
|
public virtual void OnLobbyClientConnect(NetworkConnection conn)
|
|
{
|
|
}
|
|
|
|
// Token: 0x0600028E RID: 654 RVA: 0x00010E66 File Offset: 0x0000F066
|
|
public virtual void OnLobbyClientDisconnect(NetworkConnection conn)
|
|
{
|
|
}
|
|
|
|
// Token: 0x0600028F RID: 655 RVA: 0x00010E69 File Offset: 0x0000F069
|
|
public virtual void OnLobbyStartClient(NetworkClient lobbyClient)
|
|
{
|
|
}
|
|
|
|
// Token: 0x06000290 RID: 656 RVA: 0x00010E6C File Offset: 0x0000F06C
|
|
public virtual void OnLobbyStopClient()
|
|
{
|
|
}
|
|
|
|
// Token: 0x06000291 RID: 657 RVA: 0x00010E6F File Offset: 0x0000F06F
|
|
public virtual void OnLobbyClientSceneChanged(NetworkConnection conn)
|
|
{
|
|
}
|
|
|
|
// Token: 0x06000292 RID: 658 RVA: 0x00010E72 File Offset: 0x0000F072
|
|
public virtual void OnLobbyClientAddPlayerFailed()
|
|
{
|
|
}
|
|
|
|
// Token: 0x06000293 RID: 659 RVA: 0x00010E78 File Offset: 0x0000F078
|
|
private void OnGUI()
|
|
{
|
|
if (this.showLobbyGUI)
|
|
{
|
|
string name = SceneManager.GetSceneAt(0).name;
|
|
if (!(name != this.m_LobbyScene))
|
|
{
|
|
Rect rect = new Rect(90f, 180f, 500f, 150f);
|
|
GUI.Box(rect, "Players:");
|
|
if (NetworkClient.active)
|
|
{
|
|
Rect rect2 = new Rect(100f, 300f, 120f, 20f);
|
|
if (GUI.Button(rect2, "Add Player"))
|
|
{
|
|
this.TryToAddPlayer();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Token: 0x06000294 RID: 660 RVA: 0x00010F20 File Offset: 0x0000F120
|
|
public void TryToAddPlayer()
|
|
{
|
|
if (NetworkClient.active)
|
|
{
|
|
short num = -1;
|
|
List<PlayerController> playerControllers = NetworkClient.allClients[0].connection.playerControllers;
|
|
if (playerControllers.Count < this.maxPlayers)
|
|
{
|
|
num = (short)playerControllers.Count;
|
|
}
|
|
else
|
|
{
|
|
short num2 = 0;
|
|
while ((int)num2 < this.maxPlayers)
|
|
{
|
|
if (!playerControllers[(int)num2].IsValid)
|
|
{
|
|
num = num2;
|
|
break;
|
|
}
|
|
num2 += 1;
|
|
}
|
|
}
|
|
if (LogFilter.logDebug)
|
|
{
|
|
Debug.Log(string.Concat(new object[]
|
|
{
|
|
"NetworkLobbyManager TryToAddPlayer controllerId ",
|
|
num,
|
|
" ready:",
|
|
ClientScene.ready
|
|
}));
|
|
}
|
|
if (num == -1)
|
|
{
|
|
if (LogFilter.logDebug)
|
|
{
|
|
Debug.Log("NetworkLobbyManager No Space!");
|
|
}
|
|
}
|
|
else if (ClientScene.ready)
|
|
{
|
|
ClientScene.AddPlayer(num);
|
|
}
|
|
else
|
|
{
|
|
ClientScene.AddPlayer(NetworkClient.allClients[0].connection, num);
|
|
}
|
|
}
|
|
else if (LogFilter.logDebug)
|
|
{
|
|
Debug.Log("NetworkLobbyManager NetworkClient not active!");
|
|
}
|
|
}
|
|
|
|
// Token: 0x04000144 RID: 324
|
|
[SerializeField]
|
|
private bool m_ShowLobbyGUI = true;
|
|
|
|
// Token: 0x04000145 RID: 325
|
|
[SerializeField]
|
|
private int m_MaxPlayers = 4;
|
|
|
|
// Token: 0x04000146 RID: 326
|
|
[SerializeField]
|
|
private int m_MaxPlayersPerConnection = 1;
|
|
|
|
// Token: 0x04000147 RID: 327
|
|
[SerializeField]
|
|
private int m_MinPlayers;
|
|
|
|
// Token: 0x04000148 RID: 328
|
|
[SerializeField]
|
|
private NetworkLobbyPlayer m_LobbyPlayerPrefab;
|
|
|
|
// Token: 0x04000149 RID: 329
|
|
[SerializeField]
|
|
private GameObject m_GamePlayerPrefab;
|
|
|
|
// Token: 0x0400014A RID: 330
|
|
[SerializeField]
|
|
private string m_LobbyScene = "";
|
|
|
|
// Token: 0x0400014B RID: 331
|
|
[SerializeField]
|
|
private string m_PlayScene = "";
|
|
|
|
// Token: 0x0400014C RID: 332
|
|
private List<NetworkLobbyManager.PendingPlayer> m_PendingPlayers = new List<NetworkLobbyManager.PendingPlayer>();
|
|
|
|
// Token: 0x0400014D RID: 333
|
|
public NetworkLobbyPlayer[] lobbySlots;
|
|
|
|
// Token: 0x0400014E RID: 334
|
|
private static LobbyReadyToBeginMessage s_ReadyToBeginMessage = new LobbyReadyToBeginMessage();
|
|
|
|
// Token: 0x0400014F RID: 335
|
|
private static IntegerMessage s_SceneLoadedMessage = new IntegerMessage();
|
|
|
|
// Token: 0x04000150 RID: 336
|
|
private static LobbyReadyToBeginMessage s_LobbyReadyToBeginMessage = new LobbyReadyToBeginMessage();
|
|
|
|
// Token: 0x02000049 RID: 73
|
|
private struct PendingPlayer
|
|
{
|
|
// Token: 0x04000151 RID: 337
|
|
public NetworkConnection conn;
|
|
|
|
// Token: 0x04000152 RID: 338
|
|
public GameObject lobbyPlayer;
|
|
}
|
|
}
|
|
}
|