High level UNET client.

        public static void OnStartClient(NetworkClient client)
        {
            client.RegisterHandler(VoiceChatMsgType.Packet, OnClientPacketReceived);
            client.RegisterHandler(VoiceChatMsgType.SpawnProxy, OnProxySpawned);

            var prefab = Resources.Load<GameObject>(ProxyPrefabPath);
            ClientScene.RegisterPrefab(prefab);
        }
        // Create a client and connect to the server port
        public void SetupClient()
        {
            ClientScene.RegisterPrefab(Prefab);

            client = new NetworkClient();

            client.RegisterHandler(MsgType.Connect, OnConnected);
            client.Connect("127.0.0.1", 4444);
        }
Beispiel #3
0
        private void Start()
        {
            var appManager = ApplicationManager.Instance;
            _messageBus = appManager.GetService<IMessageBus>();
            _client = NetworkManager.singleton.client;

            _editorController = new EditorController(appManager.GetService<ITileModelEditor>());

            SubscribeToLocalEvents();
            SubscribeToNetworkEvents();
        }
Beispiel #4
0
        public static void RegisterClientPacketHandlers(NetworkClient client)
        {
            client.RegisterHandler((short)PacketType.SetPlayerID, PHSetPlayerID);
            client.RegisterHandler((short)PacketType.SendMapInfo, PHReceiveMap);
            client.RegisterHandler((short)PacketType.PlayerNotReady, PHPlayerNotReady);
            client.RegisterHandler((short)PacketType.BroadcastPlayerName, PHBroadcastPlayerName);
            client.RegisterHandler((short)PacketType.BroadcastPlayerTeam, PHBroadcastPlayerTeam);
            client.RegisterHandler((short)PacketType.PlayerPrepared, PHPlayerPrepared);

            Debug.Log("Client Packet Handlers registered");
        }
        public static void OnManagerStartClient(NetworkClient client, GameObject customPrefab = null)
        {
            client.RegisterHandler(VoiceChatMsgType.Packet, OnClientPacketReceived);
            client.RegisterHandler(VoiceChatMsgType.SpawnProxy, OnProxySpawned);

            if (customPrefab == null)
            {
                proxyPrefab = Resources.Load<GameObject>(ProxyPrefabPath);
            }
            else
            {
                proxyPrefab = customPrefab;
            }

            ClientScene.RegisterPrefab(proxyPrefab);
        }
