/// <summary>
    /// Parses a LoadLobby TagMessage
    /// </summary>
    /// <param name="message"></param>
    private void ParseLoadLobbyMessage(Message message)
    {
        int sceneBuildIndex;

        using (DarkRiftReader reader = message.GetReader())
        {
            //read client id
            reader.ReadInt16();
            //read scene id
            sceneBuildIndex = reader.ReadInt16();
        }

        SceneManager.LoadScene(sceneBuildIndex, LoadSceneMode.Single);
        _postInitEvents.Subscribe(sceneBuildIndex, RequestLobbyUpdate);
    }
Example #2
0
    private void HandleLevelGraphChanged(Message message)
    {
        using (DarkRiftReader reader = message.GetReader())
        {
            _graphState.graph.Reset();

            _graphState.graph.TriggerId      = reader.ReadUInt16();
            _graphState.graph.EndLevelRoomId = reader.ReadUInt16();
            while (reader.Position < reader.Length)
            {
                short RoomId = reader.ReadInt16();
                short north  = reader.ReadInt16();
                short west   = reader.ReadInt16();
                short east   = reader.ReadInt16();
                short south  = reader.ReadInt16();
                _graphState.graph.AddVertex(RoomId, north, west, east, south);
            }
        }

        _levelSpawner.GenerateLevel();
        _sender.SendClientReady();
    }
        public void ReadInt16Test()
        {
            // GIVEN a buffer of serialized data
            mockMessageBuffer.Setup(m => m.Buffer).Returns(new byte[] { 0xE8, 0xA2 });
            mockMessageBuffer.Setup(m => m.Offset).Returns(0);
            mockMessageBuffer.Setup(m => m.Count).Returns(2);

            // WHEN I read a short from the reader
            short result = reader.ReadInt16();

            // THEN the value is as expected
            Assert.AreEqual((short)-5982, result);
        }
    private void HandleSpawnCharacter(Message message)
    {
        using (DarkRiftReader reader = message.GetReader())
        {
            while (reader.Position < reader.Length)
            {
                ushort id        = reader.ReadUInt16();
                float  X         = reader.ReadSingle();
                float  Y         = reader.ReadSingle();
                bool   isLocal   = (id == _client.ID);
                var    itemCount = reader.ReadInt16();
                var    items     = new List <short>();
                for (short i = 0; i < itemCount; i++)
                {
                    items.Add(reader.ReadInt16());
                }
                var moduleCount = reader.ReadInt16();
                var modules     = new List <short>();
                for (short i = 0; i < moduleCount; i++)
                {
                    modules.Add(reader.ReadInt16());
                }


                CharacterSpawnParameters spawnParameters = new CharacterSpawnParameters();
                spawnParameters.Id            = id;
                spawnParameters.X             = X;
                spawnParameters.Y             = Y;
                spawnParameters.CharacterType = CharacterType.Player;
                spawnParameters.IsLocal       = isLocal;
                spawnParameters.items         = items;
                spawnParameters.modules       = modules;
                _characterSpawner.Spawn(spawnParameters);
            }
            _messageWithResponse.SendClientReady();
        }
    }
Example #5
0
        /// <summary>
        /// Reads a quaternion that was written by WriteQuaternionCompressed
        /// </summary>
        public static Quaternion ReadQuaternionCompressed(this DarkRiftReader reader)
        {
            byte maxIndex = reader.ReadByte();

            float a = reader.ReadInt16() / 32767f;
            float b = reader.ReadInt16() / 32767f;
            float c = reader.ReadInt16() / 32767f;
            float d = Mathf.Sqrt(1f - (a * a + b * b + c * c));

            switch (maxIndex)
            {
            case 0:
                return(new Quaternion(d, a, b, c));

            case 1:
                return(new Quaternion(a, d, b, c));

            case 2:
                return(new Quaternion(a, b, d, c));

            default:
                return(new Quaternion(a, b, c, d));
            }
        }
    private void HandleWeaponChanged(Message message)
    {
        List <short> moduleIds = new List <short>();

        using (DarkRiftReader reader = message.GetReader())
        {
            ushort playerId = reader.ReadUInt16();
            if (playerId == _characterFacade.Id)
            {
                while (reader.Position < reader.Length)
                {
                    moduleIds.Add(reader.ReadInt16());
                }

                _weaponCreator.CreateWeapon(_weapon, moduleIds);
            }
        }
    }
