Пример #1
0
        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;
            }
        }
Пример #2
0
        /// <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]);
        }
Пример #3
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");
                }
            }
        }
Пример #4
0
        /// <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;
            }
        }
Пример #5
0
 /// <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>();
 }
Пример #6
0
        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();
        }
Пример #7
0
        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);
        }
Пример #8
0
 /// <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);
            }
        }
Пример #10
0
 /// <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);
 }
Пример #11
0
 private void Awake()
 {
     EdgeManager.observers.Add(this);
     networkedPlayer = GetComponent <NetworkedPlayer>();
     UpdateObservables();
 }