Beispiel #6
0
		// CONSTRUCTOR
		public Client(NetworkingInfo netinfo)
		{
			networkingInfo = netinfo;
			if(networkingInfo.port == -1) networkingInfo.port = NetworkingInfo.defaultPort;
			if(networkingInfo.address == "") networkingInfo.address = NetworkingInfo.defaultAddress;
			// TODO: Add some kind of DNS pre check for IP?

			connectedPlayers = new List<Player>();

			config = new ConnectionConfig();
			Channels.priority = config.AddChannel(QosType.AllCostDelivery);
			Channels.reliable = config.AddChannel(QosType.ReliableSequenced);
			Channels.unreliable = config.AddChannel(QosType.UnreliableSequenced);
			Channels.fragmented = config.AddChannel(QosType.ReliableFragmented);
			Channels.update = config.AddChannel(QosType.StateUpdate);
			hostconfig = new HostTopology(config, maxConcurrentConnectedUsers);

			if(networkingInfo.isServer)
			{
				myClient = ClientScene.ConnectLocalServer();
				myClient.Configure(hostconfig);

				myClient.RegisterHandler(MsgType.Connect, OnConnected);
				myClient.RegisterHandler(MsgType.Disconnect, ConnectionFailed);
				registerAllCallbacks(myClient, cbClientHandler);
			}
			else
			{
				myClient = new NetworkClient();
				myClient.Configure(hostconfig);

				myClient.RegisterHandler(MsgType.Connect, OnConnected);
				myClient.RegisterHandler(MsgType.Error, ConnectionError);
				myClient.RegisterHandler(MsgType.Disconnect, ConnectionFailed);
				registerAllCallbacks(myClient, cbClientHandler);

				common.printConsole (tag, "Setup complete", true);

				myClient.Connect(networkingInfo.address, networkingInfo.port);
				common.printConsole (tag, "Connecting to " + networkingInfo.address + ":" + networkingInfo.port, true);
			}
		}
 /// <summary>
 /// 
 /// <para>
 /// This is called on the client when a client is started.
 /// </para>
 /// 
 /// </summary>
 /// <param name="client"/>
 public virtual void OnLobbyStartClient(NetworkClient client)
 {
 }
 /// <summary>
 ///   <para>Stops the client that the manager is using.</para>
 /// </summary>
 public void StopClient()
 {
   this.OnStopClient();
   if (LogFilter.logDebug)
     Debug.Log((object) "NetworkManager StopClient");
   this.isNetworkActive = false;
   if (this.client != null)
   {
     this.client.Disconnect();
     this.client.Shutdown();
     this.client = (NetworkClient) null;
   }
   this.StopMatchMaker();
   ClientScene.DestroyAllClientObjects();
   if (!(this.m_OfflineScene != string.Empty))
     return;
   this.ClientChangeScene(this.m_OfflineScene, false);
 }
 public NetworkClient StartClient(MatchInfo info, ConnectionConfig config)
 {
   this.InitializeSingleton();
   this.matchInfo = info;
   if (this.m_RunInBackground)
     Application.runInBackground = true;
   this.isNetworkActive = true;
   if (this.m_GlobalConfig != null)
     NetworkTransport.Init(this.m_GlobalConfig);
   this.client = new NetworkClient();
   if (config != null)
   {
     if (config.UsePlatformSpecificProtocols && Application.platform != RuntimePlatform.PS4)
       throw new ArgumentOutOfRangeException("Platform specific protocols are not supported on this platform");
     this.client.Configure(config, 1);
   }
   else if (this.m_CustomConfig && this.m_ConnectionConfig != null)
   {
     this.m_ConnectionConfig.Channels.Clear();
     using (List<QosType>.Enumerator enumerator = this.m_Channels.GetEnumerator())
     {
       while (enumerator.MoveNext())
       {
         int num = (int) this.m_ConnectionConfig.AddChannel(enumerator.Current);
       }
     }
     if (this.m_ConnectionConfig.UsePlatformSpecificProtocols && Application.platform != RuntimePlatform.PS4)
       throw new ArgumentOutOfRangeException("Platform specific protocols are not supported on this platform");
     this.client.Configure(this.m_ConnectionConfig, this.m_MaxConnections);
   }
   this.RegisterClientMessages(this.client);
   if (this.matchInfo != null)
   {
     if (LogFilter.logDebug)
       Debug.Log((object) ("NetworkManager StartClient match: " + (object) this.matchInfo));
     this.client.Connect(this.matchInfo);
   }
   else if (this.m_EndPoint != null)
   {
     if (LogFilter.logDebug)
       Debug.Log((object) "NetworkManager StartClient using provided SecureTunnel");
     this.client.Connect(this.m_EndPoint);
   }
   else
   {
     if (string.IsNullOrEmpty(this.m_NetworkAddress))
     {
       if (LogFilter.logError)
         Debug.LogError((object) "Must set the Network Address field in the manager");
       return (NetworkClient) null;
     }
     if (LogFilter.logDebug)
       Debug.Log((object) ("NetworkManager StartClient address:" + this.m_NetworkAddress + " port:" + (object) this.m_NetworkPort));
     if (this.m_UseSimulator)
       this.client.ConnectWithSimulator(this.m_NetworkAddress, this.m_NetworkPort, this.m_SimulatedLatency, this.m_PacketLossPercentage);
     else
       this.client.Connect(this.m_NetworkAddress, this.m_NetworkPort);
   }
   if ((UnityEngine.Object) this.m_MigrationManager != (UnityEngine.Object) null)
     this.m_MigrationManager.Initialize(this.client, this.matchInfo);
   this.OnStartClient(this.client);
   NetworkManager.s_Address = this.m_NetworkAddress;
   return this.client;
 }
 internal void RegisterClientMessages(NetworkClient client)
 {
   client.RegisterHandler((short) 32, new NetworkMessageDelegate(this.OnClientConnectInternal));
   client.RegisterHandler((short) 33, new NetworkMessageDelegate(this.OnClientDisconnectInternal));
   client.RegisterHandler((short) 36, new NetworkMessageDelegate(this.OnClientNotReadyMessageInternal));
   client.RegisterHandler((short) 34, new NetworkMessageDelegate(this.OnClientErrorInternal));
   client.RegisterHandler((short) 39, new NetworkMessageDelegate(this.OnClientSceneInternal));
   if ((UnityEngine.Object) this.m_PlayerPrefab != (UnityEngine.Object) null)
     ClientScene.RegisterPrefab(this.m_PlayerPrefab);
   using (List<GameObject>.Enumerator enumerator = this.m_SpawnPrefabs.GetEnumerator())
   {
     while (enumerator.MoveNext())
     {
       GameObject current = enumerator.Current;
       if ((UnityEngine.Object) current != (UnityEngine.Object) null)
         ClientScene.RegisterPrefab(current);
     }
   }
 }
        private NetworkClient ConnectLocalClient()
        {
            if (LogFilter.logDebug)
            Debug.Log((object) ("NetworkManager StartHost port:" + (object) this.m_NetworkPort));

              this.m_NetworkAddress = "localhost";
              this.client = ClientScene.ConnectLocalServer();
              this.RegisterClientMessages(this.client);

              return this.client;
        }
        /// <summary>
        /// 
        /// <para>
        /// Stops the client that the manager is using.
        /// </para>
        /// 
        /// </summary>
        public void StopClient()
        {
            this.OnStopClient();

              if (LogFilter.logDebug)
            Debug.Log((object) "NetworkManager StopClient");

              this.isNetworkActive = false;

              if (this.client != null)
              {
            this.client.Disconnect();
            this.client.Shutdown();
            this.client = (NetworkClient) null;
              }

              this.StopMatchMaker();

              ClientScene.DestroyAllClientObjects(); // cleans up all network objects on this clients game, not just this clients objects

              if (this.m_OfflineScene != string.Empty)
            this.ClientChangeScene(this.m_OfflineScene, false);

              NetworkClient.ShutdownAll();
        }
        private void OnClientStart(NetworkClient client)
        {
            client.RegisterHandler(MessageIDs.PlayerInfoRequest, OnPlayerInfoRequest);
            client.RegisterHandler(MessageIDs.PlayerInfoUpdate, OnPlayerInfoUpdate);

            _net_mgr.ClientConnect += OnClientConnect;
            _net_mgr.ClientDisconnect += OnClientDisconnect;
        }
 internal static void RegisterSystemHandlers(NetworkClient client, bool localClient)
 {
   if (localClient)
   {
     client.RegisterHandlerSafe((short) 1, new NetworkMessageDelegate(ClientScene.OnLocalClientObjectDestroy));
     client.RegisterHandlerSafe((short) 13, new NetworkMessageDelegate(ClientScene.OnLocalClientObjectHide));
     client.RegisterHandlerSafe((short) 3, new NetworkMessageDelegate(ClientScene.OnLocalClientObjectSpawn));
     client.RegisterHandlerSafe((short) 10, new NetworkMessageDelegate(ClientScene.OnLocalClientObjectSpawnScene));
     client.RegisterHandlerSafe((short) 15, new NetworkMessageDelegate(ClientScene.OnClientAuthority));
   }
   else
   {
     client.RegisterHandlerSafe((short) 3, new NetworkMessageDelegate(ClientScene.OnObjectSpawn));
     client.RegisterHandlerSafe((short) 10, new NetworkMessageDelegate(ClientScene.OnObjectSpawnScene));
     client.RegisterHandlerSafe((short) 12, new NetworkMessageDelegate(ClientScene.OnObjectSpawnFinished));
     client.RegisterHandlerSafe((short) 1, new NetworkMessageDelegate(ClientScene.OnObjectDestroy));
     client.RegisterHandlerSafe((short) 13, new NetworkMessageDelegate(ClientScene.OnObjectDestroy));
     client.RegisterHandlerSafe((short) 8, new NetworkMessageDelegate(ClientScene.OnUpdateVarsMessage));
     client.RegisterHandlerSafe((short) 4, new NetworkMessageDelegate(ClientScene.OnOwnerMessage));
     client.RegisterHandlerSafe((short) 9, new NetworkMessageDelegate(ClientScene.OnSyncListMessage));
     client.RegisterHandlerSafe((short) 40, new NetworkMessageDelegate(NetworkAnimator.OnAnimationClientMessage));
     client.RegisterHandlerSafe((short) 41, new NetworkMessageDelegate(NetworkAnimator.OnAnimationParametersClientMessage));
     client.RegisterHandlerSafe((short) 15, new NetworkMessageDelegate(ClientScene.OnClientAuthority));
   }
   client.RegisterHandlerSafe((short) 2, new NetworkMessageDelegate(ClientScene.OnRPCMessage));
   client.RegisterHandlerSafe((short) 7, new NetworkMessageDelegate(ClientScene.OnSyncEventMessage));
   client.RegisterHandlerSafe((short) 42, new NetworkMessageDelegate(NetworkAnimator.OnAnimationTriggerClientMessage));
 }
