public void ReadHeader()
{
Header = new DemoHeader();
Header.Header = StringUtils.ReadNullTerminatedString(_binaryReader);
if (Header.Header != SOURCE_ENGINE_DEMO_HEADER)
{
throw new FileLoadException($"Demo header '{Header.Header}' is not equal to '{SOURCE_ENGINE_DEMO_HEADER}'!");
}
Header.DemoProtocol = _binaryReader.ReadInt32();
if (Header.DemoProtocol != SOURCE_ENGINE_DEMO_PROTOCOL)
{
throw new FileLoadException($"Demo protocol '{Header.DemoProtocol}' is not equal to '{SOURCE_ENGINE_DEMO_PROTOCOL}'!");
}
Header.NetworkProtocol = _binaryReader.ReadInt32();
Header.ServerName = StringUtils.ReadSizedNullString(_binaryReader, 260);
Header.ClientName = StringUtils.ReadSizedNullString(_binaryReader, 260);
Header.MapName = StringUtils.ReadSizedNullString(_binaryReader, 260);
Header.GameDirectory = StringUtils.ReadSizedNullString(_binaryReader, 260);
Header.PlaybackTime = _binaryReader.ReadSingle();
Header.Ticks = _binaryReader.ReadInt32();
Header.Frames = _binaryReader.ReadInt32();
Header.SignonDataLength = _binaryReader.ReadInt32();
}
private void ParserHeader(string folderName, string fileName)
{
DateTime dateFile = File.GetCreationTime(folderName + fileName);
txtResult.AppendText("=======Start Parser " + fileName + " at " + DateTime.Now + "=============");
txtResult.AppendText(Environment.NewLine);
try
{
parser.ParseHeader();
}
catch (Exception ex)
{
MessageBox.Show("Exception:" + ex.ToString());
}
DemoHeader header = parser.Header;
FileInfo fi = new FileInfo(folderName + fileName);
int seconds = (int)fi.LastWriteTime.Subtract(new DateTime(1970, 1, 1)).TotalSeconds;
txtResult.AppendText(header.MapName.Replace("/", "") + "_" + header.SignonLength + header.PlaybackTicks + header.PlaybackFrames + seconds + fi.Length);
txtResult.AppendText(Environment.NewLine);
txtResult.AppendText("Client name: " + header.ClientName);
txtResult.AppendText(Environment.NewLine);
txtResult.AppendText("Server name: " + header.ServerName);
txtResult.AppendText(Environment.NewLine);
if (header.PlaybackTicks != 0 && header.PlaybackTime != 0)
{
txtResult.AppendText(("Tick Rate: " + header.PlaybackTicks / header.PlaybackTime).ToString());
txtResult.AppendText(Environment.NewLine);
}
else
{
txtResult.AppendText("corrupted");
txtResult.AppendText(Environment.NewLine);
}
if (header.PlaybackFrames != 0 && header.PlaybackTime != 0)
{
//Tick rate
txtResult.AppendText("Tick Rate: " + ((int)Math.Round((double)header.PlaybackFrames / header.PlaybackTime)).ToString());
txtResult.AppendText(Environment.NewLine);
}
txtResult.AppendText("Playback time: " + header.PlaybackTime.ToString()); //Duration
txtResult.AppendText(Environment.NewLine);
txtResult.AppendText("Map name: " + header.MapName);
txtResult.AppendText(Environment.NewLine);
txtResult.AppendText("Playback tick: " + header.PlaybackTicks.ToString());
txtResult.AppendText(Environment.NewLine);
}
public static unsafe Header ConvertToClass(this DemoHeader structHeader)
{
var header = new Header
{
Demofilestamp = FixedByteArrayHelper.ConvertToString(structHeader.Demofilestamp),
Clientname = FixedByteArrayHelper.ConvertToString(structHeader.Clientname),
Gamedirectory = FixedByteArrayHelper.ConvertToString(structHeader.Gamedirectory),
Mapname = FixedByteArrayHelper.ConvertToString(structHeader.Mapname),
Servername = FixedByteArrayHelper.ConvertToString(structHeader.Servername),
Demoprotocol = structHeader.Demoprotocol,
Networkprotocol = structHeader.Networkprotocol,
PlaybackFrames = structHeader.PlaybackFrames,
PlaybackTime = structHeader.PlaybackTime,
PlaybackTicks = structHeader.PlaybackTicks,
Signonlength = structHeader.Signonlength
};
return(header);
}
public static void WriteHeader(SourceDemo demo, TextWriter tw, bool writeDemoName = true)
{
DemoHeader h = demo.Header;
if (writeDemoName)
{
tw.WriteLine($"{"File name ",FmtIdt}: {demo.FileName}");
}
tw.Write(
$"{"Demo protocol ", FmtIdt}: {h.DemoProtocol}" +
$"\n{"Network protocol ", FmtIdt}: {h.NetworkProtocol}" +
$"\n{"Server name ", FmtIdt}: {h.ServerName}" +
$"\n{"Client name ", FmtIdt}: {h.ClientName}" +
$"\n{"Map name ", FmtIdt}: {h.MapName}" +
$"\n{"Game directory ", FmtIdt}: {h.GameDirectory}" +
$"\n{"Playback time ", FmtIdt}: {Utils.FormatTime(h.PlaybackTime)}" +
$"\n{"Ticks ", FmtIdt}: {h.TickCount}" +
$"\n{"Frames ", FmtIdt}: {h.FrameCount}" +
$"\n{"SignOn Length ", FmtIdt}: {h.SignOnLength}\n\n");
}
protected override void Parse(ref BitStreamReader bsr)
{
if ((DemoParseResult & DemoParseResult.DataTooLong) != 0)
{
throw new InvalidDataException("data too long");
}
// make sure we set the demo settings first
Header = new DemoHeader(this);
Header.ParseStream(ref bsr);
DemoInfo = new DemoInfo(this);
// it might be worth it to implement updating helper classes with listeners, but it's not a huge deal atm
StringTablesManager = new StringTablesManager(this);
ErrorList = new List <string>();
DecompressedLookup = new List <byte[]>();
Frames = new List <PacketFrame>();
StartTick = 0;
try {
PacketFrame frame;
do
{
frame = new PacketFrame(this);
Frames.Add(frame);
frame.ParseStream(ref bsr);
_parseProgress?.Report((double)bsr.CurrentBitIndex / bsr.BitLength);
} while (frame.Type != PacketType.Stop && bsr.BitsRemaining >= 24); // would be 32 but the last byte is often cut off
StartAdjustmentTick ??= 0;
EndTick = this.FilterForPacket <Packet>().Select(packet => packet.Tick).Where(i => i >= 0).Max();
}
catch (Exception e) {
_exceptionDuringParsing = true;
Debug.WriteLine($"Exception after parsing {Frames.Count - 1} packets");
LogError($"Exception after parsing {Frames.Count - 1} packets: {e.Message}");
throw;
}
EndAdjustmentTick ??= EndTick;
DemoParseResult |= DemoParseResult.Success;
}
public Archive(DemoHeader demoHeader, ReplayHeader replayHeader)
{
DemoHeader = demoHeader;
ReplayHeader = replayHeader;
}
public HeaderParsedEventArgs(DemoHeader header)
{
this.Header = header;
}
void demoParser_HeaderParsed(object sender, HeaderParsedEventArgs e)
{
demoHeader = demoParser.Header;
}
public ChunkArchive(Memory <byte> memory, DemoHeader demoHeader, ReplayHeader replayHeader) : base(demoHeader, replayHeader)
{
_reader = new MemoryReader(memory, Endianness.Little);
}
public BitArchive(Memory <byte> data, DemoHeader demoHeader, ReplayHeader replayHeader)
: base(demoHeader, replayHeader)
{
_bitReader = new BitReader(data);
}
