public static EControllerID GetControllerIDFrom(ENetworkID networkID)
{
switch (networkID)
{
case ENetworkID.HOST:
return(EControllerID.NET_HOST);
case ENetworkID.CLIENT_1:
return(EControllerID.NET_CLIENT_1);
case ENetworkID.CLIENT_2:
return(EControllerID.NET_CLIENT_2);
case ENetworkID.CLIENT_3:
return(EControllerID.NET_CLIENT_3);
case ENetworkID.CLIENT_4:
return(EControllerID.NET_CLIENT_4);
case ENetworkID.CLIENT_5:
return(EControllerID.NET_CLIENT_5);
case ENetworkID.CLIENT_6:
return(EControllerID.NET_CLIENT_6);
case ENetworkID.CLIENT_7:
return(EControllerID.NET_CLIENT_7);
case ENetworkID.CLIENT_8:
return(EControllerID.NET_CLIENT_8);
case ENetworkID.CLIENT_9:
return(EControllerID.NET_CLIENT_9);
case ENetworkID.CLIENT_10:
return(EControllerID.NET_CLIENT_10);
case ENetworkID.CLIENT_11:
return(EControllerID.NET_CLIENT_11);
case ENetworkID.CLIENT_12:
return(EControllerID.NET_CLIENT_12);
case ENetworkID.CLIENT_13:
return(EControllerID.NET_CLIENT_13);
default:
return(EControllerID.NONE);
}
}
private void Rpc_OnRefreshAssignedNetworkID(ENetworkID assignedNetworkID)
{
//Debug.Log("Rpc_OnRefreshAssignedNetworkID : " + assignedNetworkID);
networkID = assignedNetworkID;
// Connect network if not connected yet
MirrorBEventDispatcher mirrorBEventDispatcher = (MirrorBEventDispatcher)BEventManager.Instance.BEventDispatcher;
if (mirrorBEventDispatcher)
{
mirrorBEventDispatcher.OnRefreshConnectedNetworkIDs(assignedNetworkID);
}
}
private void Target_OnAssignedNetworkID(NetworkConnection networkConnection, ENetworkID assignedNetworkID)
{
//Debug.Log("Target_OnAssignedNetworkID : " + assignedNetworkID);
networkID = assignedNetworkID;
// Set up MirrorBEventDispatcher
MirrorBEventDispatcher mirrorBEventDispatcher = (MirrorBEventDispatcher)BEventManager.Instance.BEventDispatcher;
if (mirrorBEventDispatcher)
{
//mirrorBEventDispatcher.LocalNetworkID = NetworkID;
//mirrorBEventDispatcher.LocalMirrorPlayerBEventListener = this;
mirrorBEventDispatcher.Target_OnConnectedToHost(networkID, this);
}
}
private void Publish_TOPIC_BROADCAST_BEVENT(AbstractBEHandle bEHandle, ENetworkID targetNetworkID)
{
// Debug
if (MotherOfManagers.Instance.DebugUbiiTopicPublish)
{
LogConsole("Publish_TOPIC_BROADCAST_BEVENT");
}
if (ARE_NOT_EQUAL(LocalNetworkID, targetNetworkID))
{
string serializedBEHandle = BUtils.SerializeObject(bEHandle);
Publish(UbiiParser.UnityToProto(TOPIC_BROADCAST_BEVENT, joinedHostGuid + "|" + targetNetworkID + "|" + serializedBEHandle));
}
}
private void Cmd_OnRequestNetworkID(NetworkIdentity networkIdentity)
{
//Debug.Log("Cmd_OnRequestNetworkID : " + networkIdentity.connectionToClient.ToString());
MirrorBEventDispatcher mirrorBEventDispatcher = (MirrorBEventDispatcher)BEventManager.Instance.BEventDispatcher;
if (mirrorBEventDispatcher)
{
ENetworkID newNetworkID = mirrorBEventDispatcher.Server_OnNewMirrorPlayerJoined(this);
if (newNetworkID != ENetworkID.NONE)
{
Debug.Log("Assigned network ID : " + newNetworkID);
Target_OnAssignedNetworkID(networkIdentity.connectionToClient, newNetworkID);
}
}
}
private ENetworkID GetNextFreeNetworkNetworkID()
{
ENetworkID netowrkID = ENetworkID.NONE;
foreach (ENetworkID networkIDitr in System.Enum.GetValues(typeof(ENetworkID)))
{
if (networkIDitr == ENetworkID.NONE)
{
continue;
}
if (connectedNetworkIDs.ContainsKey(networkIDitr) == false)
{
netowrkID = networkIDitr;
break;
}
}
return(netowrkID);
}
protected override void Start()
{
base.Start();
if (dZPlayer == null)
{
dZPlayer = GetComponentInHierarchy <DropZonePlayer>();
}
if (IS_NOT_NULL(dZPlayer))
{
playerID = dZPlayer.PlayerID;
owner = dZPlayer.GetOwner();
}
// Disable collision if not locally owned
if (IS_NOT_NULL(myCollider) &&
owner != BEventManager.Instance.LocalNetworkID)
{
myCollider.enabled = false;
}
}
private void On_TOPIC_BROADCAST_BEVENT(TopicDataRecord topicDataRecord)
{
// Debug
if (MotherOfManagers.Instance.DebugUbiiTopicRecieve)
{
Debug.Log("On_TOPIC_BROADCAST_BEVENT");
}
if (LocalNetworkID != ENetworkID.LOCAL)
{
// Split the parameters
string[] parameters = topicDataRecord.String.Split('|');
if (parameters.Length >= 3)
{
string joinedHostGuid = parameters[0];
ENetworkID targetNetworkID = ENetworkID.NONE;
Enum.TryParse(parameters[1], out targetNetworkID);
string serializedBEHandle = parameters[2];
// Same host and Is targeted client
if (joinedHostGuid == this.joinedHostGuid &&
targetNetworkID == LocalNetworkID)
{
// Did the serialized BEHandle got split?
if (parameters.Length > 3)
{
LogConsoleWarning("The BEhandle got split. Trying to reconstruct it");
for (int i = 3; i < parameters.Length; i++)
{
serializedBEHandle += '|' + parameters[i];
}
}
// Proceed the deserialization of the BEHandle
BEventManager.Instance.OnBEventReplicated(serializedBEHandle);
}
}
}
}
private void On_TOPIC_REQUEST_JOIN_HOST(TopicDataRecord topicDataRecord)
{
// Debug
if (MotherOfManagers.Instance.DebugUbiiTopicRecieve)
{
Debug.Log("On_TOPIC_REQUEST_JOIN_HOST");
}
if (LocalNetworkID == ENetworkID.HOST)
{
// Split message
string[] parameters = topicDataRecord.String.Split('|');
if (ARE_EQUAL(parameters.Length, 2))
{
string requestingGuid = parameters[0];
string requestedHostGuid = parameters[1];
// Check if this instanced is the one concerned
if (requestedHostGuid == localGuid &&
IS_VALUE_NOT_CONTAINED(connectedNetworkIDs, requestingGuid))
{
ENetworkID networkID = GetNextFreeNetworkNetworkID();
if (ARE_NOT_EQUAL(networkID, ENetworkID.NONE))
{
connectedNetworkIDs.Add(networkID, requestingGuid);
// Publish topic
Publish_TOPIC_CLIENT_CONNECTED(requestingGuid, networkID);
// Resend a Publish_TOPIC_CLIENT_CONNECTED for every other connected client (after a short delay?)
StartCoroutine(RefreshConnectedClientsCoroutine());
// Trigger local BEvent
BEventsCollection.NETWORK_NewNetworkIDConnected.Invoke(new BEHandle <ENetworkID>(networkID));
}
}
}
}
}
private void On_AR_BAnchorReplicateTransform(BEHandle <BAnchorInformation, string> handle)
{
ENetworkID callingNetworkID = handle.InvokingNetworkID;
if (bAnchorID == handle.Arg2 &&
callingNetworkID == bAnchor.Owner &&
ARE_NOT_EQUAL(callingNetworkID, BEventManager.Instance.LocalNetworkID) &&
IS_NOT_NULL(bAnchor))
{
BAnchorInformation bAnchorInformation = handle.Arg1;
if (interpolateReplication == false)
{
bAnchor.SetTransformedPosition(bAnchorInformation.TransformedPosition);
bAnchor.SetTransformedRotation(bAnchorInformation.TransformedRotation);
}
else
{
inverseRepTransformedPosition = ARManager.Instance.GetInverseTransformedPosition(bAnchorInformation.TransformedPosition);
inverseRepTransformedRotation = ARManager.Instance.GetInverseTransformedRotation(bAnchorInformation.TransformedRotation);
}
}
}
private void On_NETWORK_NetworkStateUpdated(BEHandle <ENetworkState> handle)
{
// Connected ?
if (handle.Arg1 == ENetworkState.CLIENT ||
handle.Arg1 == ENetworkState.HOST)
{
localNetworkID = BEventManager.Instance.LocalNetworkID;
//EControllerID controllerID = BUtils.GetControllerIDFrom(localNetworkID);
//if (localNetworkID == ENetworkID.HOST)
//{
// // Connect Controller
// InputManager.Instance.ConnectController(controllerID);
// // Join Player
// localPlayerID = PlayerManager.Instance.OnNextFreePlayerJoinRequest(controllerID); // TODO : Move to OnButtonPressed
// if (IS_NOT_NONE(localPlayerID))
// {
// partyMap.Add(controllerID, localPlayerID);
// }
//}
}
else // Disconnected
{
// Disconnect all connected net controllers
foreach (EControllerID controllerID in partyMap.Keys)
{
InputManager.Instance.DisconnectController(controllerID);
}
// Reinitialize
localNetworkID = ENetworkID.NONE;
//localPlayerID = EPlayerID.NONE;
partyMap.Clear();
}
}
public override void OnBEventInvoked <H>(BEvent <H> bEvent, H bEHandle, BEventReplicationType eventInvocationType, ENetworkID targetNetworkID)
{
// Broadcast locally if still not connected
if (LocalNetworkID == ENetworkID.LOCAL)
{
bEvent.OnProceedInvokation(bEHandle);
return;
}
switch (eventInvocationType)
{
case BEventReplicationType.TO_ALL:
//Broadcast locally
bEvent.OnProceedInvokation(bEHandle);
// Publish to all other clients on the network
foreach (ENetworkID networkID in connectedNetworkIDs.Keys)
{
if (networkID != LocalNetworkID)
{
Publish_TOPIC_BROADCAST_BEVENT(bEHandle, networkID);
}
}
break;
case BEventReplicationType.TO_ALL_OTHERS:
// Publish to all other clients on the network
foreach (ENetworkID networkID in connectedNetworkIDs.Keys)
{
if (networkID != LocalNetworkID)
{
Publish_TOPIC_BROADCAST_BEVENT(bEHandle, networkID);
}
}
break;
case BEventReplicationType.LOCAL:
// Broadcast locally
bEvent.OnProceedInvokation(bEHandle);
break;
case BEventReplicationType.TO_TARGET:
if (LocalNetworkID == targetNetworkID)
{
// Broadcast locally
bEvent.OnProceedInvokation(bEHandle);
}
else if (IS_NOT_NONE(targetNetworkID))
{
Publish_TOPIC_BROADCAST_BEVENT(bEHandle, targetNetworkID);
}
break;
}
}
public abstract void OnBEventInvoked <H>(BEvent <H> bEvent, H bEHandle, BEventReplicationType eventInvocationType, ENetworkID targetNetworkID) where H : AbstractBEHandle;
public void OnClientDisconnected(ENetworkID networkID)
{
BEventsCollection.NETWORK_NetworkIDDisconnected.Invoke(new BEHandle <ENetworkID>(networkID));
}
/* Callbacks from Dispatcher */
public void OnBEventInvoked <H>(BEvent <H> bEvent, H bEHandle, BEventReplicationType bEInvocationType, ENetworkID targetNetworkID) where H : AbstractBEHandle
{
if (BEventDispatcher)
{
bEHandle.InvokingNetworkID = LocalNetworkID;
BEventDispatcher.OnBEventInvoked(bEvent, bEHandle, bEInvocationType, targetNetworkID);
}
}
public override void OnBEventInvoked <H>(BEvent <H> bEvent, H bEHandle, BEventReplicationType eventInvocationType, ENetworkID targetNetworkID)
{
// Broadcast locally if still not connected
if (LocalNetworkID == ENetworkID.LOCAL)
{
bEvent.OnProceedInvokation(bEHandle);
return;
}
switch (eventInvocationType)
{
case BEventReplicationType.TO_ALL:
//Broadcast locally
bEvent.OnProceedInvokation(bEHandle);
// Server
if (LocalNetworkID == ENetworkID.HOST)
{
if (IS_NOT_NULL(LocalMirrorPlayerBEventListener))
{
// Broadcast it to everyone in connectedNetworkControllers
LocalMirrorPlayerBEventListener.Server_RequestBroadcastEvent(bEHandle, eventInvocationType, LocalNetworkID, targetNetworkID);
}
}
else // Client
{
if (IS_NOT_NULL(LocalMirrorPlayerBEventListener))
{
// Send to server, which then broadcasts it to everyone in connectedNetworkControllers
LocalMirrorPlayerBEventListener.Client_RequestBroadcastEvent(bEHandle, eventInvocationType, LocalNetworkID, targetNetworkID);
}
}
break;
case BEventReplicationType.TO_ALL_OTHERS:
// Server
if (LocalNetworkID == ENetworkID.HOST)
{
if (IS_NOT_NULL(LocalMirrorPlayerBEventListener))
{
// Broadcast it to everyone in connectedNetworkControllers
LocalMirrorPlayerBEventListener.Server_RequestBroadcastEvent(bEHandle, eventInvocationType, LocalNetworkID, targetNetworkID);
}
}
else // Client
{
if (IS_NOT_NULL(LocalMirrorPlayerBEventListener))
{
// Send to server, which then broadcasts it to everyone in connectedNetworkControllers
LocalMirrorPlayerBEventListener.Client_RequestBroadcastEvent(bEHandle, eventInvocationType, LocalNetworkID, targetNetworkID);
}
}
break;
case BEventReplicationType.LOCAL:
// Broadcast locally
bEvent.OnProceedInvokation(bEHandle);
break;
case BEventReplicationType.TO_TARGET:
// Server
if (LocalNetworkID == ENetworkID.HOST)
{
if (IS_NOT_NULL(LocalMirrorPlayerBEventListener))
{
// Broadcast it to target in connectedNetworkControllers
LocalMirrorPlayerBEventListener.Server_RequestBroadcastEvent(bEHandle, eventInvocationType, LocalNetworkID, targetNetworkID);
}
}
else // Client
{
if (IS_NOT_NULL(LocalMirrorPlayerBEventListener))
{
// Send to server, which then broadcasts it to target in connectedNetworkControllers
LocalMirrorPlayerBEventListener.Client_RequestBroadcastEvent(bEHandle, eventInvocationType, LocalNetworkID, targetNetworkID);
}
}
break;
}
}
/// <summary>
/// Called from the MirrorPlayerBEventListener when destroyed to disconnect the associated NetworkID
/// </summary>
/// <param name="mirrorPlayerListener"> MirrorPlayerBEventListener to disconnect </param>
/// <returns> Assigned NetworkID </returns>
public void OnMirrorPlayerLeft(MirrorPlayerBEventListener mirrorPlayerListener, ENetworkID networkID)
{
// Is Local Player disconnected?
if (networkID == LocalNetworkID)
{
// Is local player the server?
if (LocalNetworkID == ENetworkID.HOST)
{
connectedNetworkIDs.Clear();
}
LocalMirrorPlayerBEventListener = null;
LocalNetworkID = ENetworkID.LOCAL;
BEventManager.Instance.OnUpdatedNetworkState(ENetworkState.NOT_CONNECTED, this);
BEventsCollection.NETWORK_ConnectionStoped.Invoke(new BEHandle(), true);
}
else if (LocalNetworkID == ENetworkID.HOST &&
IS_KEY_CONTAINED(connectedNetworkIDs, networkID))
{
connectedNetworkIDs.Remove(networkID);
Server_InformAllDisconnectedClient(networkID);
}
}
public override void OnBEventInvoked <H>(BEvent <H> bEvent, H bEHandle, BEventReplicationType eventInvocationType, ENetworkID targetNetworkID)
{
//LogConsole(bEvent.BEventName + " : " + bEHandle.GetDebugMessage());
bEvent.OnProceedInvokation(bEHandle);
}
public void Invoke(H eventHandle, BEventReplicationType eventInvocationType = BEventReplicationType.LOCAL, bool debugEvent = true, ENetworkID targetNetworkID = ENetworkID.NONE)
{
eventHandle.InvokingBEventName = BEventName;
eventHandle.DebugEvent = debugEvent;
BEventManager.Instance.OnBEventInvoked(this, eventHandle, eventInvocationType, targetNetworkID);
}
public void Server_RefreshAssignedNetworkID(ENetworkID assignedNetworkID)
{
//Debug.Log("Server_RefreshAssignedNetworkID : " + assignedNetworkID);
Rpc_OnRefreshAssignedNetworkID(assignedNetworkID);
}
protected override void Awake()
{
base.Awake();
owner = ENetworkID.LOCAL;
}
public abstract void SetOwner(ENetworkID networkID);
private void Cmd_OnRequestBroadcastEvent(string serializedBEHandle, BEventReplicationType eventInvocationType, ENetworkID callingNetworkID, ENetworkID targetNetworkID)
{
//Debug.Log("Cmd_OnRequestBroadcastEvent : " + callingNetworkID + " - " + eventInvocationType);
Server_OnBroadcastEvent(serializedBEHandle, eventInvocationType, callingNetworkID, targetNetworkID);
}
public void Server_RequestBroadcastEvent(AbstractBEHandle bEHandle, BEventReplicationType eventInvocationType, ENetworkID callingNetworkID, ENetworkID targetNetworkID)
{
//Debug.Log("Server_RequestBroadcastEvent : " + callingNetworkID + " - " + eventInvocationType);
string serializedBEHandle = BUtils.SerializeObject(bEHandle);
Server_OnBroadcastEvent(serializedBEHandle, eventInvocationType, callingNetworkID, targetNetworkID);
}
private void Target_OnBroadcastEvent(NetworkConnection networkConnection, string serializedBEHandle, ENetworkID callingNetworkID, ENetworkID targetNetworkID)
{
//Debug.Log("Target_OnBroadcastEvent : " + callingNetworkID);
MirrorBEventDispatcher mirrorBEventDispatcher = (MirrorBEventDispatcher)BEventManager.Instance.BEventDispatcher;
if ((mirrorBEventDispatcher) &&
(mirrorBEventDispatcher.LocalNetworkID != callingNetworkID))
{
if (targetNetworkID != BEventManager.Instance.LocalNetworkID)
{
Debug.LogError("Recieved a target rpc but the local networkID is not the same. Target : " + targetNetworkID + " - Local : " + BEventManager.Instance.LocalNetworkID);
}
BEventManager.Instance.OnBEventReplicated(serializedBEHandle);
}
}
private void Server_OnBroadcastEvent(string serializedBEHandle, BEventReplicationType eventInvocationType, ENetworkID callingNetworkID, ENetworkID targetNetworkID)
{
//Debug.Log("Server_OnBroadcastEvent : " + callingNetworkID + " - " + eventInvocationType);
if (eventInvocationType == BEventReplicationType.TO_TARGET)
{
MirrorBEventDispatcher mirrorBEventDispatcher = (MirrorBEventDispatcher)BEventManager.Instance.BEventDispatcher;
if (mirrorBEventDispatcher)
{
NetworkIdentity targetNetworkIdentity = mirrorBEventDispatcher.GetNetworkIdentity(targetNetworkID);
Target_OnBroadcastEvent(targetNetworkIdentity.connectionToClient, serializedBEHandle, callingNetworkID, targetNetworkID);
}
}
else // ALL or ALL_OTHERS
{
Rpc_OnBroadcastEvent(serializedBEHandle, callingNetworkID);
}
}