Beispiel #15
0
		// ===========================================================================
		// ========================= UTILITY FUNCTIONS =========================
		// ===========================================================================

		void registerAllCallbacks ( NetworkClient nc, NetworkMessageDelegate nmd )
		{
			foreach (Message.ID MsgId in System.Enum.GetValues(typeof(Message.ID))) // Register all the callbacks
				nc.RegisterHandler((short)MsgId, nmd);
		}
Beispiel #16
0
 private static void RegisterClientPrefabsNStuff(On.RoR2.Networking.GameNetworkManager.orig_OnStartClient orig, RoR2.Networking.GameNetworkManager self, UnityEngine.Networking.NetworkClient newClient)
 {
     orig(self, newClient);
     foreach (HashStruct h in thingsToHash)
     {
         if (h.prefab.HasComponent <NetworkIdentity>())
         {
             h.prefab.GetComponent <NetworkIdentity>().SetFieldValue <NetworkHash128>("m_AssetId", nullHash);
         }
         ClientScene.RegisterPrefab(h.prefab, NetworkHash128.Parse(MakeHash(h.goName + h.callPath + h.callMember + h.callLine.ToString())));
     }
 }
        // Connections methods return a NetworkClient object, this method connects according to the endpoint being used
        public NetworkClient StartClient(MatchInfo info, ConnectionConfig config)
        {
            this.matchInfo = info;

              if (this.m_RunInBackground)
            Application.runInBackground = true;

              this.isNetworkActive = true;
              this.client = new NetworkClient();
              this.OnStartClient(this.client);

              // if not using a custom config
              if (config != null)
            this.client.Configure(config, 1);
              else if (this.m_CustomConfig && this.m_ConnectionConfig != null) // else using a custom config setup for our clients
              {
            this.m_ConnectionConfig.Channels.Clear();
            using (List<QosType>.Enumerator enumerator = this.m_Channels.GetEnumerator())
            {
              while (enumerator.MoveNext())
              {
            int num = (int) this.m_ConnectionConfig.AddChannel(enumerator.Current);
              }
            }
            this.client.Configure(this.m_ConnectionConfig, this.m_MaxConnections);
              }

              this.RegisterClientMessages(this.client); // register client handlers

              // if a match was sent in then connect to that game
              if (this.matchInfo != null)
              {
            if (LogFilter.logDebug)
              Debug.Log((object) ("NetworkManager StartClient match: " + (object) this.matchInfo));
            this.client.Connect(this.matchInfo);
              }
              else if (this.m_EndPoint != null) // if we are connecting to an endpoint used by something like XboxOne, then connect there
              {
            if (LogFilter.logDebug)
              Debug.Log((object) "NetworkManager StartClient using provided SecureTunnel");
            this.client.Connect(this.m_EndPoint);
              }
              else // we are going to local connect otherwise if address has been set
              {
            if (string.IsNullOrEmpty(this.m_NetworkAddress))
            {
              if (LogFilter.logError)
            Debug.LogError((object) "Must set the Network Address field in the manager");
              return (NetworkClient) null;
            }
            if (LogFilter.logDebug)
            {
              object[] objArray = new object[4];
              int index1 = 0;
              string str1 = "NetworkManager StartClient address:";
              objArray[index1] = (object) str1;
              int index2 = 1;
              string str2 = this.m_NetworkAddress;
              objArray[index2] = (object) str2;
              int index3 = 2;
              string str3 = " port:";
              objArray[index3] = (object) str3;
              int index4 = 3;
              // ISSUE: variable of a boxed type
              __Boxed<int> local = (ValueType) this.m_NetworkPort;
              objArray[index4] = (object) local;
              Debug.Log((object) string.Concat(objArray));
            }

            // if using simulator connect that way, otherwise just complete the local network connect
            if (this.m_UseSimulator)
              this.client.ConnectWithSimulator(this.m_NetworkAddress, this.m_NetworkPort, this.m_SimulatedLatency, this.m_PacketLossPercentage);
            else
              this.client.Connect(this.m_NetworkAddress, this.m_NetworkPort);
              }

              NetworkManager.s_address = this.m_NetworkAddress;

              return this.client;
        }
 void OnStartClient(NetworkClient client)
 {
     networkManager.OnStartClient (client);
     joining = true;
 }
        // This provided NetManager accounts for a client, server, or host. Register handlers for a client here using the NetworkClient field
        internal void RegisterClientMessages(NetworkClient client)
        {
            client.RegisterHandler((short) 32, new NetworkMessageDelegate(this.OnClientConnectInternal));
              client.RegisterHandler((short) 33, new NetworkMessageDelegate(this.OnClientDisconnectInternal));
              client.RegisterHandler((short) 36, new NetworkMessageDelegate(this.OnClientNotReadyMessageInternal));
              client.RegisterHandler((short) 34, new NetworkMessageDelegate(this.OnClientErrorInternal));
              client.RegisterHandler((short) 39, new NetworkMessageDelegate(this.OnClientSceneInternal));

              // handle the registering of the clients prefab also so it doesnt need to be done manually from separate client code
              if ((UnityEngine.Object) this.m_PlayerPrefab != (UnityEngine.Object) null)
            ClientScene.RegisterPrefab(this.m_PlayerPrefab);

              // Also register any prefabs added in the inspector so they are included in the game for the client, no manual client code also needed
              using (List<GameObject>.Enumerator enumerator = this.m_SpawnPrefabs.GetEnumerator())
              {
            while (enumerator.MoveNext())
            {
              GameObject current = enumerator.Current;
              if ((UnityEngine.Object) current != (UnityEngine.Object) null)
            ClientScene.RegisterPrefab(current);
            }
              }
        }
 /// <summary>
 ///   <para>Used to initialize the migration manager with client and match information.</para>
 /// </summary>
 /// <param name="newClient">The NetworkClient being used to connect to the host.</param>
 /// <param name="newMatchInfo">Information about the match being used. This may be null if there is no match.</param>
 public void Initialize(NetworkClient newClient, MatchInfo newMatchInfo)
 {
   if (LogFilter.logDev)
     Debug.Log((object) "NetworkMigrationManager initialize");
   this.m_Client = newClient;
   this.m_MatchInfo = newMatchInfo;
   newClient.RegisterHandlerSafe((short) 11, new NetworkMessageDelegate(this.OnPeerInfo));
   newClient.RegisterHandlerSafe((short) 17, new NetworkMessageDelegate(this.OnPeerClientAuthority));
   NetworkIdentity.clientAuthorityCallback = new NetworkIdentity.ClientAuthorityCallback(this.AssignAuthorityCallback);
 }
        // used in Update to complete loading of a scene
        private void FinishLoadScene()
        {
            if (this.client == null)
              {
            if (LogFilter.logDebug)
              Debug.LogWarning((object) "FinishLoadScene client is null");
            if (NetworkClient.allClients.Count > 0)
              this.client = NetworkClient.allClients[0];
              }
              if (this.client != null)
              {
            if (NetworkManager.s_ClientReadyConnection != null)
            {
              this.OnClientConnect(NetworkManager.s_ClientReadyConnection);
              NetworkManager.s_ClientReadyConnection = (NetworkConnection) null;
            }
              }
              else if (LogFilter.logDev)
            Debug.Log((object) "FinishLoadScene client is STILL null");

              if (NetworkServer.active)
              {
            NetworkServer.SpawnObjects();
            this.OnServerSceneChanged(NetworkManager.networkSceneName);
              }

              if (!NetworkClient.active || NetworkServer.active)
            ;

              if (!NetworkClient.active)
            return;

              this.RegisterClientMessages(this.client);
              this.OnClientSceneChanged(this.client.connection);
        }
	// Client Message Handlers
	override public void OnStartClient(NetworkClient client)
	{
		base.OnStartClient(client);
		ClientStarted(client);
		_is_singleplayer = false;
		_is_client = true;
	}
 /// <summary>
 ///   <para>This allows the NetworkManager to use a client object created externally to the NetworkManager instead of using StartClient().</para>
 /// </summary>
 /// <param name="externalClient">The NetworkClient object to use.</param>
 public void UseExternalClient(NetworkClient externalClient)
 {
   if (this.m_RunInBackground)
     Application.runInBackground = true;
   if (externalClient != null)
   {
     this.client = externalClient;
     this.isNetworkActive = true;
     this.RegisterClientMessages(this.client);
     this.OnStartClient(this.client);
   }
   else
   {
     this.OnStopClient();
     ClientScene.DestroyAllClientObjects();
     ClientScene.HandleClientDisconnect(this.client.connection);
     this.client = (NetworkClient) null;
     if (this.m_OfflineScene != string.Empty)
       this.ClientChangeScene(this.m_OfflineScene, false);
   }
   NetworkManager.s_Address = this.m_NetworkAddress;
 }