Example #7
0
    private void UpdateWeapon(Message message)
    {
        if (_info.Status == ClientStatus.Host)
        {
            using (DarkRiftReader reader = message.GetReader())
            {
                ushort playerId = reader.ReadUInt16();

                if (_weapons.TryGetValue(playerId, out var moduleIds) == false)
                {
                    moduleIds = new List <short>();
                    _weapons.Add(playerId, moduleIds);
                }
                else
                {
                    moduleIds.Clear(); //if entry exists, weaponchanged contains all current modules - thus list clearing
                }
                while (reader.Position < reader.Length)
                {
                    moduleIds.Add(reader.ReadInt16());
                }
            }
        }
    }
Example #8
0
    void MessageReceived(object sender, MessageReceivedEventArgs e)
    {
        using (Message message = e.GetMessage() as Message)
        {
            using (DarkRiftReader reader = message.GetReader())
            {
                switch (message.Tag)
                {
                //// Byte[] 압축 수신일 경우
                //case MessageTags.VIDEO_STREAMING:
                //    {
                //        uint checkflag = reader.ReadUInt32();
                //        short uid = reader.ReadInt16();

                //        MemoryStream input = new MemoryStream(reader.ReadBytes());
                //        MemoryStream output = new MemoryStream();
                //        using (DeflateStream dstream = new DeflateStream(input, CompressionMode.Decompress))
                //        {
                //            dstream.CopyTo(output);
                //        }
                //        SetCameraTexture(output.ToArray());
                //    }
                //    break;

                //// LOGIC  (DeflateStream Byte[]분할 수신일 경우)
                case MessageTags.VIDEO_STREAMING:
                {
                    uint  checkflag  = reader.ReadUInt32();
                    short uid        = reader.ReadInt16();
                    int   numOfDatas = reader.ReadInt32();
                    var   idx        = reader.ReadInt32();

                    if (idx == 0)
                    {
                        textureByteData.Clear();
                    }

                    textureByteData.AddRange(reader.ReadBytes());

                    if (idx == numOfDatas)
                    {
                        Debug.Log(textureByteData.Count);
                        MemoryStream input  = new MemoryStream(textureByteData.ToArray());
                        MemoryStream output = new MemoryStream();
                        using (DeflateStream dstream = new DeflateStream(input, CompressionMode.Decompress))
                        {
                            dstream.CopyTo(output);
                        }
                        SetCameraTexture(output.ToArray());
                    }
                }
                break;

                    //// LOGIC  (BitConverter Byte[]분할 수신일 경우)
                    //case MessageTags.VIDEO_STREAMING:
                    //    {
                    //        uint checkflag = reader.ReadUInt32();
                    //        short uid = reader.ReadInt16();
                    //        int numOfDatas = reader.ReadInt32();
                    //        var idx = reader.ReadInt32();

                    //        if (idx == 0)
                    //        {
                    //            textureByteData.Clear();
                    //        }

                    //        textureByteData.AddRange(reader.ReadBytes());

                    //        if (idx == numOfDatas)
                    //        {
                    //            MemoryStream ms = new MemoryStream();
                    //            var gzBuffer = textureByteData.ToArray();
                    //            int msgLength = BitConverter.ToInt32(gzBuffer, 0);
                    //            ms.Write(gzBuffer, 4, gzBuffer.Length - 4);

                    //            byte[] buffer = new byte[msgLength];

                    //            ms.Position = 0;
                    //            GZipStream zip = new GZipStream(ms, CompressionMode.Decompress);
                    //            zip.Read(buffer, 0, buffer.Length);

                    //            SetCameraTexture(buffer);
                    //        }
                    //    }
                    //    break;
                }
            }
        }
    }