Пример #1
0
        public void EncodeThenDecode_ReturnsOriginalString()
        {
            const string expected = "Test map string to encode";

            var bytes  = _service.EncodeMapString(expected);
            var actual = _service.DecodeMapString(bytes);

            Assert.AreEqual(expected, actual);
        }
Пример #2
0
        public SignMapEntity DeserializeFromByteArray(byte[] data)
        {
            if (data.Length < SignMapEntity.DATA_SIZE) //using < for comparison because data will be an unknown length based on message
            {
                throw new ArgumentException("Data is improperly size for serialization", nameof(data));
            }

            var sign = new SignMapEntity()
                       .WithX(numberEncoderService.DecodeNumber(data[0]))
                       .WithY(numberEncoderService.DecodeNumber(data[1]));

            var titleAndMessageLength = numberEncoderService.DecodeNumber(data[2], data[3]) - 1;

            if (data.Length != SignMapEntity.DATA_SIZE + titleAndMessageLength)
            {
                throw new ArgumentException("Data is improperly sized for deserialization", nameof(data));
            }

            var rawTitleAndMessage = data.Skip(4).Take(titleAndMessageLength).ToArray();
            var titleLength        = numberEncoderService.DecodeNumber(data[4 + titleAndMessageLength]);

            var titleAndMessage = mapStringEncoderService.DecodeMapString(rawTitleAndMessage);

            sign = sign.WithTitle(titleAndMessage.Substring(0, titleLength))
                   .WithMessage(titleAndMessage.Substring(titleLength));

            return(sign);
        }
Пример #3
0
        public IMapFileProperties DeserializeFromByteArray(byte[] data)
        {
            IMapFileProperties properties = new MapFileProperties();

            if (data.Length != MapFileProperties.DATA_SIZE)
            {
                throw new ArgumentException("Data is not sized correctly for proper deserialization", nameof(data));
            }

            var typeString = Encoding.ASCII.GetString(data.Take(3).ToArray());

            if (typeString != properties.FileType)
            {
                throw new FormatException("Data is not correctly formatted! Must be an EMF file header");
            }

            var checksumArray = data.Skip(3).Take(4).ToArray();
            var mapNameArray  = data.Skip(7).Take(24).ToArray();
            var mapName       = _mapStringEncoderService.DecodeMapString(mapNameArray);

            properties = properties.WithChecksum(checksumArray)
                         .WithName(mapName)
                         .WithPKAvailable(_numberEncoderService.DecodeNumber(data[31]) == 3 ||
                                          (mapNameArray[0] == 0xFF && mapNameArray[1] == 0x01))
                         .WithEffect((MapEffect)_numberEncoderService.DecodeNumber(data[32]))
                         .WithMusic((byte)_numberEncoderService.DecodeNumber(data[33]))
                         .WithMusicExtra((byte)_numberEncoderService.DecodeNumber(data[34]))
                         .WithAmbientNoise((short)_numberEncoderService.DecodeNumber(data[35], data[36]))
                         .WithWidth((byte)_numberEncoderService.DecodeNumber(data[37]))
                         .WithHeight((byte)_numberEncoderService.DecodeNumber(data[38]))
                         .WithFillTile((short)_numberEncoderService.DecodeNumber(data[39], data[40]))
                         .WithMapAvailable(_numberEncoderService.DecodeNumber(data[41]) == 1)
                         .WithScrollAvailable(_numberEncoderService.DecodeNumber(data[42]) == 1)
                         .WithRelogX((byte)_numberEncoderService.DecodeNumber(data[43]))
                         .WithRelogY((byte)_numberEncoderService.DecodeNumber(data[44]))
                         .WithUnknown2((byte)_numberEncoderService.DecodeNumber(data[45]));

            return(properties);
        }