Beispiel #24
0
 internal void RegisterClientMessages(NetworkClient client)
 {
     client.RegisterHandler(0x20, new NetworkMessageDelegate(this.OnClientConnectInternal));
     client.RegisterHandler(0x21, new NetworkMessageDelegate(this.OnClientDisconnectInternal));
     client.RegisterHandler(0x24, new NetworkMessageDelegate(this.OnClientNotReadyMessageInternal));
     client.RegisterHandler(0x22, new NetworkMessageDelegate(this.OnClientErrorInternal));
     client.RegisterHandler(0x27, new NetworkMessageDelegate(this.OnClientSceneInternal));
     if (this.m_PlayerPrefab != null)
     {
         ClientScene.RegisterPrefab(this.m_PlayerPrefab);
     }
     foreach (GameObject obj2 in this.m_SpawnPrefabs)
     {
         if (obj2 != null)
         {
             ClientScene.RegisterPrefab(obj2);
         }
     }
 }
 private NetworkClient ConnectLocalClient()
 {
   if (LogFilter.logDebug)
     Debug.Log((object) ("NetworkManager StartHost port:" + (object) this.m_NetworkPort));
   this.m_NetworkAddress = "localhost";
   this.client = ClientScene.ConnectLocalServer();
   this.RegisterClientMessages(this.client);
   if ((UnityEngine.Object) this.m_MigrationManager != (UnityEngine.Object) null)
     this.m_MigrationManager.Initialize(this.client, this.matchInfo);
   return this.client;
 }
