Example #1
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]);
        }
Example #2
0
        /// <summary>
        /// Sends an event to all players in the room except the sender
        /// </summary>
        public void BroadcastMessage(string eventName, string[] stringData = null, int[] commandInts = null,
                                     float[] floatData  = null,
                                     bool[] booleanData = null)
        {
            GamePlayEvent gamePlayEvent = new GamePlayEvent(this.roomId, playerId, eventName, stringData, commandInts, floatData, booleanData);

            edgeManager.SendGamePlayEvent(gamePlayEvent);
        }
Example #3
0
 public override void OnWebSocketEventReceived(GamePlayEvent gameplayEvent)
 {
     if (!isLocalPlayer)
     {
         if (gameplayEvent.senderId == playerId)
         {
             playerEvent(gameplayEvent);
         }
     }
 }
Example #4
0
 public override void OnUDPEventReceived(GamePlayEvent udpEvent)
 {
     if (!isLocalPlayer)
     {
         if (udpEvent.senderId == playerId)
         {
             playerEvent(udpEvent);
         }
     }
 }
Example #5
0
 /// <summary>
 /// Sends a UDP Message from local player to other room members, can be used only after the game starts (OnGameStart())
 /// <para>
 /// on the player manager that inherits from NetworkedPlayer use
 /// <b>public override void OnMessageReceived</b>  to get the forwarded message
 /// </para>
 /// <para>
 /// <b>UDP Messages are limited to 508 bytes</b> if you want to exceed that make sure you slice and reassemble your buffer
 /// </para>
 /// </summary>
 /// <param name="gameplayEvent">the GamePlay Event to be forwarded to other room members</param>
 public static void SendUDPMessage(GamePlayEvent gameplayEvent)
 {
     gameplayEvent.roomId   = gameSession.roomId;
     gameplayEvent.senderId = gameSession.playerId;
     if (udpClient.run)
     {
         udpClient.Send(gameplayEvent.ToJson());
     }
     else
     {
         Debug.LogError("EdgeMultiplay: Error in sending UDP Message");
     }
 }
Example #6
0
        /// <summary>
        /// Sends an event to all players in the room (UDP)
        /// </summary>
        /// <param name="gamePlayEvent">The GamePlayEvent to send</param>
        public void SendGamePlayEventUDP(GamePlayEvent gamePlayEvent)
        {
            GamePlayEvent gameplayEvent = new GamePlayEvent()
            {
                eventName   = gamePlayEvent.eventName,
                booleanData = gamePlayEvent.booleanData,
                stringData  = gamePlayEvent.stringData,
                integerData = gamePlayEvent.integerData,
                floatData   = gamePlayEvent.floatData,
            };

            EdgeManager.SendUDPMessage(gameplayEvent);
        }
Example #7
0
        /// <summary>
        /// Sends an event to all players in the room except the sender
        /// </summary>
        public void BroadcastMessage(GamePlayEvent gamePlayEvent)
        {
            GamePlayEvent gameplayEvent = new GamePlayEvent()
            {
                eventName   = gamePlayEvent.eventName,
                booleanData = gamePlayEvent.booleanData,
                stringData  = gamePlayEvent.stringData,
                integerData = gamePlayEvent.integerData,
                floatData   = gamePlayEvent.floatData,
            };

            edgeManager.SendGamePlayEvent(gameplayEvent);
        }
Example #8
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;
            }
        }
 void TakeOverObservable(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;
         }
         // change the observable ownership from the current owner to the sender
         observable.ChangeOwnership(gamePlayEvent.senderId);
     }
 }
Example #10
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);
        }
Example #11
0
        public void SendDataToServer()
        {
            GamePlayEvent observerEvent = new GamePlayEvent();

            observerEvent.eventName   = "EdgeMultiplayObserver";
            observerEvent.integerData = new int[2] {
                (int)syncOption, observableIndex
            };
            switch (syncOption)
            {
            case SyncOptions.SyncPosition:
                observerEvent.floatData = Util.GetPositionData(observeredTransform.transform);
                lastPosition            = observeredTransform.transform.position;
                break;

            case SyncOptions.SyncRotation:
                observerEvent.floatData = Util.GetRotationEulerData(observeredTransform.transform);
                lastRotation            = observeredTransform.transform.rotation.eulerAngles;
                break;

            case SyncOptions.SyncPositionAndRotation:
                observerEvent.floatData = Util.GetPositionAndRotationData(observeredTransform.transform);
                lastRotation            = observeredTransform.transform.rotation.eulerAngles;
                lastPosition            = observeredTransform.transform.position;
                break;

            case SyncOptions.SyncLocalPosition:
                observerEvent.floatData = Util.GetLocalPositionData(observeredTransform.transform);
                lastPosition            = observeredTransform.localPosition;
                break;

            case SyncOptions.SyncLocalRotation:
                observerEvent.floatData = Util.GetLocalRotationData(observeredTransform.transform);
                lastRotation            = observeredTransform.transform.rotation.eulerAngles;
                break;

            case SyncOptions.SyncLocalPositionAndRotation:
                observerEvent.floatData = Util.GetLocalPositionAndRotationData(observeredTransform.transform);
                lastPosition            = observeredTransform.transform.localRotation.eulerAngles;
                lastRotation            = observeredTransform.transform.localPosition;
                break;
            }
            EdgeManager.SendUDPMessage(observerEvent);
        }
