protected override void Parse(ref BitStreamReader bsr) { SpecMode = (SpectatorMode)bsr.ReadByte(); Target1 = bsr.ReadByte(); Target2 = bsr.ReadByte(); Unknown = bsr.ReadByte(); }
// src_main/common/netmessages.cpp SVC_ServerInfo::WriteToBuffer protected override void Parse(ref BitStreamReader bsr) { NetworkProtocol = bsr.ReadUShort(); ServerCount = bsr.ReadUInt(); IsHltv = bsr.ReadBool(); IsDedicated = bsr.ReadBool(); if (DemoInfo.IsLeft4Dead() && DemoInfo.Game >= SourceGame.L4D2_2147) { UnknownBit = bsr.ReadBool(); } ClientCrc = bsr.ReadSInt(); if (DemoInfo.NewDemoProtocol) // unknown field, could be before ClientCrc { Unknown = bsr.ReadUInt(); } MaxServerClasses = bsr.ReadUShort(); if (NetworkProtocol == 24) { MapMD5 = bsr.ReadBytes(16); } else { MapCrc = bsr.ReadUInt(); // network protocol < 18 according to p2 leak, but doesn't add up for l4d2 and p2 } PlayerCount = bsr.ReadByte(); MaxClients = bsr.ReadByte(); TickInterval = bsr.ReadFloat(); Platform = (char)bsr.ReadByte(); GameDirBitIndex = bsr.AbsoluteBitIndex; GameDir = bsr.ReadNullTerminatedString(); MapName = bsr.ReadNullTerminatedString(); SkyName = bsr.ReadNullTerminatedString(); HostName = bsr.ReadNullTerminatedString(); if (DemoInfo.IsLeft4Dead() && DemoInfo.Game >= SourceGame.L4D2_2147) { MissionName = bsr.ReadNullTerminatedString(); MutationName = bsr.ReadNullTerminatedString(); } if (NetworkProtocol == 24) { HasReplay = bsr.ReadBool(); // protocol version >= 16 } // there's a good change that the first SvcServerInfo parsed is parsed correctly // prevent the interval from being overwritten by subsequent, incorrectly detected, SvcServerInfo messages // TODO: check if changing tickrate mid game sends another SvcServerInfo if (!DemoInfo.HasParsedTickInterval) { DemoInfo.TickInterval = TickInterval; DemoInfo.HasParsedTickInterval = true; } // this packet always(?) appears before the creation of any tables DemoRef.StringTablesManager.ClearCurrentTables(); // init baselines here DemoRef.EntBaseLines = new EntityBaseLines(DemoRef, MaxServerClasses); }
protected override void Parse(ref BitStreamReader bsr) { ClientId = bsr.ReadByte(); Str = bsr.ReadNullTerminatedString(); WantsToChat = bsr.ReadByte() != 0; /*if (DemoInfo.NewDemoProtocol) * Unknown = bsr.ReadByte() != 0;*/ }
protected override void Parse(ref BitStreamReader bsr) { Duration = bsr.ReadUShort() / (float)(1 << 9); // might be useful: #define SCREENFADE_FRACBITS 9 HoldTime = bsr.ReadUShort(); Flags = (FadeFlags)bsr.ReadUShort(); R = bsr.ReadByte(); G = bsr.ReadByte(); B = bsr.ReadByte(); A = bsr.ReadByte(); }
protected override void Parse(ref BitStreamReader bsr) { PortalEnt = bsr.ReadUShort(); OwnerEnt = bsr.ReadUShort(); Team = bsr.ReadByte(); PortalNum = bsr.ReadByte(); Effect = (PortalFizzleType)bsr.ReadByte(); bsr.ReadVectorCoord(out Origin); bsr.ReadVectorCoord(out Angles); }
public DamageInfoMessage Deserialize(BlubSerializer serializer, BinaryReader reader) { var message = new DamageInfoMessage(); message.Target = reader.ReadUInt16(); message.AttackAttribute = reader.ReadEnum <AttackAttribute>(); message.GameTime = reader.ReadUInt32(); message.Source = reader.ReadUInt16(); message.Unk5 = reader.ReadByte(); message.Rotation = reader.ReadRotation(); message.Position = reader.ReadCompressedVector3(); message.Unk6 = reader.ReadCompressedFloat(); message.Damage = reader.ReadCompressedFloat(); message.Unk8 = reader.ReadInt16(); message.Unk9 = reader.ReadUInt16(); var br = new BitStreamReader(reader.ReadBytes(3)); message.Flag1 = br.ReadByte(3); message.Flag2 = br.ReadByte(2); message.Flag3 = br.ReadByte(1); message.Flag4 = br.ReadByte(1); message.Flag5 = br.ReadByte(1); message.Flag6 = br.ReadByte(1); message.Flag7 = br.ReadByte(7); message.IsCritical = br.ReadByte(4); message.Flag9 = br.ReadByte(4); return(message); }
public LiteralValuePacket(byte version, byte typeId, BitStreamReader reader) : base(version, typeId) { Value = 0; while (reader.ReadBit()) { Value = Value << 4; Value |= reader.ReadByte(4); } Value = Value << 4; Value |= reader.ReadByte(4); }
protected override void Parse(ref BitStreamReader bsr) { Armor = bsr.ReadByte(); DamageTaken = bsr.ReadByte(); BitsDamage = bsr.ReadSInt(); bsr.ReadVector3(out VecFrom); /*VecFrom = new Vector3 { old engine? * X = bsr.ReadCoord(), * Y = bsr.ReadCoord(), * Z = bsr.ReadCoord() * };*/ }
protected override void Parse(ref BitStreamReader bsr) { Message = bsr.ReadNullTerminatedString(); Show = bsr.ReadByte() != 0; int count = bsr.ReadByte(); KeyValues = new List <KeyValuePair <string, string> >(); for (int i = 0; i < count; i++) { KeyValues.Add(new KeyValuePair <string, string>( bsr.ReadNullTerminatedString(), bsr.ReadNullTerminatedString())); } }
void ReadAlignment(BitStreamReader reader, VoidDsdlType t) { var amount = t.MaxBitlen; while (amount > 8) { reader.ReadByte(8); amount -= 8; } if (amount > 0) { reader.ReadByte(amount); } }
protected override void Parse(ref BitStreamReader bsr) { Client = bsr.ReadByte(); WantsToChat = bsr.ReadBool(); // TODO: fill out the rest of the UserMessage (don't know what SayText2 // is even but I guess it doesn't happen often at all since it hasn't broken a demo parse yet) }
protected override void Parse(ref BitStreamReader bsr) { Command = (ShakeCommand)bsr.ReadByte(); Amplitude = bsr.ReadFloat(); Frequency = bsr.ReadFloat(); Duration = bsr.ReadFloat(); }
public void EightBitsAndOneByteRead() { var data = new byte[] { 0x3c, 0x4b, 0x1a, 0x54, 0x22, 0x10, 0xaf, 0x89, 0x97, 0x65 }; var stream = new MemoryStream(data); var reader = new BitStreamReader(stream); Assert.AreEqual(true, reader.CanRead); Assert.AreEqual(true, reader.CanSeek); Assert.AreEqual(false, reader.CanWrite); Assert.AreEqual(80, reader.BitLength); Assert.AreEqual(0, reader.BitPosition); Assert.AreEqual(10, reader.Length); Assert.AreEqual(0, reader.Position); Assert.AreEqual(false, reader.ReadBoolean()); Assert.AreEqual(false, reader.ReadBoolean()); Assert.AreEqual(true, reader.ReadBoolean()); Assert.AreEqual(true, reader.ReadBoolean()); Assert.AreEqual(true, reader.ReadBoolean()); Assert.AreEqual(true, reader.ReadBoolean()); Assert.AreEqual(false, reader.ReadBoolean()); Assert.AreEqual(false, reader.ReadBoolean()); Assert.AreEqual(0x4b, reader.ReadByte()); Assert.AreEqual(80, reader.BitLength); Assert.AreEqual(16, reader.BitPosition); Assert.AreEqual(10, reader.Length); Assert.AreEqual(2, reader.Position); }
/// <summary> /// Private helper used to read an int, short or byte (in reverse order) from the reader /// and return an int /// </summary> /// <param name="reader"></param> /// <param name="type"></param> /// <returns></returns> private int GetDataFromReader(BitStreamReader reader, GorillaEncodingType type) { switch (type) { case GorillaEncodingType.Int: { return((int)reader.ReadUInt32Reverse(Native.BitsPerInt)); } case GorillaEncodingType.Short: { return((int)reader.ReadUInt16Reverse(Native.BitsPerShort)); } case GorillaEncodingType.Byte: { return((int)reader.ReadByte(Native.BitsPerByte)); } default: { throw new ArgumentException(StrokeCollectionSerializer.ISFDebugMessage("bogus GorillaEncodingType passed to GetDataFromReader")); } } }
public static Packet CreatePacket(BitStreamReader reader) { Packet packet = null; byte version = reader.ReadByte(3); byte packetId = reader.ReadByte(3); switch (packetId) { case 0: packet = new SumPacket(version, packetId, reader); break; case 1: packet = new ProductPacket(version, packetId, reader); break; case 2: packet = new MinimumPacket(version, packetId, reader); break; case 3: packet = new MaximumPacket(version, packetId, reader); break; case 4: packet = new LiteralValuePacket(version, packetId, reader); break; case 5: packet = new GreaterThanPacket(version, packetId, reader); break; case 6: packet = new LessThanPacket(version, packetId, reader); break; case 7: packet = new EqualToPacket(version, packetId, reader); break; default: throw new InvalidOperationException("Not a valid packet type"); } return(packet); }
protected override void Parse(ref BitStreamReader bsr) { Codec = bsr.ReadNullTerminatedString(); Quality = bsr.ReadByte(); if (Quality == 255) { Unknown = bsr.ReadFloat(); } }
protected override void Parse(ref BitStreamReader bsr) { Destination = (TextMsgDestination)bsr.ReadByte(); Messages = new string[MessageCount]; for (int i = 0; i < MessageCount; i++) { Messages[i] = bsr.ReadNullTerminatedString(); } }
protected override void Parse(ref BitStreamReader bsr) { Count = bsr.ReadByte(); if (Count != 1) { DemoRef.LogError($"{GetType()} is borking, there should only be one string but count is {Count}"); } KeyString = bsr.ReadNullTerminatedString(); }
/* Okay, this is pretty wacky. First I read a byte, and based off of that I try to determine the type of * user message. If I don't have a lookup list for whatever game this is or the type seems bogus, I log an * error. Otherwise, create the message instance, and if it's not empty, try to parse it. If parsing fails, * log an error. Finally, if not all bits of the message are parsed, then it's likely that I did something * wrong, (since it seems like the user messages use up all the bits in the message) so log an error. */ protected override void Parse(ref BitStreamReader bsr) { byte typeVal = bsr.ReadByte(); MessageType = UserMessage.ByteToUserMessageType(DemoInfo, typeVal); uint messageLength = bsr.ReadUInt(DemoInfo.UserMessageLengthBits); string?errorStr = null; var uMessageReader = bsr.SplitAndSkip(messageLength); switch (MessageType) { case UserMessageType.Unknown: errorStr = $"There is no SvcUserMessage list for this game, type {typeVal} was found"; break; case UserMessageType.Invalid: errorStr = $"SvcUserMessage with value {typeVal} is invalid"; break; default: UserMessage = SvcUserMessageFactory.CreateUserMessage(DemoRef, MessageType) !; if (UserMessage == null) { errorStr = $"Unimplemented SvcUserMessage: {MessageType}"; _unimplemented = true; } else { try { // empty messages might still have 1-2 bytes, might need to do something 'bout that if (UserMessage.ParseStream(uMessageReader) != 0) { errorStr = $"{GetType().Name} - {MessageType} ({typeVal}) didn't parse all bits"; } } catch (Exception e) { errorStr = $"{GetType().Name} - {MessageType} ({typeVal}) " + $"threw exception during parsing, message: {e.Message}"; } } break; } #region error logging // if parsing fails, just convert to an unknown type - the byte array that it will print is still useful if (errorStr != null) { int rem = uMessageReader.BitsRemaining; DemoRef.LogError($"{errorStr}, ({rem} bit{(rem == 1 ? "" : "s")}) - " + $"{uMessageReader.FromBeginning().ToHexString()}"); UserMessage = new UnknownUserMessage(DemoRef); UserMessage.ParseStream(uMessageReader); } #endregion }
protected override void Parse(ref BitStreamReader bsr) { EntryCount = bsr.ReadByte(); uint bitLen = DemoInfo.Game == SourceGame.PORTAL_1_1910503 ? bsr.ReadVarUInt32() : bsr.ReadUInt(DemoInfo.IsLeft4Dead2() ? 18 : 17); _data = bsr.SplitAndSkip(bitLen); // todo }
// we're reading a player_info_t, so take alignment into account protected override void Parse(ref BitStreamReader bsr) { if (DemoInfo.NewDemoProtocol && !DemoInfo.IsLeft4Dead1()) { SteamId = (CSteamId)bsr.ReadULong(); } Name = bsr.ReadStringOfLength(MaxPlayerNameLength); UserId = bsr.ReadSInt(); Guid = bsr.ReadStringOfLength(SignedGuidLen + 1); bsr.SkipBytes(3); FriendsId = bsr.ReadUInt(); FriendsName = bsr.ReadStringOfLength(MaxPlayerNameLength); FakePlayer = bsr.ReadByte() != 0; IsHlTv = bsr.ReadByte() != 0; bsr.SkipBytes(2); CustomFiles = new[] { bsr.ReadUInt(), bsr.ReadUInt(), bsr.ReadUInt(), bsr.ReadUInt() }; FilesDownloaded = bsr.ReadByte(); bsr.SkipBytes(3); // for demo protocol 4 there's 4 additional bytes somewhere for some reason }
public static void Deserialize(ref Guid value, BitStreamReader reader) { byte[] b = new byte[BYTE_COUNT]; for (int i = 0; i < BYTE_COUNT; i++) { b[i] = reader.ReadByte(); } value = new Guid(b); }
protected override void Parse(ref BitStreamReader bsr) { PaintType = (PaintType)bsr.ReadByte(); EHandle = bsr.ReadEHandle(); UnkHf1 = bsr.ReadFloat(); UnkHf2 = bsr.ReadFloat(); byte len = bsr.ReadByte(); bsr.ReadVector3(out Center); if (bsr.BitsRemaining % 48 != 0) { throw new ParseException($"{GetType().Name} doesn't have the right number of bits left, " + $"expected a multiple of 48 but got {bsr.BitsRemaining}"); } Positions = new Vector3[len]; for (int i = 0; i < len; i++) { Positions[i] = Center + new Vector3(bsr.ReadSShort(), bsr.ReadSShort(), bsr.ReadSShort()); } }
protected override void Parse(ref BitStreamReader bsr) { Channel = (HudChannel)(bsr.ReadByte() % MaxNetMessage); // if ( !pNetMessage || !pNetMessage->pMessage ) // return; // ^ Since this is what the game does, I will simply keep reading if there are more bytes left if (bsr.BitsRemaining >= 148) { MsgInfo = new HudMsgInfo(DemoRef); MsgInfo.ParseStream(ref bsr); } }
public void Test_ReadByte() { BitStreamWriter writer = new BitStreamWriter(stream); BitStreamReader reader = new BitStreamReader(stream); writer.Write(125, 7); byte result = reader.ReadByte(_fixture.index, 7); _fixture.index += 7; Assert.Equal(125, result); }
protected override void Parse(ref BitStreamReader bsr) { PlayerMasks = new PlayerMask[VoiceMaxPlayers]; for (int i = 0; i < VoiceMaxPlayers; i++) { PlayerMasks[i] = new PlayerMask { GameRulesMask = bsr.ReadSInt(), BanMask = bsr.ReadSInt() } } ; PlayerModEnable = bsr.ReadByte() != 0; }
protected override void Parse(ref BitStreamReader bsr) { X = bsr.ReadFloat(); Y = bsr.ReadFloat(); R1 = bsr.ReadByte(); G1 = bsr.ReadByte(); B1 = bsr.ReadByte(); A1 = bsr.ReadByte(); R2 = bsr.ReadByte(); G2 = bsr.ReadByte(); B2 = bsr.ReadByte(); A2 = bsr.ReadByte(); Effect = (HudMsgEffect)bsr.ReadByte(); FadeIn = bsr.ReadFloat(); FadeOut = bsr.ReadFloat(); HoldTime = bsr.ReadFloat(); FxTime = bsr.ReadFloat(); Message = bsr.ReadNullTerminatedString(); }
public void SetPosition() { var data = new byte[] { 0x3c, 0x4b, 0x1a, 0x54, 0x22, 0x10, 0xaf, 0x89, 0x97, 0x65 }; var stream = new MemoryStream(data); var reader = new BitStreamReader(stream); Assert.AreEqual(true, reader.CanRead); Assert.AreEqual(true, reader.CanSeek); Assert.AreEqual(false, reader.CanWrite); Assert.AreEqual(80, reader.BitLength); Assert.AreEqual(0, reader.BitPosition); Assert.AreEqual(10, reader.Length); Assert.AreEqual(0, reader.Position); reader.Position = 7; Assert.AreEqual(56, reader.BitPosition); Assert.AreEqual(7, reader.Position); Assert.AreEqual(0x89, reader.ReadByte()); Assert.AreEqual(true, reader.ReadBoolean()); Assert.AreEqual(7, reader.Position = 7); Assert.AreEqual(true, reader.ReadBoolean()); Assert.AreEqual(0x13, reader.ReadByte()); var buffer = new byte[10]; Assert.AreEqual(1, reader.Read(buffer, 0, 10)); Assert.AreEqual(0x2e, buffer[0]); Assert.AreEqual(-1, reader.ReadByte()); Assert.AreEqual(73, reader.BitPosition); Assert.AreEqual(9, reader.Position); }
protected override void Parse(ref BitStreamReader bsr) { Reliable = bsr.ReadBool(); int soundCount = Reliable ? 1 : bsr.ReadByte(); int dataBitLen = (int)bsr.ReadUInt(Reliable ? 8 : 16); BitStreamReader soundBsr = bsr.SplitAndSkip(dataBitLen); SoundInfo sound = new SoundInfo(DemoRef); SoundInfo delta = new SoundInfo(DemoRef); delta.SetDefault(); Exception?e = null; try { Sounds = new SoundInfo[soundCount]; for (int i = 0; i < soundCount; i++) { sound.ParseDelta(ref soundBsr, delta); delta = sound; if (Reliable) // client is incrementing the reliable sequence numbers itself { DemoRef.ClientSoundSequence = ++DemoRef.ClientSoundSequence & SndSeqNumMask; if (sound.SequenceNumber != 0) { throw new ArgumentException($"expected sequence number 0, got: {sound.SequenceNumber}"); } sound.SequenceNumber = DemoRef.ClientSoundSequence; } Sounds[i] = new SoundInfo(sound); } } catch (Exception exp) { e = exp; } if (e != null) { Sounds = null; DemoRef.LogError($"exception while parsing {nameof(SoundInfo)}: {e.Message}"); } else if (soundBsr.BitsRemaining != 0) { Sounds = null; DemoRef.LogError($"exception while parsing {nameof(SoundInfo)}: {soundBsr.BitsRemaining} bits left to read"); } }
public void CompletelyRead() { var data = new byte[] { 0x3c, 0x4b, 0x1a, 0x54, 0x22, 0x10, 0xaf, 0x89, 0x97, 0x65 }; var stream = new MemoryStream(data); var reader = new BitStreamReader(stream); Assert.AreEqual(true, reader.CanRead); Assert.AreEqual(true, reader.CanSeek); Assert.AreEqual(false, reader.CanWrite); Assert.AreEqual(80, reader.BitLength); Assert.AreEqual(0, reader.BitPosition); Assert.AreEqual(10, reader.Length); Assert.AreEqual(0, reader.Position); Assert.AreEqual(false, reader.ReadBoolean()); Assert.AreEqual(false, reader.ReadBoolean()); Assert.AreEqual(true, reader.ReadBoolean()); Assert.AreEqual(true, reader.ReadBoolean()); Assert.AreEqual(true, reader.ReadBoolean()); Assert.AreEqual(true, reader.ReadBoolean()); Assert.AreEqual(false, reader.ReadBoolean()); Assert.AreEqual(false, reader.ReadBoolean()); Assert.AreEqual(0x4b, reader.ReadByte()); var expected = new byte[8]; Array.Copy(data, 2, expected, 0, 8); var result = new byte[8]; int toRead = 8; while (toRead > 0) { int read = reader.Read(result, 8 - toRead, toRead); toRead -= read; } CollectionAssert.AreEqual(expected, result); Assert.AreEqual(80, reader.BitLength); Assert.AreEqual(80, reader.BitPosition); Assert.AreEqual(10, reader.Length); Assert.AreEqual(10, reader.Position); }
/// <summary> /// Private helper used to read an int, short or byte (in reverse order) from the reader /// and return an int /// </summary> /// <param name="reader"></param> /// <param name="type"></param> /// <returns></returns> private int GetDataFromReader(BitStreamReader reader, GorillaEncodingType type) { switch (type) { case GorillaEncodingType.Int: { return (int)reader.ReadUInt32Reverse(Native.BitsPerInt); } case GorillaEncodingType.Short: { return (int)reader.ReadUInt16Reverse(Native.BitsPerShort); } case GorillaEncodingType.Byte: { return (int)reader.ReadByte(Native.BitsPerByte); } default: { throw new ArgumentException(StrokeCollectionSerializer.ISFDebugMessage("bogus GorillaEncodingType passed to GetDataFromReader")); } } }