Beispiel #26
0
 public NetworkClient StartClient(MatchInfo info, ConnectionConfig config)
 {
     this.matchInfo = info;
     if (this.m_RunInBackground)
     {
         Application.runInBackground = true;
     }
     this.isNetworkActive = true;
     this.client = new NetworkClient();
     if (config != null)
     {
         this.client.Configure(config, 1);
     }
     else if (this.m_CustomConfig && (this.m_ConnectionConfig != null))
     {
         this.m_ConnectionConfig.Channels.Clear();
         foreach (QosType type in this.m_Channels)
         {
             this.m_ConnectionConfig.AddChannel(type);
         }
         this.client.Configure(this.m_ConnectionConfig, this.m_MaxConnections);
     }
     this.RegisterClientMessages(this.client);
     if (this.matchInfo != null)
     {
         if (LogFilter.logDebug)
         {
             Debug.Log("NetworkManager StartClient match: " + this.matchInfo);
         }
         this.client.Connect(this.matchInfo);
     }
     else if (this.m_EndPoint != null)
     {
         if (LogFilter.logDebug)
         {
             Debug.Log("NetworkManager StartClient using provided SecureTunnel");
         }
         this.client.Connect(this.m_EndPoint);
     }
     else
     {
         if (string.IsNullOrEmpty(this.m_NetworkAddress))
         {
             if (LogFilter.logError)
             {
                 Debug.LogError("Must set the Network Address field in the manager");
             }
             return null;
         }
         if (LogFilter.logDebug)
         {
             Debug.Log(string.Concat(new object[] { "NetworkManager StartClient address:", this.m_NetworkAddress, " port:", this.m_NetworkPort }));
         }
         if (this.m_UseSimulator)
         {
             this.client.ConnectWithSimulator(this.m_NetworkAddress, this.m_NetworkPort, this.m_SimulatedLatency, this.m_PacketLossPercentage);
         }
         else
         {
             this.client.Connect(this.m_NetworkAddress, this.m_NetworkPort);
         }
     }
     this.OnStartClient(this.client);
     s_Address = this.m_NetworkAddress;
     return this.client;
 }
        /// <summary>
        /// Called on every client after connecting to a server.
        /// </summary>
        /// <param name="client"></param>
        public override void OnStartClient(NetworkClient client)
        {
            base.OnStartClient(client);

            // Register our custom game player prefabs with the client scene
            foreach (var prefab in playerPrefabs)
                ClientScene.RegisterPrefab(prefab);
        }
 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(0x2b, new NetworkMessageDelegate(this.OnClientReadyToBegin));
     lobbyClient.RegisterHandler(0x2d, new NetworkMessageDelegate(this.OnClientAddPlayerFailedMessage));
     this.OnLobbyStartClient(lobbyClient);
 }
        public override void OnStartClient(NetworkClient client)
        {
            if (this.lobbySlots.Length == 0)
            this.lobbySlots = new NetworkLobbyPlayer[this.maxPlayers];

              if ((UnityEngine.Object) this.m_LobbyPlayerPrefab == (UnityEngine.Object) null || (UnityEngine.Object) this.m_LobbyPlayerPrefab.gameObject == (UnityEngine.Object) null)
              {
            if (LogFilter.logError)
              Debug.LogError((object) "NetworkLobbyManager no LobbyPlayer prefab is registered. Please add a LobbyPlayer prefab.");
              }
              else
            ClientScene.RegisterPrefab(this.m_LobbyPlayerPrefab.gameObject);

              if ((UnityEngine.Object) this.m_GamePlayerPrefab == (UnityEngine.Object) null)
              {
            if (LogFilter.logError)
              Debug.LogError((object) "NetworkLobbyManager no GamePlayer prefab is registered. Please add a GamePlayer prefab.");
              }
              else
            ClientScene.RegisterPrefab(this.m_GamePlayerPrefab);

              client.RegisterHandler((short) 43, new NetworkMessageDelegate(this.OnClientReadyToBegin));
              client.RegisterHandler((short) 45, new NetworkMessageDelegate(this.OnClientAddPlayerFailedMessage));
              this.OnLobbyStartClient(client);
        }
        public override void OnStartClient(NetworkClient client)
        {
            VoiceChatNetworkProxy.OnManagerStartClient(client);

            gameObject.AddComponent<VoiceChatUi>();
        }
Beispiel #31
0
        void Start()
        {
            NetworkManager netManager = FindObjectOfType<NetworkManager>();

            if (netManager == null) return;

            Debug.Log("found netManager");

            client = netManager.client;
            if (client.isConnected)
                client.RegisterHandler(CHAT_MSG, ClientReceiveChatMessage);
            if (isServer)
                NetworkServer.RegisterHandler(CHAT_MSG, ServerReceiveChatMessage);
        }
Beispiel #32
0
 public virtual void OnLobbyStartClient(NetworkClient lobbyClient)
 {
 }