private void On_DZ_BallDroneReleased(BEHandle <EPlayerID> handle)
{
if (IS_NOT_NULL(ballDroneCatchIndicator))
{
ballDroneCatchIndicator.HideUIElement();
}
}
/* On Clients */
private void On_NETWORK_PlayerJoined(BEHandle <EPlayerID, EControllerID> handle)
{
if (ARE_NOT_EQUAL(localNetworkID, handle.InvokingNetworkID) &&
ARE_NOT_EQUAL(localNetworkID, ENetworkID.HOST) &&
InputManager.Instance.IsControllerConnected(handle.Arg2) == false)
{
// Connect Controller
InputManager.Instance.ConnectController(handle.Arg2);
// Update Party Map
if (IS_KEY_NOT_CONTAINED(partyMap, handle.Arg2))
{
partyMap.Add(handle.Arg2, handle.Arg1);
}
// Join Player
IS_TRUE(PlayerManager.Instance.JoinPlayer(handle.Arg1, handle.Arg2));
// Spawn Player
ENetworkID networkID = BUtils.GetNetworkIDFrom(handle.Arg2);
AbstractNetPlayer newPlayer = (AbstractNetPlayer)PlayerManager.Instance.SpawnPlayer(handle.Arg1);
if (IS_NOT_NULL(newPlayer) &&
IS_NOT_NONE(networkID))
{
newPlayer.SetOwner(networkID);
}
}
}
private void On_INPUT_ControllerDisconnected(BEHandle <EControllerID> eventHandle)
{
EControllerID controllerID = eventHandle.Arg1;
if (IS_KEY_CONTAINED(ControllersMap, controllerID))
{
EPlayerID playerID = ControllersMap[controllerID];
// Was a joined controller?
if (playerID != EPlayerID.SPECTATOR &&
IS_KEY_CONTAINED(partyStatusMap, playerID))
{
partyStatusMap[playerID].Flush();
}
// Destroy Player
if (ActivePlayers.ContainsKey(playerID))
{
DestroyPlayer(playerID);
}
ControllersMap.Remove(controllerID);
BEventsCollection.PLAYERS_PlayerLeft.Invoke(new BEHandle <EPlayerID, EControllerID>(playerID, controllerID));
}
}
private void On_NETWORK_CalculateRTT(BEHandle <ENetworkID, int> handle)
{
ENetworkID requestingNetworkID = handle.Arg1;
int startTime = handle.Arg2;
// Half-way
if (BEventManager.Instance.LocalNetworkID != requestingNetworkID)
{
BEventsCollection.NETWORK_CalculateRTT.Invoke(new BEHandle <ENetworkID, int>(requestingNetworkID, startTime), BEventReplicationType.TO_TARGET, false, requestingNetworkID);
}
// Round Trip
else
{
CurrentPing = BUtils.GetTimeAsInt() - startTime;
if (CurrentPing < pingDropTreshold)
{
CalculateAvgPing(CurrentPing);
}
else
{
LogConsole("Ping dropped : " + CurrentPing);
}
}
}
private void On_NETWORK_RequestPing(BEHandle handle)
{
if (ARE_NOT_EQUAL(BEventManager.Instance.LocalNetworkID, handle.InvokingNetworkID))
{
int myPing = BEventManager.Instance.GetPing();
BEventsCollection.NETWORK_SharePing.Invoke(new BEHandle <int>(myPing), BEventReplicationType.TO_TARGET, true, handle.InvokingNetworkID);
}
}
private void On_DZ_BallDroneCaught(BEHandle <EPlayerID> handle)
{
if (BEventManager.Instance.LocalNetworkID == handle.InvokingNetworkID &&
IS_NOT_NULL(ballDroneCatchIndicator))
{
ballDroneCatchIndicator.ShowUIElement();
}
}
private void On_BI_PlayVideo(BEHandle handle)
{
if (handle.InvokingNetworkID != BEventManager.Instance.LocalNetworkID &&
IS_NOT_NULL(videoPlayer))
{
StopVideo();
PlayVideo();
}
}
private void On_NETWORK_SharePing(BEHandle <int> handle)
{
ENetworkID invokingNetworkID = handle.InvokingNetworkID;
if (ARE_NOT_EQUAL(BEventManager.Instance.LocalNetworkID, invokingNetworkID) &&
IS_KEY_CONTAINED(pingMap, invokingNetworkID))
{
pingMap[invokingNetworkID] = handle.Arg1;
}
}
protected virtual void On_AR_TrackerUpdated(BEHandle <string, Vector3, Quaternion> eHandle)
{
string trackerName = eHandle.Arg1;
if (eHandle.Arg1 == BindWithTrackerName)
{
transform.position = eHandle.Arg2;
transform.rotation = eHandle.Arg3;
InvokeTrackerEvent();
}
}
private void On_AR_PlayAreaStateUpdated(BEHandle <EPlayAreaState, AbstractPlayArea> handle)
{
if (handle.Arg1 == EPlayAreaState.READY)
{
RectanglePlayArea rectanglePlayArea = (RectanglePlayArea)handle.Arg2;
if (rectanglePlayArea)
{
playAreaUpVector = rectanglePlayArea.UpVector;
}
}
}
private void On_INPUT_ControllerConnected(BEHandle <EControllerID> eventHandle)
{
EControllerID controllerID = eventHandle.Arg1;
// Add connected controller as a spectator
if (IS_KEY_NOT_CONTAINED(ControllersMap, controllerID))
{
ControllersMap.Add(controllerID, EPlayerID.SPECTATOR);
BEventsCollection.PLAYERS_PlayerJoined.Invoke(new BEHandle <EPlayerID, EControllerID>(EPlayerID.SPECTATOR, controllerID));
}
}
private void On_NETWORK_NewNetworkIDConnected(BEHandle <ENetworkID> handle)
{
if (BEventManager.Instance.LocalNetworkID == ENetworkID.HOST)
{
EControllerID newControllerID = BUtils.GetControllerIDFrom(handle.Arg1);
if (IS_NOT_NONE(newControllerID) &&
InputManager.Instance.IsControllerConnected(newControllerID) == false)
{
StartCoroutine(JoinConnectedPlayerCoroutine(handle, newControllerID));
}
}
}
private void On_UI_FocusedFrameUpdated(BEHandle <BFrame> bEHandle)
{
BFrame bFrame = bEHandle.Arg1;
if (cameraTransforms.ContainsKey(bFrame))
{
BFrameCameraTransform newCameraTransform = cameraTransforms[bFrame];
cameraTransformLerp.StartValue = lastCameraTransform.transform;
cameraTransformLerp.EndValue = newCameraTransform.transform;
cameraTransformLerp.PlayDuration = newCameraTransform.TransitionTime;
cameraTransformLerp.StartAnimation();
lastCameraTransform = newCameraTransform;
}
}
public bool DisconnectController(EControllerID controllerID)
{
if (connectedControllers.Contains(controllerID) == false)
{
LogConsoleError("Trying to disconnect a controller that is not connected.");
return(false);
}
connectedControllers.Remove(controllerID);
// Invoke event
BEHandle <EControllerID> controllerDisconnected = new BEHandle <EControllerID>(controllerID);
BEventsCollection.INPUT_ControllerDisconnected.Invoke(controllerDisconnected);
return(true);
}
private void On_NETWORK_PlayerLeft(BEHandle <EPlayerID, EControllerID> handle)
{
if (ARE_NOT_EQUAL(localNetworkID, handle.InvokingNetworkID) &&
ARE_NOT_EQUAL(localNetworkID, ENetworkID.HOST) &&
InputManager.Instance.IsControllerConnected(handle.Arg2) == true)
{
// Connect Controller
InputManager.Instance.DisconnectController(handle.Arg2);
// Update Party Map
if (IS_KEY_CONTAINED(partyMap, handle.Arg2))
{
partyMap.Remove(handle.Arg2);
}
}
}
private void On_INPUT_ButtonReleased(BEHandle <EControllerID, EInputButton> eventHandle)
{
EInputButton inputButton = eventHandle.Arg2;
if (CurrentBButtonHighlighted)
{
switch (inputButton)
{
case EInputButton.CONFIRM:
if (canPressButton == true)
{
CurrentBButtonHighlighted.OnReleased(true);
}
break;
}
}
}
private void On_DZ_BallDroneReleased(BEHandle <EPlayerID> handle)
{
// On not locally owned instances
if (handle.Arg1 == playerID &&
ARE_NOT_EQUAL(handle.InvokingNetworkID, BEventManager.Instance.LocalNetworkID) &&
IS_NOT_NULL(caughtBallDrone))
{
caughtBallDrone.Release(transform.position, Vector3.zero, 0.0f);
caughtBallDrone = null;
if (myRenderer)
{
myRenderer.material.color = Color.white;
}
}
}
protected override void On_AR_TrackerUpdated(BEHandle <string, Vector3, Quaternion> eHandle)
{
if (ARManager.Instance.FixWorldRoot == false)
{
string trackerName = eHandle.Arg1;
if (eHandle.Arg1 == BindWithTrackerName)
{
transform.position = eHandle.Arg2;
// Keep rotation on x axis (pitch) the same
Vector3 newRotation = eHandle.Arg3.eulerAngles;
transform.rotation = Quaternion.Euler(new Vector3(transform.rotation.eulerAngles.x, newRotation.y, transform.rotation.eulerAngles.z));
InvokeTrackerEvent();
}
}
}
//protected override void Start()
//{
// base.Start();
// StartNewCoroutine(ref pingEnumerator, PingCoroutine());
//}
#endregion
#region Events Callbacks
private void On_NETWORK_NetworkStateUpdated(BEHandle <ENetworkState> handle)
{
if (handle.Arg1 == ENetworkState.NOT_CONNECTED)
{
StopCoroutine(pingEnumerator);
AveragePing = 0;
}
else
{
if (pingStartCalculationDelay > 0.0f)
{
StartNewCoroutine(ref pingDelayedStartEnumerator, PingDelayedStartCortouine());
}
else
{
StartNewCoroutine(ref pingEnumerator, PingCoroutine());
}
}
}
private void On_PLAYERS_PlayerSpawned(BEHandle <EPlayerID, IPlayer> bHandle)
{
// Add an AIPlayerController on the spawned player if he's an AI
EPlayerID playerID = bHandle.Arg1;
EControllerID controllerID = PlayerManager.Instance.GetAssignedControllerID(playerID);
if ((controllerID.ContainedIn(BConsts.AI_CONTROLLERS)) &&
(IS_KEY_CONTAINED(PlayerManager.Instance.ActivePlayers, playerID)) &&
(IS_NOT_NULL(PlayerManager.Instance.ActivePlayers[playerID])))
{
AbstractPlayer player = PlayerManager.Instance.ActivePlayers[playerID];
AbstractAIPlayerController aIPlayerController = player.gameObject.AddComponent <AbstractAIPlayerController>();
aIPlayerController.AxisUpdated += On_AIPlayerController_JoystickMoved;
aIPlayerController.ButtonPressed += On_AIPlayerController_ButtonPressed;
aIPlayerController.ButtonReleased += On_AIPlayerController_ButtonReleased;
aIPlayerController.WillGetDestroyed += On_AIPlayerController_WillGetDestroyed;
aIPlayerController.InitializeAIController(this);
activeAIControllers.Add(aIPlayerController);
}
}
private void On_DZ_DroneBallSpawned(BEHandle <BAnchorInformation> handle)
{
if (BEventManager.Instance.LocalNetworkID != handle.InvokingNetworkID &&
IS_NOT_NULL(ballDronePrefab))
{
// Destroy exsiting Ball Drone
BallDroneBAnchor existingBallDrone = FindObjectOfType <BallDroneBAnchor>();
if (existingBallDrone)
{
Destroy(existingBallDrone.gameObject);
}
// Spawn new
BAnchorInformation bAnchorInformation = handle.Arg1;
BallDroneBAnchor ballDrone = Instantiate(ballDronePrefab);
ballDrone.Owner = handle.InvokingNetworkID;
ballDrone.SetTransformedPosition(bAnchorInformation.TransformedPosition);
ballDrone.SetTransformedRotation(bAnchorInformation.TransformedRotation);
}
}
private void On_INPUT_ButtonPressed(BEHandle <EControllerID, EInputButton> eventHandle)
{
EInputButton inputButton = eventHandle.Arg2;
if (CurrentBButtonHighlighted)
{
BButton nextButton = null;
switch (inputButton)
{
case EInputButton.CONFIRM:
CurrentBButtonHighlighted.OnPressed();
canPressButton = true;
break;
case EInputButton.LEFT:
nextButton = CurrentBButtonHighlighted.GetNextButton(EButtonDirection.LEFT);
break;
case EInputButton.RIGHT:
nextButton = CurrentBButtonHighlighted.GetNextButton(EButtonDirection.RIGHT);
break;
case EInputButton.UP:
nextButton = CurrentBButtonHighlighted.GetNextButton(EButtonDirection.UP);
break;
case EInputButton.DOWN:
nextButton = CurrentBButtonHighlighted.GetNextButton(EButtonDirection.DOWN);
break;
}
// Update highlighted button
if (nextButton != null)
{
CurrentBButtonHighlighted.OnUnhighlighted();
CurrentBButtonHighlighted = nextButton;
nextButton.OnHighlighted();
canPressButton = false;
}
}
}
private void On_DZ_BallDroneCaught(BEHandle <EPlayerID> handle)
{
// TODO : Feels like a hack
BallDroneBAnchor ballDrone = FindObjectOfType <BallDroneBAnchor>();
// On not locally owned instances
if (handle.Arg1 == playerID &&
ARE_NOT_EQUAL(handle.InvokingNetworkID, BEventManager.Instance.LocalNetworkID) &&
IS_NOT_NULL(ballDrone))
{
caughtBallDrone = ballDrone;
caughtBallDrone.Owner = handle.InvokingNetworkID;
IS_TRUE(caughtBallDrone.OnCatch(playerID));
if (myRenderer)
{
myRenderer.material.color = Color.red;
}
}
}
private void On_BI_SynchFrame(BEHandle <int> handle)
{
if (BEventManager.Instance.LocalNetworkID != handle.InvokingNetworkID &&
videoPlayer &&
Mathf.Abs(videoPlayer.frame - handle.Arg1) > syncThreshold)
{
float transferTime = (PingCalculator.Instance.AveragePing / 2.0f) / 1000.0f;
int extraFrames = (int)(transferTime / currentFrameTime);
LogConsole("extre frames : " + extraFrames + " = halfPing " + transferTime + " + " + " currentFrameTime " + currentFrameTime);
videoPlayer.frame = handle.Arg1 + extraFrames;
lastFrame = videoPlayer.frame;
lastFrameTime = Time.time;
if (videoPlayer.isPlaying == false)
{
videoPlayer.Play();
}
}
}
private void On_NETWORK_NetworkIDDisconnected(BEHandle <ENetworkID> handle)
{
if (BEventManager.Instance.LocalNetworkID == ENetworkID.HOST)
{
EControllerID controllerID = BUtils.GetControllerIDFrom(handle.Arg1);
if (IS_NOT_NONE(controllerID) &&
IS_TRUE(InputManager.Instance.IsControllerConnected(controllerID)) &&
IS_KEY_CONTAINED(partyMap, controllerID))
{
EPlayerID playerID = partyMap[controllerID];
if (IS_NOT_NONE(playerID))
{
partyMap.Remove(controllerID);
// Disconnect Controller (-> Remove from party)
InputManager.Instance.DisconnectController(controllerID);
BEventsCollection.NETWORK_PlayerLeft.Invoke(new BEHandle <EPlayerID, EControllerID>(playerID, controllerID), BEventReplicationType.TO_ALL_OTHERS, true);
}
}
}
}
public bool ConnectController(EControllerID controllerID)
{
if (controllerID == EControllerID.NONE)
{
LogConsoleError("Trying to connect a controller that is NONE.");
return(false);
}
if (connectedControllers.Contains(controllerID))
{
LogConsoleError("Trying to connect a controller that is already connected.");
return(false);
}
connectedControllers.Add(controllerID);
// Invoke event
BEHandle <EControllerID> controllerConnected = new BEHandle <EControllerID>(controllerID);
BEventsCollection.INPUT_ControllerConnected.Invoke(controllerConnected);
return(true);
}
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();
}
}
private IEnumerator JoinConnectedPlayerCoroutine(BEHandle <ENetworkID> handle, EControllerID newControllerID)
{
// Wait a delay
yield return(new WaitForSeconds(1.0f));
// Connect Controller
InputManager.Instance.ConnectController(newControllerID);
// Join Player
EPlayerID newPlayerID = PlayerManager.Instance.JoinPlayer(newControllerID); // TODO : Move to OnButtonPressed
if (IS_NOT_NONE(newPlayerID))
{
// Spawn Player
AbstractNetPlayer newPlayer = (AbstractNetPlayer)PlayerManager.Instance.SpawnPlayer(newPlayerID);
if (IS_NOT_NULL(newPlayer))
{
newPlayer.SetOwner(handle.Arg1);
}
// Update map
partyMap.Add(newControllerID, newPlayerID);
// Replicate all connected net controllers to all other clients (Refresh)
foreach (ENetworkID networkIDitr in BEventManager.Instance.GetConnectedNetworkIDs())
{
if (networkIDitr != localNetworkID) // != Host
{
foreach (KeyValuePair <EControllerID, EPlayerID> pair in partyMap)
{
BEventsCollection.NETWORK_PlayerJoined.Invoke(new BEHandle <EPlayerID, EControllerID>(pair.Value, pair.Key), BEventReplicationType.TO_TARGET, true, networkIDitr);
}
}
}
}
}
private void On_DZ_BallDroneReleased(BEHandle <EPlayerID> handle)
{
AudioManager.Instance.SpawnSoundObject(ballReleasedSound);
}