Example #12
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);
            }
        }
Example #14
0
        /// <summary>
        /// Creates synced GameObject in runtime in the local player's world
        /// and sends an event to all players in the room to create the observable in their worlds
        /// </summary>
        /// <param name="prefabName">The name of your prefab (Game Object) stored in Resources Folder without extensions ex. 'Ball' </param>
        /// <param name="startPosition"> the inital position of the spawning </param>
        /// <param name="startRotation">  the inital rotation of the spawning </param>
        /// <param name="syncOption"> Which Synchronization option will be applied </param>
        /// <param name="interpolatePosition"> Set to true if you want to smoothen the tracked position if you have network lag </param>
        /// <param name="interpolateRotation"> Set to true if you want to smoothen the tracked rotation if you have network lag</param>
        /// <param name="interpolationFactor"> Set Interpolation factor between 0.1 and 1 </param>
        /// <returns> The created Observer object </returns>
        public Observable CreateObservableObject(string prefabName, Vector3 startPosition, Quaternion startRotation, SyncOptions syncOption, bool interpolatePosition = false, bool interpolateRotation = false, float interpolationFactor = 0)
        {
            GameObject prefab = Resources.Load <GameObject>(prefabName);
            GameObject syncedObject;

            syncedObject = Instantiate(prefab, startPosition, startRotation);
            if (!observer)
            {
                observer = gameObject.AddComponent <EdgeMultiplayObserver>();
            }
            Observable newObservable = new Observable(syncedObject.transform, syncOption, interpolatePosition, interpolateRotation, Mathf.Clamp(interpolationFactor, 0.1f, 1f), observer.observables.Count);

            observer.observables.Add(newObservable);
            newObservable.SetupObservable(this);
            observer.UpdateObservables();
            if (isLocalPlayer)
            {
                GamePlayEvent newObserverEvent = new GamePlayEvent
                {
                    eventName   = "NewObservableCreated",
                    booleanData = new bool[2] {
                        interpolatePosition, interpolateRotation
                    },
                    stringData = new string[2] {
                        playerId, prefabName
                    },
                    integerData = new int[1] {
                        (int)syncOption
                    },
                    floatData = new float[7] {
                        startPosition.x, startPosition.y, startPosition.z, startRotation.eulerAngles.x, startRotation.eulerAngles.y, startRotation.eulerAngles.z, interpolationFactor
                    },
                };
                edgeManager.SendGamePlayEvent(newObserverEvent);
            }
            return(newObservable);
        }
Example #15
0
        void HandleUDPMessage(string message)
        {
            GamePlayEvent gamePlayEvent = JsonUtility.FromJson <GamePlayEvent>(message);

            switch (gamePlayEvent.type)
            {
            case "GamePlayEvent":
                if (gamePlayEvent.eventName == "EdgeMultiplayObserver")
                {
                    SyncObject(gamePlayEvent);
                }
                else
                {
                    // if used for other than that Syncing GameObjects Position & Rotation
                    // it wil trigger OnUDPMessagesReceived()
                    EdgeMultiplayCallbacks.udpEventReceived(gamePlayEvent);
                }
                break;

            default:
                Debug.LogError("Unknown UDP message arrived: " + message);
                break;
            }
        }
Example #16
0
 /// <summary>
 /// During GamePlay once a event received from another player (Websocket)
 /// </summary>
 /// <param name="gamePlayEvent">received GamePlayEvent</param>
 public virtual void OnWebSocketEventReceived(GamePlayEvent gamePlayEvent)
 {
     Debug.Log("WebSocket Event Received From Server : " + gamePlayEvent.eventName);
 }
Example #17
0
        /// <summary>
        /// Sends an event to all players in the room except the sender
        /// </summary>
        public void BroadcastMessage(string eventName, List <float> floatArray)
        {
            GamePlayEvent gameplayEvent = new GamePlayEvent(eventName, floatArray);

            edgeManager.SendGamePlayEvent(gameplayEvent);
        }
Example #18
0
        /// <summary>
        /// Sends an event to all players in the room except the sender
        /// </summary>
        public void BroadcastMessage(string eventName, List <int> integerArray)
        {
            GamePlayEvent gameplayEvent = new GamePlayEvent(eventName, integerArray);

            edgeManager.SendGamePlayEvent(gameplayEvent);
        }
Example #19
0
        /// <summary>
        /// Sends an event to all players in the room except the sender
        /// </summary>
        public void BroadcastMessage(string eventName, Vector3 position, Quaternion rotation)
        {
            GamePlayEvent gameplayEvent = new GamePlayEvent(eventName, position, rotation);

            edgeManager.SendGamePlayEvent(gameplayEvent);
        }
