// ------------------------------------------- /* * CreateRoom */ private void CreateRoom() { SoundsController.Instance.PlaySingleSound(SoundsConfiguration.SOUND_SELECTION_FX); string ipAddress = m_container.Find("IPAddress").GetComponent <InputField>().text; int portNumber = int.Parse(m_container.Find("PortAddress").GetComponent <InputField>().text); if (ipAddress.Length < 5) { UIEventController.Instance.DispatchUIEvent(UIEventController.EVENT_SCREENMANAGER_OPEN_INFORMATION_SCREEN, ScreenInformationView.SCREEN_INFORMATION, UIScreenTypePreviousAction.KEEP_CURRENT_SCREEN, LanguageController.Instance.GetText("message.error"), LanguageController.Instance.GetText("screen.lobby.setup.server.invalid.ip"), null, ""); } else { if (portNumber < 2000) { UIEventController.Instance.DispatchUIEvent(UIEventController.EVENT_SCREENMANAGER_OPEN_INFORMATION_SCREEN, ScreenInformationView.SCREEN_INFORMATION, UIScreenTypePreviousAction.KEEP_CURRENT_SCREEN, LanguageController.Instance.GetText("message.error"), LanguageController.Instance.GetText("screen.lobby.setup.server.invalid.portnumber"), null, ""); } else { PlayerPrefs.SetString(PLAYERPREFS_YNT_IP, ipAddress); PlayerPrefs.SetString(PLAYERPREFS_YNT_PORT, portNumber.ToString()); MultiplayerConfiguration.SaveIPAddressServer(ipAddress); MultiplayerConfiguration.SavePortServer(portNumber); UIEventController.Instance.DispatchUIEvent(UIEventController.EVENT_SCREENMANAGER_OPEN_GENERIC_SCREEN, ScreenRemoteModeView.SCREEN_NAME, UIScreenTypePreviousAction.DESTROY_ALL_SCREENS, false, null); Destroy(); } } }
// ------------------------------------------- /* * Constructor */ public override void Initialize(params object[] _list) { base.Initialize(_list); m_root = this.gameObject; m_container = m_root.transform.Find("Content"); #if !ALTERNATIVE_TITLE m_container.Find("Title").GetComponent <Text>().text = LanguageController.Instance.GetText("message.game.title"); #else m_container.Find("Title").GetComponent <Text>().text = LanguageController.Instance.GetText("message.game.mobile.title"); #endif GameObject playAsCustomer = m_container.Find("Button_Customer").gameObject; playAsCustomer.transform.Find("Text").GetComponent <Text>().text = LanguageController.Instance.GetText("screen.play.as.customer"); playAsCustomer.GetComponent <Button>().onClick.AddListener(PlayAsCustomer); GameObject playAsDirector = m_container.Find("Button_Director").gameObject; playAsDirector.transform.Find("Text").GetComponent <Text>().text = LanguageController.Instance.GetText("screen.play.as.director"); playAsDirector.GetComponent <Button>().onClick.AddListener(PlayAsDirector); GameObject playAsSpectator = m_container.Find("Button_Spectator").gameObject; if (playAsSpectator != null) { playAsSpectator.transform.Find("Text").GetComponent <Text>().text = LanguageController.Instance.GetText("screen.play.as.spectator"); playAsSpectator.GetComponent <Button>().onClick.AddListener(PlayAsSpectator); } MultiplayerConfiguration.SaveSpectatorMode(MultiplayerConfiguration.SPECTATOR_MODE_DISABLED); UIEventController.Instance.UIEvent += new UIEventHandler(OnMenuEvent); }
// ------------------------------------------- /* * InitializeLocalData */ public void InitializeLocalData(string _initialData) { if (MultiplayerConfiguration.LoadNumberOfPlayers() == 1) { InitializeWithData(_initialData); } }
// ------------------------------------------- /* * ConfirmNumberPlayers */ private void ConfirmNumberPlayers() { bool loadNextScreen = true; if (loadNextScreen) { SoundsController.Instance.PlaySingleSound(SoundsConfiguration.SOUND_SELECTION_FX); if (MenuScreenController.Instance.EnableAppOrganization) { UIEventController.Instance.DispatchUIEvent(EVENT_SCREENNUMBERPLAYERS_SET_NUMBER_PLAYERS, FinalNumberOfPlayers); GoBackPressed(); } else { UIEventController.Instance.DispatchUIEvent(MenuScreenController.EVENT_MENUEVENTCONTROLLER_CREATED_NEW_GAME, FinalNumberOfPlayers); if (FinalNumberOfPlayers == 1) { MultiplayerConfiguration.SaveDirectorMode(MultiplayerConfiguration.DIRECTOR_MODE_DISABLED); MenuScreenController.Instance.ScreenGameOptions = ScreenCharacterSelectionView.SCREEN_NAME; } else { MenuScreenController.Instance.ScreenGameOptions = ScreenDirectorModeView.SCREEN_NAME; } MenuScreenController.Instance.LoadCustomGameScreenOrCreateGame(false, FinalNumberOfPlayers, "", null); } } }
// ------------------------------------------- /* * PlayInVRPressed */ private void PlayInVRPressed() { SoundsController.Instance.PlaySingleSound(SoundsConfiguration.SOUND_SELECTION_FX); CardboardLoaderVR.Instance.SaveEnableCardboard(true); #if ENABLE_GOOGLE_ARCORE if (!MenuScreenController.Instance.AskToEnableBackgroundARCore || (MultiplayerConfiguration.LoadGoogleARCore(-1) != MultiplayerConfiguration.GOOGLE_ARCORE_ENABLED)) { FinalLoadGameWithAssets(); } else { if (MenuScreenController.Instance.AlphaAnimationNameStack != -1) { UIEventController.Instance.DispatchUIEvent(UIEventController.EVENT_SCREENMANAGER_OPEN_LAYER_GENERIC_SCREEN, -1, new List <object> { ScreenController.ANIMATION_ALPHA, 0f, 1f, MenuScreenController.Instance.AlphaAnimationNameStack }, ScreenEnableBackground.SCREEN_NAME, UIScreenTypePreviousAction.DESTROY_ALL_SCREENS, false, m_nameOfScreen); } else { UIEventController.Instance.DispatchUIEvent(UIEventController.EVENT_SCREENMANAGER_OPEN_GENERIC_SCREEN, ScreenEnableBackground.SCREEN_NAME, UIScreenTypePreviousAction.DESTROY_ALL_SCREENS, false, m_nameOfScreen); } } #else if (MenuScreenController.Instance.RequestPermissionAssetBundleDownload) { RequestDownloadAssetBundle(); } else { FinalLoadGameWithAssets(); } #endif }
// ------------------------------------------- /* * Constructor */ public override void Initialize(params object[] _list) { base.Initialize(_list); m_root = this.gameObject; m_container = m_root.transform.Find("Content"); #if !ALTERNATIVE_TITLE m_container.Find("Title").GetComponent <Text>().text = LanguageController.Instance.GetText("message.game.title"); #else m_container.Find("Title").GetComponent <Text>().text = LanguageController.Instance.GetText("message.game.mobile.title"); #endif GameObject playWithARCore = m_container.Find("Button_WithARCore").gameObject; playWithARCore.transform.Find("Text").GetComponent <Text>().text = LanguageController.Instance.GetText("screen.play.with.arcore"); playWithARCore.GetComponent <Button>().onClick.AddListener(PlayWithARCore); GameObject playWithoutARCore = m_container.Find("Button_WithoutARCore").gameObject; playWithoutARCore.transform.Find("Text").GetComponent <Text>().text = LanguageController.Instance.GetText("screen.play.without.arcore"); playWithoutARCore.GetComponent <Button>().onClick.AddListener(PlayWithoutARCore); MultiplayerConfiguration.SaveEnableBackground(true); UIEventController.Instance.UIEvent += new UIEventHandler(OnMenuEvent); }
// ------------------------------------------- /* * PlayLocalGame */ private void PlayLocalGame() { #if ENABLE_PHOTON if (GameObject.FindObjectOfType <PhotonController>() != null) { PhotonController.Instance.Destroy(); } #elif ENABLE_NAKAMA if (GameObject.FindObjectOfType <NakamaController>() != null) { NakamaController.Instance.Destroy(); } #endif NetworkEventController.Instance.MenuController_SetLocalGame(true); NetworkEventController.Instance.MenuController_SetLobbyMode(false); SoundsController.Instance.PlaySingleSound(SoundsConfiguration.SOUND_SELECTION_FX); #if UNITY_WEBGL MultiplayerConfiguration.SaveDirectorMode(MultiplayerConfiguration.DIRECTOR_MODE_DISABLED); UIEventController.Instance.DispatchUIEvent(MenuScreenController.EVENT_MENUEVENTCONTROLLER_CREATED_NEW_GAME, 1); CardboardLoaderVR.Instance.SaveEnableCardboard(false); MenuScreenController.Instance.LoadCustomGameScreenOrCreateGame(false, 1, "", null); #else if (MenuScreenController.Instance.AlphaAnimationNameStack != -1) { UIEventController.Instance.DispatchUIEvent(UIEventController.EVENT_SCREENMANAGER_OPEN_LAYER_GENERIC_SCREEN, -1, new List <object> { ScreenController.ANIMATION_ALPHA, 0f, 1f, MenuScreenController.Instance.AlphaAnimationNameStack }, ScreenMenuLocalGameView.SCREEN_NAME, UIScreenTypePreviousAction.DESTROY_ALL_SCREENS, false, null); } else { UIEventController.Instance.DispatchUIEvent(UIEventController.EVENT_SCREENMANAGER_OPEN_GENERIC_SCREEN, ScreenMenuLocalGameView.SCREEN_NAME, UIScreenTypePreviousAction.DESTROY_ALL_SCREENS, false, m_nameOfScreen); } #endif }
// ------------------------------------------- /* * PlayInVRPressed */ private void EnableBackgroundVR() { SoundsController.Instance.PlaySingleSound(SoundsConfiguration.SOUND_SELECTION_FX); MultiplayerConfiguration.SaveEnableBackground(true); MenuScreenController.Instance.LoadGameScene(this); }
// ------------------------------------------- /* * Will create the socket connection */ public void MenuController_InitialitzationSocket(int _numberRoom, int _idMachineHost) { #if ENABLE_PHOTON PhotonController.Instance.Login(); #elif ENABLE_NAKAMA NakamaController.Instance.Initialitzation(); #else ClientTCPEventsController.Instance.Initialitzation(MultiplayerConfiguration.LoadIPAddressServer(), MultiplayerConfiguration.LoadPortServer(), MultiplayerConfiguration.LoadRoomNumberInServer(_numberRoom), MultiplayerConfiguration.LoadMachineIDServer(_idMachineHost), MultiplayerConfiguration.LoadBufferSizeReceive(), MultiplayerConfiguration.LoadTimeoutReceive(), MultiplayerConfiguration.LoadBufferSizeSend(), MultiplayerConfiguration.LoadTimeoutSend()); #endif }
// ------------------------------------------- /* * Will create a new room for lobby */ public void MenuController_CreateNewLobbyRoom(string _nameLobby, int _finalNumberOfPlayers, string _extraData) { MultiplayerConfiguration.SaveNameRoomLobby(_nameLobby); #if ENABLE_BALANCE_LOADER UIEventController.Instance.DispatchUIEvent(MenuScreenController.EVENT_MENUEVENTCONTROLLER_SHOW_LOADING_MESSAGE); CommsHTTPConfiguration.CreateNewRoom(true, _nameLobby, ClientTCPEventsController.GetPlayersString(_finalNumberOfPlayers), _extraData); #else MenuController_CreateRoomForLobby(_nameLobby, _finalNumberOfPlayers, _extraData); #endif }
// ------------------------------------------- /* * Informs if the object belongs to the local player */ public bool IsLocalPlayer() { if (MultiplayerConfiguration.LoadNumberOfPlayers() != 1) { return(CommunicationsController.Instance.NetworkID == NetID); } else { return(true); } }
// ------------------------------------------- /* * Will load the game scene after 1 second delay */ public void MenuController_LoadGameScene(string _targetScene) { if (m_targetScene.Length == 0) { m_targetScene = _targetScene; #if ENABLE_OCULUS || ENABLE_WORLDSENSE || ENABLE_HTCVIVE || ENABLE_PICONEO MultiplayerConfiguration.SaveDirectorMode(MultiplayerConfiguration.DIRECTOR_MODE_DISABLED); #endif StartCoroutine(LoadScene()); } }
// ------------------------------------------- /* * Check it the actor belongs to the current player */ public bool IsMine() { if (MultiplayerConfiguration.LoadNumberOfPlayers() != 1) { return(YourNetworkTools.Instance.GetUniversalNetworkID() == NetworkID.NetID); } else { return(true); } }
// ------------------------------------------- /* * Will create a new room for friends */ public void MenuController_CreateNewFacebookRoom(string _friends, List <string> _friendsIDs, string _extraData) { #if ENABLE_BALANCE_LOADER UIEventController.Instance.DispatchUIEvent(MenuScreenController.EVENT_MENUEVENTCONTROLLER_SHOW_LOADING_MESSAGE); MultiplayerConfiguration.SaveFriendsGame(_friends); MultiplayerConfiguration.SaveNumberOfPlayers(_friends.Split(',').Length); CommsHTTPConfiguration.CreateNewRoom(false, FacebookController.Instance.NameHuman, _friends, _extraData); #else ClientTCPEventsController.Instance.CreateRoomForFriends(_friendsIDs.ToArray(), _extraData); #endif }
// ------------------------------------------- /* * SelectedLevel */ private void SelectedLevel() { if (m_indexSelected == -1) { UIEventController.Instance.DispatchUIEvent(UIEventController.EVENT_SCREENMANAGER_OPEN_INFORMATION_SCREEN, ScreenInformationView.SCREEN_INFORMATION, UIScreenTypePreviousAction.KEEP_CURRENT_SCREEN, LanguageController.Instance.GetText("message.warning"), LanguageController.Instance.GetText("message.you.should.select.an.item"), null, ""); } else { SoundsController.Instance.PlaySingleSound(SoundsConfiguration.SOUND_SELECTION_FX); MultiplayerConfiguration.SaveLevel6DOF(m_indexSelected); NextScreen(); } }
// ------------------------------------------- /* * PlayInVRPressed */ private void PlayWithARCore() { SoundsController.Instance.PlaySingleSound(SoundsConfiguration.SOUND_SELECTION_FX); MultiplayerConfiguration.SaveGoogleARCore(MultiplayerConfiguration.GOOGLE_ARCORE_ENABLED); if (MenuScreenController.Instance.EnableAppOrganization) { UIEventController.Instance.DispatchUIEvent(EVENT_SCREENARCORE_ENABLED_ARCORE, true); GoBackPressed(); } else { MenuScreenController.Instance.LoadGameScene(this); } }
// ------------------------------------------- /* * PlayAsCustomer */ private void PlayAsCustomer() { SoundsController.Instance.PlaySingleSound(SoundsConfiguration.SOUND_SELECTION_FX); MultiplayerConfiguration.SaveDirectorMode(MultiplayerConfiguration.DIRECTOR_MODE_DISABLED); if (MenuScreenController.Instance.EnableAppOrganization) { UIEventController.Instance.DispatchUIEvent(EVENT_SCREENDIRECTORMODE_SELECTED_PROFILE, FunctionsScreenController.PROFILE_PLAYER.PLAYER); GoBackPressed(); } else { NextscreenForPlayAsCustomer(); } }
// ------------------------------------------- /* * Will dispatch an event that will destroy the object in all the network */ void OnDestroy() { #if DEBUG_MODE_DISPLAY_LOG Debug.LogError("[ActorNetwork] ++SEND++ SIGNAL FOR AUTODESTRUCTION"); #endif if (NetworkEventController.Instance != null) { NetworkEventController.Instance.NetworkEvent -= OnNetworkEvent; } if (MultiplayerConfiguration.LoadNumberOfPlayers() != 1) { NetworkEventController.Instance?.DispatchNetworkEvent(NetworkEventController.EVENT_WORLDOBJECTCONTROLLER_DESTROY_REQUEST, NetworkID.NetID.ToString(), NetworkID.UID.ToString()); } }
// ------------------------------------------- /* * LoadGame */ private void LoadGame(bool _setLevel) { if (MenuScreenController.Instance.EnableAppOrganization) { UIEventController.Instance.DispatchUIEvent(EVENT_SCREENCHARACTERSELECTION_SELECTED_CHARACTER, m_indexSelected); GoBackPressed(); } else { #if ENABLE_SELECT_LEVEL UIEventController.Instance.DispatchUIEvent(UIEventController.EVENT_SCREENMANAGER_OPEN_GENERIC_SCREEN, ScreenLevelSelectionView.SCREEN_NAME, UIScreenTypePreviousAction.DESTROY_ALL_SCREENS, false, null); #elif ENABLE_GOOGLE_ARCORE UIEventController.Instance.DispatchUIEvent(UIEventController.EVENT_SCREENMANAGER_OPEN_GENERIC_SCREEN, ScreenEnableARCore.SCREEN_NAME, UIScreenTypePreviousAction.DESTROY_ALL_SCREENS, false, null); #else MultiplayerConfiguration.SaveGoogleARCore(MultiplayerConfiguration.GOOGLE_ARCORE_DISABLED); MenuScreenController.Instance.LoadGameScene(this); #endif } }
// ------------------------------------------- /* * PlayAsSpectator */ private void PlayAsSpectator() { if (MenuScreenController.Instance.EnableAppOrganization) { UIEventController.Instance.DispatchUIEvent(EVENT_SCREENDIRECTORMODE_SELECTED_PROFILE, FunctionsScreenController.PROFILE_PLAYER.SPECTATOR); GoBackPressed(); } else { if (NetworkEventController.Instance.MenuController_LoadNumberOfPlayers() == MultiplayerConfiguration.VALUE_FOR_JOINING) { MultiplayerConfiguration.SaveDirectorMode(MultiplayerConfiguration.DIRECTOR_MODE_ENABLED); MultiplayerConfiguration.SaveSpectatorMode(MultiplayerConfiguration.SPECTATOR_MODE_ENABLED); CardboardLoaderVR.Instance.SaveEnableCardboard(false); MultiplayerConfiguration.SaveGoogleARCore(MultiplayerConfiguration.GOOGLE_ARCORE_DISABLED); MenuScreenController.Instance.LoadGameScene(this); } } }
// ------------------------------------------- /* * PlayAsDirector */ private void PlayAsDirector() { SoundsController.Instance.PlaySingleSound(SoundsConfiguration.SOUND_SELECTION_FX); MultiplayerConfiguration.SaveDirectorMode(MultiplayerConfiguration.DIRECTOR_MODE_ENABLED); MultiplayerConfiguration.SaveGoogleARCore(MultiplayerConfiguration.GOOGLE_ARCORE_DISABLED); CardboardLoaderVR.Instance.SaveEnableCardboard(false); if (MenuScreenController.Instance.EnableAppOrganization) { UIEventController.Instance.DispatchUIEvent(EVENT_SCREENDIRECTORMODE_SELECTED_PROFILE, FunctionsScreenController.PROFILE_PLAYER.DIRECTOR); GoBackPressed(); } else { if (NetworkEventController.Instance.MenuController_LoadNumberOfPlayers() != MultiplayerConfiguration.VALUE_FOR_JOINING) { MultiplayerConfiguration.SaveCharacter6DOF(0); MultiplayerConfiguration.SaveLevel6DOF(0); } MenuScreenController.Instance.LoadGameScene(this); } }
// ------------------------------------------- /* * Start looking for a server to work as a client */ private void Start() { Debug.Log("NetworkDiscoveryUNET::START!!!!"); if (MultiplayerConfiguration.LoadNumberOfPlayers() == 1) { broadcastData = Utilities.RandomCodeGeneration(UnityEngine.Random.Range(0, 10).ToString()); broadcastKey = UnityEngine.Random.Range(2000, 6000); broadcastPort = UnityEngine.Random.Range(20000, 90000); broadcastSubVersion = UnityEngine.Random.Range(1, 9); NetworkEventController.Instance.DelayLocalEvent(NetworkEventController.EVENT_COMMUNICATIONSCONTROLLER_REGISTER_ALL_NETWORK_PREFABS, 0.2f); BasicSystemEventController.Instance.DelayBasicSystemEvent(CommunicationsController.EVENT_COMMSCONTROLLER_SET_UP_IS_SERVER, 0.3f); return; } // Initializes NetworkDiscovery. Initialize(); if (!CheckComponents()) { Debug.Log("Invalid configuration detected. Network Discovery disabled."); Destroy(this); return; } broadcastInterval = BroadcastInterval; // Start listening for broadcasts. StartAsClient(); float InvokeWaitTime = 3 * BroadcastInterval + Random.value * 3 * BroadcastInterval; Invoke("MaybeInitAsServer", InvokeWaitTime * 0.001f); NetworkEventController.Instance.NetworkEvent += new NetworkEventHandler(OnBasicEvent); }
// ------------------------------------------- /* * OnLocalPartyGame */ private void OnLocalPartyGame() { if (MenuScreenController.Instance.EnableAppOrganization) { UIEventController.Instance.DispatchUIEvent(EVENT_SCREENMAIN_LOCAL_OR_REMOTE_PARTY, true); GoBackPressed(); } else { NetworkEventController.Instance.MenuController_SetLocalGame(true); SoundsController.Instance.PlaySingleSound(SoundsConfiguration.SOUND_SELECTION_FX); #if UNITY_STANDALONE CardboardLoaderVR.Instance.SaveEnableCardboard(false); MultiplayerConfiguration.SaveDirectorMode(MultiplayerConfiguration.DIRECTOR_MODE_DISABLED); MultiplayerConfiguration.SaveGoogleARCore(MultiplayerConfiguration.GOOGLE_ARCORE_DISABLED); MenuScreenController.Instance.ScreenGameOptions = ScreenCharacterSelectionView.SCREEN_NAME; MenuScreenController.Instance.CreateRoomInServer(1, MultiplayerConfiguration.LoadExtraData()); #else UIEventController.Instance.DispatchUIEvent(UIEventController.EVENT_SCREENMANAGER_OPEN_GENERIC_SCREEN, ScreenMenuLocalGameView.SCREEN_NAME, UIScreenTypePreviousAction.DESTROY_ALL_SCREENS, false, null); #endif } }
// ------------------------------------------- /* * Returns the network identificator independently if it's a local or a remote game */ public int GetUniversalNetworkID() { if (IsLocalGame) { if (MultiplayerConfiguration.LoadNumberOfPlayers() != 1) { return(CommunicationsController.Instance.NetworkID); } else { return(1); } } else { #if ENABLE_PHOTON return(PhotonController.Instance.UniqueNetworkID); #elif ENABLE_NAKAMA return(NakamaController.Instance.UniqueNetworkID); #else return(ClientTCPEventsController.Instance.UniqueNetworkID); #endif } }
// ------------------------------------------- /* * We save the IP address we should connect */ public void MenuController_SaveIPAddressServer(string _value) { MultiplayerConfiguration.SaveIPAddressServer(_value); }
// ------------------------------------------- /* * Will save the ID of the machine which is hosting the room */ public void MenuController_SaveMachineIDServer(int _value) { MultiplayerConfiguration.SaveMachineIDServer(_value); }
// ------------------------------------------- /* * CreateGamePressed */ public void CreateGamePressed() { SoundsController.Instance.PlaySingleSound(SoundsConfiguration.SOUND_SELECTION_FX); if (MenuScreenController.Instance.ForceFixedPlayers != -1) { MenuScreenController.Instance.CreateRoomInServer(MenuScreenController.Instance.ForceFixedPlayers, MultiplayerConfiguration.LoadExtraData()); } else { if (MenuScreenController.Instance.AlphaAnimationNameStack != -1) { UIEventController.Instance.DispatchUIEvent(UIEventController.EVENT_SCREENMANAGER_OPEN_LAYER_GENERIC_SCREEN, -1, new List <object> { ScreenController.ANIMATION_ALPHA, 0f, 1f, MenuScreenController.Instance.AlphaAnimationNameStack }, ScreenMenuNumberPlayersView.SCREEN_NAME, UIScreenTypePreviousAction.DESTROY_ALL_SCREENS, false, null); } else { UIEventController.Instance.DispatchUIEvent(UIEventController.EVENT_SCREENMANAGER_OPEN_GENERIC_SCREEN, ScreenMenuNumberPlayersView.SCREEN_NAME, UIScreenTypePreviousAction.DESTROY_ALL_SCREENS, false, null); } } }
// ------------------------------------------- /* * Converts the normal GameObjects in Network GameObjects */ void Start() { System.Globalization.CultureInfo customCulture = (System.Globalization.CultureInfo)System.Threading.Thread.CurrentThread.CurrentCulture.Clone(); customCulture.NumberFormat.NumberDecimalSeparator = "."; System.Threading.Thread.CurrentThread.CurrentCulture = customCulture; NetworkEventController.Instance.NetworkEvent += new NetworkEventHandler(OnNetworkEvent); int isLocalGame = PlayerPrefs.GetInt(COOCKIE_IS_LOCAL_GAME, -1); if (isLocalGame == -1) { IsLocalGame = true; } else { IsLocalGame = false; } if (IsLocalGame) { if (MultiplayerConfiguration.LoadNumberOfPlayers() != 1) { // INSTANTIATE LOCAL NETWORK PREFAB MANAGERS for (int j = 0; j < LocalNetworkPrefabManagers.Length; j++) { Utilities.AddChild(transform, LocalNetworkPrefabManagers[j]); } // NETWORK VARIABLES MANAGER Utilities.AddChild(transform, NetworkVariablesManager); // ASSIGN THE GAME OBJECTS TO THE CONTROLLER WorldObjectController worldObjectController = GameObject.FindObjectOfType <WorldObjectController>(); if (worldObjectController != null) { int totalNumberLocalObjects = 0; for (int i = 0; i < GameObjects.Length; i++) { if (GameObjects[i].GetComponent <NetworkWorldObjectData>() != null) { totalNumberLocalObjects++; } } int counterAppWorldObjects = 0; worldObjectController.AppWorldObjects = new GameObject[totalNumberLocalObjects]; for (int i = 0; i < GameObjects.Length; i++) { GameObject prefabToNetwork = GameObjects[i]; if (prefabToNetwork.GetComponent <NetworkWorldObjectData>() != null) { prefabToNetwork.GetComponent <NetworkWorldObjectData>().enabled = true; #if ENABLE_MIRROR GameObject.FindObjectOfType <MirrorDiscoveryController>().spawnPrefabs.Add(prefabToNetwork); #endif if (prefabToNetwork.GetComponent <NetworkID>() != null) { prefabToNetwork.GetComponent <NetworkID>().enabled = false; } if (prefabToNetwork.GetComponent <ActorNetwork>() == null) { prefabToNetwork.AddComponent <ActorNetwork>(); } worldObjectController.AppWorldObjects[counterAppWorldObjects] = prefabToNetwork; counterAppWorldObjects++; } } } } else { NetworkEventController.Instance.DelayLocalEvent(NetworkEventController.EVENT_SYSTEM_INITIALITZATION_LOCAL_COMPLETED, 0.2f, 1); } } else { #if !ENABLE_PHOTON && !ENABLE_NAKAMA // CONNECT TO THE SERVER ClientTCPEventsController.Instance.Initialitzation(MultiplayerConfiguration.LoadIPAddressServer(), MultiplayerConfiguration.LoadPortServer(), MultiplayerConfiguration.LoadRoomNumberInServer(0), MultiplayerConfiguration.LoadMachineIDServer(0), MultiplayerConfiguration.LoadBufferSizeReceive(), MultiplayerConfiguration.LoadTimeoutReceive(), MultiplayerConfiguration.LoadBufferSizeSend(), MultiplayerConfiguration.LoadTimeoutSend()); // NETWORK VARIABLES MANAGER Utilities.AddChild(transform, NetworkVariablesManager); #elif !ENABLE_PHOTON && ENABLE_NAKAMA NakamaController.Instance.Initialitzation(); #endif // ADD NETWORK IDENTIFICATION TO THE GAME OBJECTS for (int i = 0; i < GameObjects.Length; i++) { GameObject prefabToNetwork = GameObjects[i]; if (prefabToNetwork.GetComponent <NetworkID>() == null) { prefabToNetwork.AddComponent <NetworkID>(); } else { prefabToNetwork.GetComponent <NetworkID>().enabled = true; } #if !DISABLE_UNET_COMMS if (prefabToNetwork.GetComponent <NetworkWorldObjectData>() != null) { prefabToNetwork.GetComponent <NetworkWorldObjectData>().enabled = false; } #endif if (prefabToNetwork.GetComponent <ActorNetwork>() == null) { prefabToNetwork.AddComponent <ActorNetwork>(); } } } m_hasBeenInitialized = true; NetworkEventController.Instance.DispatchLocalEvent(EVENT_YOURNETWORKTOOLS_CONTROLLER_STARTED); }
// ------------------------------------------- /* * UnPack a communication received and dispatch it to the system */ public void UnPackEventAndDispatch(string _package) { #if DEBUG_MODE_DISPLAY_LOG Debug.LogError("****UnPackEventAndDispatch::_package=" + _package); #endif // PROCESS ALL THE OTHER EVENTS string[] parameters = _package.Split(TOKEN_SEPARATOR_EVENTS); string nameEvent = parameters[0]; // PROCESS PACKAGE if (m_uniqueNetworkID != -1) { if (parameters.Length > 3) { int uniqueNetworkID = int.Parse(parameters[1]); if (uniqueNetworkID == m_uniqueNetworkID) { // Debug.LogError("ClientTCPEventsController::EVENT[" + nameEvent + "] IGNORED BECAUSE IT CAME FROM THIS ORIGIN"); return; } int originNetworkID = int.Parse(parameters[2]); int targetNetworkID = int.Parse(parameters[3]); string[] list = new string[parameters.Length - 4]; for (int i = 4; i < parameters.Length; i++) { list[i - 4] = parameters[i]; } NetworkEventController.Instance.DispatchCustomNetworkEvent(nameEvent, true, originNetworkID, targetNetworkID, list); } } else { // RETRIEVE THE UNIQUE NETWORK IDENTIFICATOR if (nameEvent == EVENT_CLIENT_TCP_ESTABLISH_NETWORK_ID) { m_room = int.Parse(parameters[4]); m_uidPlayer = parameters[5]; #if DEBUG_MODE_DISPLAY_LOG Debug.LogError("EVENT_CLIENT_TCP_ESTABLISH_NETWORK_ID::HAS BEEN ASSIGNED AVAILABLE ROOM[" + m_room + "]++++++++++"); #endif m_events.Add(Pack(EVENT_CLIENT_TCP_PLAYER_UID, -1, -1, (MultiplayerConfiguration.LoadIsRoomLobby() ? m_uidPlayer : FacebookController.Instance.Id))); if (GameObject.FindObjectOfType <YourNetworkTools>() == null) { UIEventController.Instance.DispatchUIEvent(EVENT_CLIENT_TCP_ESTABLISH_NETWORK_ID, m_room); } else { NetworkEventController.Instance.DelayLocalEvent(EVENT_CLIENT_TCP_ESTABLISH_NETWORK_ID, 1f, m_room); } } else { if (nameEvent == EVENT_CLIENT_TCP_LIST_OF_GAME_ROOMS) { string[] roomsInvited = parameters[4].Split(TOKEN_SEPARATOR_PARTY); m_roomsInvited.Clear(); m_roomsLobby.Clear(); for (int i = 0; i < roomsInvited.Length; i++) { string[] dataParty = roomsInvited[i].Split(TOKEN_SEPARATOR_PLAYERS_IDS); if (dataParty.Length > 1) { if (int.Parse(dataParty[0]) == 0) { m_roomsInvited.Add(new ItemMultiTextEntry(dataParty)); } else { m_roomsLobby.Add(new ItemMultiTextEntry(dataParty)); } } } UIEventController.Instance.DispatchUIEvent(EVENT_CLIENT_TCP_LIST_OF_GAME_ROOMS); } else { if (nameEvent == EVENT_CLIENT_TCP_CONNECTED_ROOM) { m_uniqueNetworkID = int.Parse(parameters[4]); m_idNetworkServer = int.Parse(parameters[5]); int totalNumberPlayers = int.Parse(parameters[6]); NetworkEventController.Instance.DispatchLocalEvent(NetworkEventController.EVENT_SYSTEM_INITIALITZATION_LOCAL_COMPLETED, m_uniqueNetworkID); BasicSystemEventController.Instance.DispatchBasicSystemEvent(CommunicationsController.EVENT_COMMSCONTROLLER_SET_UP_IS_SERVER); UIEventController.Instance.DispatchUIEvent(EVENT_CLIENT_TCP_CONNECTED_ROOM, totalNumberPlayers); #if DEBUG_MODE_DISPLAY_LOG Debug.LogError("EVENT_CLIENT_TCP_CONNECTED_ROOM::ASSIGNED LOCAL CLIENT NUMBER[" + m_uniqueNetworkID + "] IN THE ROOM[" + m_room + "] WHERE THE SERVER IS[" + m_idNetworkServer + "]++++++++++"); #endif } } } } }
// ------------------------------------------- /* * Manager of global events */ private void OnNetworkEvent(string _nameEvent, bool _isLocalEvent, int _networkOriginID, int _networkTargetID, params object[] _list) { if (_nameEvent == EVENT_YOURNETWORKTOOLS_INITIALITZATION_DATA) { string targetNetworkID = (string)_list[0]; string initialDataNetwork = (string)_list[1]; ActorNetwork[] networkActors = GameObject.FindObjectsOfType <ActorNetwork>(); // Debug.LogError("+++++++++++++EVENT_YOURNETWORKTOOLS_INITIALITZATION_DATA::TARGET[" + targetNetworkID + "]::data[" + initialDataNetwork + "]::TOTAL NETWORK ACTORS["+ networkActors.Length + "]"); for (int i = 0; i < networkActors.Length; i++) { IGameNetworkActor networkActor = networkActors[i].GetComponentInParent <IGameNetworkActor>(); if (networkActor != null) { if (networkActor.NetworkID.CheckID(targetNetworkID)) { networkActor.Initialize(initialDataNetwork); } } } } if (_nameEvent == ClientTCPEventsController.EVENT_CLIENT_TCP_ESTABLISH_NETWORK_ID) { #if ENABLE_BALANCE_LOADER int totalPlayersConfigurated = MultiplayerConfiguration.LoadNumberOfPlayers(); if (totalPlayersConfigurated != MultiplayerConfiguration.VALUE_FOR_JOINING) { string friends = MultiplayerConfiguration.LoadFriendsGame(); if (friends.Length > 0) { string[] friendIDs = friends.Split(','); int idRoomLobby = MultiplayerConfiguration.LoadRoomNumberInServer(-1); ClientTCPEventsController.Instance.CreateRoomForFriends(idRoomLobby, friendIDs, ""); } else { string nameRoomLobby = MultiplayerConfiguration.LoadNameRoomLobby(); if (nameRoomLobby.Length > 0) { int idRoomLobby = MultiplayerConfiguration.LoadRoomNumberInServer(-1); ClientTCPEventsController.Instance.CreateRoomForLobby(idRoomLobby, nameRoomLobby, totalPlayersConfigurated, ""); } else { throw new Exception("THERE IS NO NAME OF LOBBY TO CREATE A TCP CONNECTION"); } } } else { int idRoomLobby = MultiplayerConfiguration.LoadRoomNumberInServer(-1); if (idRoomLobby != -1) { if (MultiplayerConfiguration.LoadIsRoomLobby()) { ClientTCPEventsController.Instance.JoinRoomOfLobby(idRoomLobby, "null", ""); } else { ClientTCPEventsController.Instance.JoinRoomForFriends(idRoomLobby, "null", ""); } } else { throw new Exception("NO GOOD"); } } #endif } if (_nameEvent == ClientTCPEventsController.EVENT_CLIENT_TCP_CONNECTED_ROOM) { // Debug.LogError("EVENT_CLIENT_TCP_CONNECTED_ROOM::UniversalUniqueID[" + GetUniversalNetworkID() + "]"); } if (_nameEvent == NetworkEventController.EVENT_SYSTEM_INITIALITZATION_REMOTE_COMPLETED) { if (IsServer) { // Debug.LogError("++++++++++++++++++++SENDING INFORMATION ABOUT ALL EXISTING NETWORK OBJECTS+++++++++++++++++++++++++++++"); CheckInitializationObjects(); } } if (_nameEvent == NetworkEventController.EVENT_WORLDOBJECTCONTROLLER_LOCAL_CREATION_CONFIRMATION) { if (IsServer) { string keyNetworkGO = (string)_list[0]; CheckInitializationObjects(keyNetworkGO); } } if (_nameEvent == NetworkEventController.EVENT_WORLDOBJECTCONTROLLER_INITIAL_DATA) { if (IsServer) { if (!m_initialData.ContainsKey((string)_list[0])) { string keyNetworkGO = (string)_list[0]; string dataNetworkGO = (string)_list[1]; m_initialData.Add(keyNetworkGO, dataNetworkGO); // Debug.LogError("*************************************DATA ADDED TO LIST(" + keyNetworkGO + ")("+ dataNetworkGO + ")::TOTAL INITIAL DATA["+ m_initialData.Count + "]::TOTAL TCP PLAYERS["+m_tcpNetworkObjects.Count+"]"); CheckInitializationObjects(keyNetworkGO); } } } if (_nameEvent == EVENT_YOURNETWORKTOOLS_NETID_NEW) { if (IsServer) { // Debug.LogError("*************************************NEW TCP NETWORK OBJECT REGISTERED(" + m_tcpNetworkObjects.Count + "]"); CheckInitializationObjects(); } } if (_nameEvent == NetworkEventController.EVENT_WORLDOBJECTCONTROLLER_DESTROY_REQUEST) { DestroyNetworkObject(int.Parse((string)_list[0]), int.Parse((string)_list[1])); } if (_nameEvent == NetworkEventController.EVENT_COMMUNICATIONSCONTROLLER_CREATION_CONFIRMATION_NETWORK_OBJECT) { #if !DISABLE_UNET_COMMS m_unetNetworkObjects.Add(new NetworkWorldObject((GameObject)_list[0])); #endif } if (_nameEvent == NetworkEventController.EVENT_PLAYERCONNECTIONDATA_USER_DISCONNECTED) { Debug.Log("----------------------DISCONNECTED PLAYER[" + (int)_list[0] + "]"); } #if ENABLE_PHOTON if (_nameEvent == EVENT_YOURNETWORKTOOLS_CREATED_GAMEOBJECT) { GameObject newGO = (GameObject)_list[0]; if (!m_tcpNetworkObjects.Contains(newGO)) { m_tcpNetworkObjects.Add(newGO); NetworkEventController.Instance.DispatchLocalEvent(EVENT_YOURNETWORKTOOLS_NETID_NEW); } } #endif if (_nameEvent == ClientTCPEventsController.EVENT_CLIENT_TCP_TRANSFORM_DATA) { int NetID = (int)_list[0]; int UID = (int)_list[1]; int prefabIndex = (int)_list[2]; Vector3 position = (Vector3)_list[3]; Vector3 forward = (Vector3)_list[4]; Vector3 scale = (Vector3)_list[5]; object networkObject = GetNetworkObjectByID(NetID, UID); GameObject networkGameObject = null; if (networkObject == null) { m_networkIDReceived = NetID; networkGameObject = Utilities.AddChild(this.gameObject.transform, GetPrefabByName(GameObjects[prefabIndex].name)); networkGameObject.GetComponent <NetworkID>().IndexPrefab = GetPrefabIndexOfName(GameObjects[prefabIndex].name); networkGameObject.GetComponent <NetworkID>().NetID = NetID; networkGameObject.GetComponent <NetworkID>().UID = UID; m_tcpNetworkObjects.Add(networkGameObject); networkGameObject.transform.position = position; networkGameObject.transform.forward = forward; networkGameObject.transform.localScale = scale; NetworkEventController.Instance.DispatchLocalEvent(EVENT_YOURNETWORKTOOLS_NETID_NEW); } else { networkGameObject = (GameObject)networkObject; InterpolatorController.Instance.Interpolate(networkGameObject, position, TimeToUpdateTransforms * 1.01f); InterpolatorController.Instance.InterpolateForward(networkGameObject, forward, TimeToUpdateTransforms * 1.01f); networkGameObject.transform.localScale = scale; } } if (_nameEvent == EVENT_YOURNETWORKTOOLS_DESTROYED_GAMEOBJECT) { int NetID = (int)_list[1]; int UID = (int)_list[2]; if (IsLocalGame) { #if !DISABLE_UNET_COMMS for (int i = 0; i < m_unetNetworkObjects.Count; i++) { bool removeObject = false; if (m_unetNetworkObjects[i] == null) { removeObject = true; } else { if (m_unetNetworkObjects[i].GetNetworkObjectData() == null) { removeObject = true; } } if (removeObject) { m_unetNetworkObjects.RemoveAt(i); } else { if ((m_unetNetworkObjects[i].GetNetworkObjectData().NetID == NetID) && (m_unetNetworkObjects[i].GetNetworkObjectData().UID == UID)) { m_unetNetworkObjects[i].Destroy(); m_unetNetworkObjects.RemoveAt(i); return; } } } #endif } else { for (int i = 0; i < m_tcpNetworkObjects.Count; i++) { bool removeObject = false; if (m_tcpNetworkObjects[i] == null) { removeObject = true; } if (removeObject) { m_tcpNetworkObjects.RemoveAt(i); } else { if ((m_tcpNetworkObjects[i].GetComponent <NetworkID>().NetID == NetID) && (m_tcpNetworkObjects[i].GetComponent <NetworkID>().UID == UID)) { m_tcpNetworkObjects.RemoveAt(i); return; } } } } } }