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"));
}
}
}