Example #20
0
 /// <summary>
 /// During GamePlay once a event received from another player (UDP)
 /// </summary>
 /// <param name="gamePlayEvent">received GamePlayEvent</param>
 public virtual void OnUDPEventReceived(GamePlayEvent gamePlayEvent)
 {
     //Debug.Log("UDP Msg Received Event From Server : " + gamePlayEvent.eventName);
 }
Example #21
0
 /// <summary>
 /// Called once GamePlay Events Received from the server
 /// </summary>
 /// <param name="gamePlayEvent">the received gamePlayEvent</param>
 public virtual void OnMessageReceived(GamePlayEvent gamePlayEvent)
 {
     Debug.Log("GamePlayEvent Received");
 }
Example #22
0
 public void SendGamePlayEvent(GamePlayEvent mobiledgexEvent)
 {
     mobiledgexEvent.roomId   = gameSession.roomId;
     mobiledgexEvent.senderId = gameSession.playerId;
     wsClient.Send(Messaging <GamePlayEvent> .Serialize(mobiledgexEvent));
 }
Example #23
0
 void ReflectEvent(GamePlayEvent receivedEvent)
 {
     EdgeMultiplayCallbacks.eventReceived(receivedEvent);
 }
Example #24
0
        void HandleWebSocketMessage(string message)
        {
            var msg = MessageWrapper.UnWrapMessage(message);

            switch (msg.type)
            {
            case "register":
                Register register = Messaging <Register> .Deserialize(message);

                gameSession.sessionId = register.sessionId;
                gameSession.playerId  = register.playerId;
                EdgeMultiplayCallbacks.registerEvent();
                break;

            case "notification":
                Notification notification = Messaging <Notification> .Deserialize(message);

                switch (notification.notificationText)
                {
                case "left-room":
                    gameSession.roomId = "";
                    EdgeMultiplayCallbacks.leftRoom();
                    break;

                case "join-room-faliure":
                    EdgeMultiplayCallbacks.joinRoomFaliure();
                    break;

                case "new-room-created-in-lobby":
                    EdgeMultiplayCallbacks.newRoomCreatedInLobby();
                    break;
                }
                EdgeMultiplayCallbacks.notificationEvent(notification);
                break;

            case "roomsList":
                RoomsList roomsList = Messaging <RoomsList> .Deserialize(message);

                EdgeMultiplayCallbacks.roomsList(roomsList.rooms);
                break;

            case "roomCreated":
                RoomCreated roomCreated = Messaging <RoomCreated> .Deserialize(message);

                gameSession.roomId = roomCreated.room.roomId;
                EdgeMultiplayCallbacks.roomCreated(roomCreated.room);
                break;

            case "roomJoin":
                RoomJoin roomJoin = Messaging <RoomJoin> .Deserialize(message);

                gameSession.roomId = roomJoin.room.roomId;
                EdgeMultiplayCallbacks.roomJoin(roomJoin.room);
                break;

            case "playerJoinedRoom":
                PlayerJoinedRoom playerJoinedRoom = Messaging <PlayerJoinedRoom> .Deserialize(message);

                EdgeMultiplayCallbacks.playerRoomJoined(playerJoinedRoom.room);
                break;

            case "gameStart":
                GameStart gameStart = Messaging <GameStart> .Deserialize(message);

                gameSession.currentPlayers = gameStart.room.roomMembers.ToArray();
                foreach (Player player in gameStart.room.roomMembers)
                {
                    if (player.playerId == gameSession.playerId)
                    {
                        gameSession.playerIndex = player.playerIndex;
                    }
                }
                CreatePlayers(gameSession.currentPlayers);
                gameStarted = true;
                EdgeMultiplayCallbacks.gameStart();
                if (useLocalHostServer)
                {
                    udpClient = new MobiledgeXUDPClient(hostIPAddress, defaultEdgeMultiplayServerUDPPort);
                }
                else
                {
                    udpClient = new MobiledgeXUDPClient(integration.GetHost(), integration.GetAppPort(LProto.L_PROTO_UDP).public_port);
                }
                SendUDPMessage(new GamePlayEvent()
                {
                    eventName = "Start"
                });
                break;

            case "GamePlayEvent":
                GamePlayEvent gamePlayEvent = Messaging <GamePlayEvent> .Deserialize(message);

                switch (gamePlayEvent.eventName)
                {
                case "NewObservableCreated":
                    CreateObserverableObject(gamePlayEvent);
                    break;

                case "ObservableOwnershipChange":
                    UpdateObserverOwnership(gamePlayEvent);
                    break;

                default:
                    ReflectEvent(gamePlayEvent);
                    break;
                }
                break;

            case "memberLeft":
                RoomMemberLeft playerLeft = Messaging <RoomMemberLeft> .Deserialize(message);

                EdgeMultiplayCallbacks.playerLeft(playerLeft);
                break;

            default:
                Debug.LogError("Unknown WebSocket message arrived: " + msg.type + ", message: " + message);
                break;
            }
        }