// -------------------------------------------
/*
* 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;
}
}
}
}
}
}
