public void SetupObservable(NetworkedPlayer observableOwner)
{
owner = observableOwner;
switch (syncOption)
{
case SyncOptions.SyncPosition:
lastPosition = observeredTransform.transform.position;
break;
case SyncOptions.SyncRotation:
lastRotation = observeredTransform.transform.rotation.eulerAngles;
break;
case SyncOptions.SyncPositionAndRotation:
lastPosition = observeredTransform.transform.position;
lastRotation = observeredTransform.transform.rotation.eulerAngles;
break;
case SyncOptions.SyncLocalPosition:
lastPosition = observeredTransform.transform.localPosition;
break;
case SyncOptions.SyncLocalRotation:
lastRotation = observeredTransform.transform.localRotation.eulerAngles;
break;
case SyncOptions.SyncLocalPositionAndRotation:
lastPosition = observeredTransform.transform.localPosition;
lastRotation = observeredTransform.transform.localRotation.eulerAngles;
break;
}
}
/// <summary>
/// When an observerable object change its owner, OwnershipChangeEvent is sent from the owner to other players
/// Changing ownership must occur at the owner world
/// </summary>
/// <param name="ownershipChangeEvent">OwnershipChangeEvent contains (oldOwnerId, the observerable Index and the newOwnerId)</param>
void UpdateObserverOwnership(GamePlayEvent ownershipChangeEvent)
{
if (localPlayer.playerId == ownershipChangeEvent.senderId)
{
return;
}
NetworkedPlayer oldOwner = GetPlayer(ownershipChangeEvent.senderId);
Observable observer;
if (oldOwner.observer != null)
{
observer = oldOwner.observer.observables[ownershipChangeEvent.integerData[0]];
}
else
{
Debug.LogError("Couldn't find old owner.observer");
return;
}
NetworkedPlayer newOwner = GetPlayer(ownershipChangeEvent.stringData[0]);
if (newOwner.observer == null)
{
newOwner.gameObject.AddComponent <EdgeMultiplayObserver>();
}
newOwner.observer.observables.Add(observer);
newOwner.observer.UpdateObservables();
oldOwner.observer.observables.RemoveAt(ownershipChangeEvent.integerData[0]);
}
void CreatePlayers(Player[] gamePlayers)
{
if (currentRoomPlayers.Count < 1 && gamePlayers.Length > 1)
{
try
{
foreach (Player player in gamePlayers)
{
GameObject playerObj = SpawnPrefabs[player.playerAvatar].gameObject;
playerObj.GetComponent <NetworkedPlayer>().SetUpPlayer(player, gameSession.roomId, player.playerId == gameSession.playerId);
GameObject playerCreated;
if (WorldOriginTransform != null)
{
playerCreated = Instantiate(playerObj, WorldOriginTransform);
Util.SetLocalPostion(playerCreated.transform, SpawnInfo[player.playerIndex].position);
Util.SetLocalRotation(playerCreated.transform, SpawnInfo[player.playerIndex].rotation);
}
else
{
playerCreated = Instantiate(playerObj, SpawnInfo[player.playerIndex].position, Quaternion.Euler(SpawnInfo[player.playerIndex].rotation));
}
NetworkedPlayer networkedPlayer = playerCreated.GetComponent <NetworkedPlayer>();
if (player.playerName == "")
{
playerCreated.name = networkedPlayer.playerName = "Player " + (player.playerIndex + 1);
}
else
{
playerCreated.name = player.playerName;
}
currentRoomPlayers.Add(networkedPlayer);
EdgeMultiplayCallbacks.eventReceived += networkedPlayer.OnWebSocketEventReceived;
EdgeMultiplayCallbacks.udpEventReceived += networkedPlayer.OnUDPEventReceived;
if (player.playerId == gameSession.playerId)
{
localPlayer = MessageSender = networkedPlayer;
}
}
}
catch (NullReferenceException)
{
throw new Exception("EdgeMultiplay: Error in creating players, Make sure to attach your Prefabs to EdgeManager.SpawnInfo in the inspector");
}
catch (ArgumentOutOfRangeException)
{
throw new Exception("EdgeMultiplay: Error in creating players, Make sure Size of EdgeManager Spawn Info equal or greater than number of players in the room");
}
catch (Exception)
{
throw new Exception("EdgeMultiplay: Error in creating players");
}
}
}
/// <summary>
/// If the LocalPlayer is observing any transforms, once there is any update to the observed transform
/// the local player will send the updated transfrom to its clones in the other players' world.
/// </summary>
/// <param name="receivedEvent"> the received gameplay event contains (obsverable owner id, observerable index, syncOption, updated transform data) </param>
void SyncObject(GamePlayEvent receivedEvent)
{
if (receivedEvent.senderId == localPlayer.playerId)
{
return;
}
NetworkedPlayer sourcePlayer = GetPlayer(receivedEvent.senderId);
if (sourcePlayer.isLocalPlayer)
{
return;
}
int observerIndex;
Observable observerObject;
observerIndex = receivedEvent.integerData[1];
observerObject = sourcePlayer.observer.observables.Find(observer => observer.observerIndex == observerIndex);
if (observerObject == null)
{
Debug.LogError("No observer found with this id " + receivedEvent.integerData[1]);
return;
}
switch (receivedEvent.integerData[0])
{
case (int)SyncOptions.SyncPosition:
observerObject.observeredTransform.transform.position = Util.ConvertFloatArrayToVector3(receivedEvent.floatData, 0);
break;
case (int)SyncOptions.SyncRotation:
observerObject.observeredTransform.transform.rotation = Quaternion.Euler(Util.ConvertFloatArrayToVector3(receivedEvent.floatData, 0));
break;
case (int)SyncOptions.SyncPositionAndRotation:
observerObject.observeredTransform.transform.position = Util.ConvertFloatArrayToVector3(receivedEvent.floatData, 0);
observerObject.observeredTransform.transform.rotation = Quaternion.Euler(Util.ConvertFloatArrayToVector3(receivedEvent.floatData, 3));
break;
case (int)SyncOptions.SyncLocalPosition:
Util.SetLocalPostion(observerObject.observeredTransform.transform, Util.ConvertFloatArrayToVector3(receivedEvent.floatData, 0));
break;
case (int)SyncOptions.SyncLocalRotation:
Util.SetLocalRotation(observerObject.observeredTransform.transform, Util.ConvertFloatArrayToVector3(receivedEvent.floatData, 0));
break;
case (int)SyncOptions.SyncLocalPositionAndRotation:
Util.SetLocalPostion(observerObject.observeredTransform.transform, Util.ConvertFloatArrayToVector3(receivedEvent.floatData, 0));
Util.SetLocalRotation(observerObject.observeredTransform.transform, Util.ConvertFloatArrayToVector3(receivedEvent.floatData, 3));
break;
}
}
/// <summary>
/// Kill the connection to your EdgeMultiplay server
/// </summary>
public static void Disconnect()
{
wsClient = null;
udpClient = null;
foreach (NetworkedPlayer player in currentRoomPlayers)
{
Destroy(player.gameObject);
}
currentRoomPlayers = new List <NetworkedPlayer>();
gameSession = new Session();
gameStarted = false;
MessageSender = null;
localPlayer = null;
observers = new List <EdgeMultiplayObserver>();
}
public void SetOwnership(string ownerId)
{
owner = EdgeManager.GetPlayer(ownerId);
if (owner == null)
{
throw new Exception("EdgeMultiplay: Couldn't find player with id: " + ownerId);
}
if (owner.observer == null)
{
owner.gameObject.AddComponent <EdgeMultiplayObserver>();
}
owner.observer.observables.Add(this);
owner.observer.UpdateObservables();
}
void CreateObserverableObject(GamePlayEvent newObserverableEvent)
{
if (localPlayer.playerId == newObserverableEvent.stringData[0])
{
return;
}
NetworkedPlayer playerCreatedObserver = GetPlayer(newObserverableEvent.stringData[0]);
Observable observerable = playerCreatedObserver.CreateObservableObject(
prefabName: newObserverableEvent.stringData[1],
startPosition: Util.ConvertFloatArrayToVector3(newObserverableEvent.floatData, 0),
startRotation: Quaternion.Euler(Util.ConvertFloatArrayToVector3(newObserverableEvent.floatData, 3)),
syncOption: (SyncOptions)Enum.ToObject(typeof(SyncOptions), newObserverableEvent.integerData[0]),
interpolatePosition: newObserverableEvent.booleanData[0],
interpolateRotation: newObserverableEvent.booleanData[1],
interpolationFactor: newObserverableEvent.floatData[6]);
EdgeMultiplayCallbacks.newObservableCreated(observerable);
}
/// <summary>
/// Changes the owner of an Observable object
/// <para>ChangeOwnership() will change the owner in the local player's world and </para>
/// <para>update all room members about Ownership change.</para>
/// </summary>
/// <param name="newOwnerId">The new owner player id</param>
public void ChangeOwnership(string newOwnerId)
{
if (owner != null)
{
if (newOwnerId == owner.playerId)
{
Debug.LogWarning("EdgeMultiplay: No ownership change needed you already own the observable object");
return;
}
if (owner.observer != null)
{
owner.observer.observables.Remove(this);
}
owner = EdgeManager.GetPlayer(newOwnerId);
if (owner == null)
{
throw new Exception("EdgeMultiplay: Couldn't find player with id: " + newOwnerId);
}
if (owner.observer == null)
{
owner.gameObject.AddComponent <EdgeMultiplayObserver>();
}
owner.observer.observables.Add(this);
owner.observer.UpdateObservables();
GamePlayEvent changeOwnershipEvent = new GamePlayEvent()
{
eventName = "ObservableOwnershipChange",
stringData = new string[1] {
newOwnerId
},
integerData = new int[1] {
observableIndex
}
};
EdgeManager.MessageSender.BroadcastMessage(changeOwnershipEvent);
}
else
{
Debug.LogError("EdgeMultiplay: Observer has no owner, Use observer.SetOwnership() first");
return;
}
}
void OwnershipRequestReceived(GamePlayEvent gamePlayEvent)
{
// check if the observable owner is the local player
if (gamePlayEvent.stringData[0] == localPlayer.playerId)
{
//get the observable
Observable observable = localPlayer.observer.observables
.Find(obs => obs.observableIndex == gamePlayEvent.integerData[0]);
if (observable == null)
{
Debug.LogWarning("EdgeMultiplay: couldn't find the observable");
return;
}
NetworkedPlayer requestee = GetPlayer(gamePlayEvent.senderId);
// Inform the current owner about the ownership request
// Triggers OnOwnershipRequestReceived() callback
localPlayer.ownershipRequested(requestee, observable);
}
}
/// <summary>
/// OnOwnershipRequestReceived is Received from the server
/// once another player requests the ownership of an observable
/// </summary>
/// <param name="requestee">The player who requested the ownership</param>
/// <param name="observable">The observable which the request is about</param>
public virtual void OnOwnershipRequestReceived(NetworkedPlayer requestee, Observable observable)
{
Debug.Log("Ownership Request Received");//To Approve the transfer >> observable.ChangeOwnership(requestee.playerId);
}
private void Awake()
{
EdgeManager.observers.Add(this);
networkedPlayer = GetComponent <NetworkedPlayer>();
UpdateObservables();
}
