From 77e4b066cb8d506b4bc944ab4eb2d6e4679e2202 Mon Sep 17 00:00:00 2001 From: Arda Serdar Pektezol <1669855+pektezol@users.noreply.github.com> Date: Sat, 15 Jun 2024 13:58:30 +0300 Subject: enable multithreading with goroutines (#20) --- pkg/classes/consoleCmd.go | 10 +-- pkg/classes/customData.go | 19 +++-- pkg/classes/dataTables.go | 74 ++++++++--------- pkg/classes/packet.go | 50 +++++------ pkg/classes/sarData.go | 196 ++++++++++++++++++++++---------------------- pkg/classes/signOn.go | 36 ++++---- pkg/classes/stop.go | 8 +- pkg/classes/stringTables.go | 128 ++++++++++++++--------------- pkg/classes/userCmd.go | 58 ++++++------- 9 files changed, 290 insertions(+), 289 deletions(-) (limited to 'pkg/classes') diff --git a/pkg/classes/consoleCmd.go b/pkg/classes/consoleCmd.go index 47a44e0..83f7333 100644 --- a/pkg/classes/consoleCmd.go +++ b/pkg/classes/consoleCmd.go @@ -4,16 +4,16 @@ import ( "strings" "github.com/pektezol/bitreader" - "github.com/pektezol/sdp.go/pkg/writer" + "github.com/pektezol/sdp.go/pkg/types" ) type ConsoleCmd struct { - Size int32 - Data string + Size int32 `json:"size"` + Data string `json:"data"` } -func (consoleCmd *ConsoleCmd) ParseConsoleCmd(reader *bitreader.Reader) { +func (consoleCmd *ConsoleCmd) ParseConsoleCmd(reader *bitreader.Reader, demo *types.Demo) { consoleCmd.Size = reader.TryReadSInt32() consoleCmd.Data = reader.TryReadStringLength(uint64(consoleCmd.Size)) - writer.AppendLine("\t%s", strings.TrimSpace(consoleCmd.Data)) + demo.Writer.AppendLine("\t%s", strings.TrimSpace(consoleCmd.Data)) } diff --git a/pkg/classes/customData.go b/pkg/classes/customData.go index 1d6f30a..4c1a79e 100644 --- a/pkg/classes/customData.go +++ b/pkg/classes/customData.go @@ -2,29 +2,30 @@ package classes import ( "github.com/pektezol/bitreader" - "github.com/pektezol/sdp.go/pkg/writer" + "github.com/pektezol/sdp.go/pkg/types" ) type CustomData struct { - Type int32 - Size int32 - Data string + Type int32 `json:"type"` + Size int32 `json:"size"` + Data any `json:"data"` } -func (customData *CustomData) ParseCustomData(reader *bitreader.Reader, tickNumber int32, packetType uint8) { +func (customData *CustomData) ParseCustomData(reader *bitreader.Reader, tickNumber int32, packetType uint8, demo *types.Demo) { customData.Type = reader.TryReadSInt32() customData.Size = reader.TryReadSInt32() if customData.Type != 0 || customData.Size == 8 { // Not SAR data - writer.AppendLine("[%d] %s (%d):", tickNumber, "CUSTOMDATA", packetType) + demo.Writer.AppendLine("[%d] %s (%d):", tickNumber, "CUSTOMDATA", packetType) customData.Data = string(reader.TryReadBytesToSlice(uint64(customData.Size))) - writer.AppendLine("\t%s", customData.Data) + demo.Writer.AppendLine("\t%s", customData.Data) return } // SAR data - writer.AppendLine("[%d] %s (%d):", tickNumber, "SARDATA", packetType) + demo.Writer.AppendLine("[%d] %s (%d):", tickNumber, "SARDATA", packetType) sarData := SarData{} data := reader.TryReadBytesToSlice(uint64(customData.Size)) sarReader := bitreader.NewReaderFromBytes(data, true) - sarData.ParseSarData(sarReader) + sarData.ParseSarData(sarReader, demo) + customData.Data = sarData } diff --git a/pkg/classes/dataTables.go b/pkg/classes/dataTables.go index 50be8fe..cf3762a 100644 --- a/pkg/classes/dataTables.go +++ b/pkg/classes/dataTables.go @@ -4,59 +4,59 @@ import ( "fmt" "github.com/pektezol/bitreader" - "github.com/pektezol/sdp.go/pkg/writer" + "github.com/pektezol/sdp.go/pkg/types" ) type DataTables struct { - Size int32 - SendTable []SendTable - ServerClassInfo []ServerClassInfo + Size int32 `json:"size"` + SendTable []SendTable `json:"send_table"` + ServerClassInfo []ServerClassInfo `json:"server_class_info"` } type SendTable struct { - NeedsDecoder bool - NetTableName string - NumOfProps int16 - Props []SendTableProp + NeedsDecoder bool `json:"needs_decoder"` + NetTableName string `json:"net_table_name"` + NumOfProps int16 `json:"num_of_props"` + Props []SendTableProp `json:"props"` } type ServerClassInfo struct { - DataTableID uint16 - ClassName string - DataTableName string + DataTableID uint16 `json:"data_table_id"` + ClassName string `json:"class_name"` + DataTableName string `json:"data_table_name"` } type SendTableProp struct { - SendPropType SendPropType - SendPropName string - SendPropFlags uint32 - Priority uint8 - ExcludeDtName string - LowValue float32 - HighValue float32 - NumBits int32 - NumElements int32 + SendPropType SendPropType `json:"send_prop_type"` + SendPropName string `json:"send_prop_name"` + SendPropFlags uint32 `json:"send_prop_flags"` + Priority uint8 `json:"priority"` + ExcludeDtName string `json:"exclude_dt_name"` + LowValue float32 `json:"low_value"` + HighValue float32 `json:"high_value"` + NumBits int32 `json:"num_bits"` + NumElements int32 `json:"num_elements"` } -func (dataTables *DataTables) ParseDataTables(reader *bitreader.Reader) { +func (dataTables *DataTables) ParseDataTables(reader *bitreader.Reader, demo *types.Demo) { dataTables.Size = int32(reader.TryReadSInt32()) dataTableReader := bitreader.NewReaderFromBytes(reader.TryReadBytesToSlice(uint64(dataTables.Size)), true) count := 0 for dataTableReader.TryReadBool() { count++ - dataTables.SendTable = append(dataTables.SendTable, ParseSendTable(dataTableReader)) + dataTables.SendTable = append(dataTables.SendTable, ParseSendTable(dataTableReader, demo)) } - writer.AppendLine("\t%d Send Tables:", count) - writer.AppendOutputFromTemp() + demo.Writer.AppendLine("\t%d Send Tables:", count) + demo.Writer.AppendOutputFromTemp() numOfClasses := dataTableReader.TryReadBits(16) for count = 0; count < int(numOfClasses); count++ { - dataTables.ServerClassInfo = append(dataTables.ServerClassInfo, ParseServerClassInfo(dataTableReader, count, int(numOfClasses))) + dataTables.ServerClassInfo = append(dataTables.ServerClassInfo, ParseServerClassInfo(dataTableReader, count, int(numOfClasses), demo)) } - writer.AppendLine("\t%d Classes:", count) - writer.AppendOutputFromTemp() + demo.Writer.AppendLine("\t%d Classes:", count) + demo.Writer.AppendOutputFromTemp() } -func ParseSendTable(reader *bitreader.Reader) SendTable { +func ParseSendTable(reader *bitreader.Reader, demo *types.Demo) SendTable { sendTable := SendTable{ NeedsDecoder: reader.TryReadBool(), NetTableName: reader.TryReadString(), @@ -65,7 +65,7 @@ func ParseSendTable(reader *bitreader.Reader) SendTable { if sendTable.NumOfProps < 0 { return sendTable } - writer.TempAppendLine("\t\t%s (%d Props):", sendTable.NetTableName, sendTable.NumOfProps) + demo.Writer.TempAppendLine("\t\t%s (%d Props):", sendTable.NetTableName, sendTable.NumOfProps) for count := 0; count < int(sendTable.NumOfProps); count++ { propType := int8(reader.TryReadBits(5)) if propType >= int8(7) { @@ -77,38 +77,38 @@ func ParseSendTable(reader *bitreader.Reader) SendTable { SendPropFlags: uint32(reader.TryReadBits(19)), Priority: reader.TryReadUInt8(), } - writer.TempAppend("\t\t\t%s\t", prop.SendPropType) + demo.Writer.TempAppend("\t\t\t%s\t", prop.SendPropType) if propType == int8(ESendPropTypeDataTable) || checkBit(prop.SendPropFlags, 6) { prop.ExcludeDtName = reader.TryReadString() - writer.TempAppend(":\t%s\t", prop.ExcludeDtName) + demo.Writer.TempAppend(":\t%s\t", prop.ExcludeDtName) } else { switch propType { case int8(ESendPropTypeString), int8(ESendPropTypeInt), int8(ESendPropTypeFloat), int8(ESendPropTypeVector3), int8(ESendPropTypeVector2): prop.LowValue = reader.TryReadFloat32() prop.HighValue = reader.TryReadFloat32() prop.NumBits = int32(reader.TryReadBits(7)) - writer.TempAppend("Low: %f\tHigh: %f\t%d bits\t", prop.LowValue, prop.HighValue, prop.NumBits) + demo.Writer.TempAppend("Low: %f\tHigh: %f\t%d bits\t", prop.LowValue, prop.HighValue, prop.NumBits) case int8(ESendPropTypeArray): prop.NumElements = int32(reader.TryReadBits(10)) - writer.TempAppend("Elements: %d\t", prop.NumElements) + demo.Writer.TempAppend("Elements: %d\t", prop.NumElements) default: - writer.TempAppend("Unknown Prop Type: %v\t", propType) + demo.Writer.TempAppend("Unknown Prop Type: %v\t", propType) return sendTable } } - writer.TempAppend("Flags: %v\tPriority: %d\n", prop.GetFlags(), prop.Priority) + demo.Writer.TempAppend("Flags: %v\tPriority: %d\n", prop.GetFlags(), prop.Priority) sendTable.Props = append(sendTable.Props, prop) } return sendTable } -func ParseServerClassInfo(reader *bitreader.Reader, count int, numOfClasses int) ServerClassInfo { +func ParseServerClassInfo(reader *bitreader.Reader, count int, numOfClasses int, demo *types.Demo) ServerClassInfo { serverClassInfo := ServerClassInfo{ DataTableID: reader.TryReadUInt16(), ClassName: reader.TryReadString(), DataTableName: reader.TryReadString(), } - writer.TempAppendLine("\t\t\t[%d] %s (%s)", serverClassInfo.DataTableID, serverClassInfo.ClassName, serverClassInfo.DataTableName) + demo.Writer.TempAppendLine("\t\t\t[%d] %s (%s)", serverClassInfo.DataTableID, serverClassInfo.ClassName, serverClassInfo.DataTableName) return serverClassInfo } diff --git a/pkg/classes/packet.go b/pkg/classes/packet.go index 445ae91..c4f9676 100644 --- a/pkg/classes/packet.go +++ b/pkg/classes/packet.go @@ -5,32 +5,32 @@ import ( "github.com/pektezol/bitreader" "github.com/pektezol/sdp.go/pkg/messages" - "github.com/pektezol/sdp.go/pkg/writer" + "github.com/pektezol/sdp.go/pkg/types" ) const MSSC int = 2 type Packet struct { - PacketInfo []CmdInfo - InSequence uint32 - OutSequence uint32 - Size uint32 - Data []any + PacketInfo []CmdInfo `json:"packet_info"` + InSequence uint32 `json:"in_sequence"` + OutSequence uint32 `json:"out_sequence"` + Size uint32 `json:"size"` + Data []any `json:"data"` } type CmdInfo struct { - Flags uint32 - ViewOrigin []float32 - ViewAngles []float32 - LocalViewAngles []float32 - ViewOrigin2 []float32 - ViewAngles2 []float32 - LocalViewAngles2 []float32 + Flags uint32 `json:"flags"` + ViewOrigin []float32 `json:"view_origin"` + ViewAngles []float32 `json:"view_angles"` + LocalViewAngles []float32 `json:"local_view_angles"` + ViewOrigin2 []float32 `json:"view_origin_2"` + ViewAngles2 []float32 `json:"view_angles_2"` + LocalViewAngles2 []float32 `json:"local_view_angles_2"` } -func (packet *Packet) ParsePacket(reader *bitreader.Reader) { +func (packet *Packet) ParsePacket(reader *bitreader.Reader, demo *types.Demo) { for count := 0; count < MSSC; count++ { - packet.ParseCmdInfo(reader) + packet.ParseCmdInfo(reader, demo) } packet.InSequence = reader.TryReadUInt32() packet.OutSequence = reader.TryReadUInt32() @@ -41,11 +41,11 @@ func (packet *Packet) ParsePacket(reader *bitreader.Reader) { if err != nil { break } - packet.Data = append(packet.Data, messages.ParseMessages(messageType, packetReader)) + packet.Data = append(packet.Data, messages.ParseMessages(messageType, packetReader, demo)) } } -func (packet *Packet) ParseCmdInfo(reader *bitreader.Reader) { +func (packet *Packet) ParseCmdInfo(reader *bitreader.Reader, demo *types.Demo) { packet.PacketInfo = append(packet.PacketInfo, CmdInfo{ Flags: reader.TryReadUInt32(), ViewOrigin: []float32{reader.TryReadFloat32(), reader.TryReadFloat32(), reader.TryReadFloat32()}, @@ -55,14 +55,14 @@ func (packet *Packet) ParseCmdInfo(reader *bitreader.Reader) { ViewAngles2: []float32{reader.TryReadFloat32(), reader.TryReadFloat32(), reader.TryReadFloat32()}, LocalViewAngles2: []float32{reader.TryReadFloat32(), reader.TryReadFloat32(), reader.TryReadFloat32()}, }) - writer.AppendLine("\tFlags: %s", CmdInfoFlags(packet.PacketInfo[len(packet.PacketInfo)-1].Flags).String()) - writer.AppendLine("\tView Origin: %v", packet.PacketInfo[len(packet.PacketInfo)-1].ViewOrigin) - writer.AppendLine("\tView Angles: %v", packet.PacketInfo[len(packet.PacketInfo)-1].ViewAngles) - writer.AppendLine("\tLocal View Angles: %v", packet.PacketInfo[len(packet.PacketInfo)-1].LocalViewAngles) - writer.AppendLine("\tView Origin 2: %v", packet.PacketInfo[len(packet.PacketInfo)-1].ViewOrigin2) - writer.AppendLine("\tView Angles 2: %v", packet.PacketInfo[len(packet.PacketInfo)-1].ViewAngles2) - writer.AppendLine("\tLocal View Angles 2: %v", packet.PacketInfo[len(packet.PacketInfo)-1].LocalViewAngles2) - writer.AppendLine("") + demo.Writer.AppendLine("\tFlags: %s", CmdInfoFlags(packet.PacketInfo[len(packet.PacketInfo)-1].Flags).String()) + demo.Writer.AppendLine("\tView Origin: %v", packet.PacketInfo[len(packet.PacketInfo)-1].ViewOrigin) + demo.Writer.AppendLine("\tView Angles: %v", packet.PacketInfo[len(packet.PacketInfo)-1].ViewAngles) + demo.Writer.AppendLine("\tLocal View Angles: %v", packet.PacketInfo[len(packet.PacketInfo)-1].LocalViewAngles) + demo.Writer.AppendLine("\tView Origin 2: %v", packet.PacketInfo[len(packet.PacketInfo)-1].ViewOrigin2) + demo.Writer.AppendLine("\tView Angles 2: %v", packet.PacketInfo[len(packet.PacketInfo)-1].ViewAngles2) + demo.Writer.AppendLine("\tLocal View Angles 2: %v", packet.PacketInfo[len(packet.PacketInfo)-1].LocalViewAngles2) + demo.Writer.AppendLine("") } type CmdInfoFlags int diff --git a/pkg/classes/sarData.go b/pkg/classes/sarData.go index 4a5bfed..ec2830e 100644 --- a/pkg/classes/sarData.go +++ b/pkg/classes/sarData.go @@ -5,7 +5,7 @@ import ( "fmt" "github.com/pektezol/bitreader" - "github.com/pektezol/sdp.go/pkg/writer" + "github.com/pektezol/sdp.go/pkg/types" ) type SarDataType uint8 @@ -69,89 +69,89 @@ func (sarDataType SarDataType) String() string { } type SarData struct { - Type SarDataType - Slot int - Data any + Type SarDataType `json:"type"` + Slot int `json:"slot"` + Data any `json:"data"` } type SarDataTimescaleCheat struct { - Timescale float32 + Timescale float32 `json:"timescale"` } type SarDataInitialCVar struct { - CVar string - Val string + CVar string `json:"cvar"` + Val string `json:"val"` } type SarDataChecksum struct { - DemoSum uint32 - SarSum uint32 + DemoSum uint32 `json:"demo_sum"` + SarSum uint32 `json:"sar_sum"` } type SarDataChecksumV2 struct { - SarSum uint32 - Signature [64]byte + SarSum uint32 `json:"sar_sum"` + Signature [64]byte `json:"signature"` } type SarDataEntityInput struct { - TargetName string - ClassName string - InputName string - Parameter string + TargetName string `json:"target_name"` + ClassName string `json:"class_name"` + InputName string `json:"input_name"` + Parameter string `json:"parameter"` } type SarDataPortalPlacement struct { - Orange bool - X float32 - Y float32 - Z float32 + Orange bool `json:"orange"` + X float32 `json:"x"` + Y float32 `json:"y"` + Z float32 `json:"z"` } type SarDataPause struct { - PauseTicks uint32 + PauseTicks uint32 `json:"pause_ticks"` } type SarDataWaitRun struct { - Ticks int - Cmd string + Ticks int `json:"ticks"` + Cmd string `json:"cmd"` } type SarDataHWaitRun struct { - Ticks int - Cmd string + Ticks int `json:"ticks"` + Cmd string `json:"cmd"` } type SarDataSpeedrunTime struct { - NSplits uint32 - Splits []SarDataSpeedrunTimeSplits + NSplits uint32 `json:"n_splits"` + Splits []SarDataSpeedrunTimeSplits `json:"splits"` } type SarDataSpeedrunTimeSegs struct { - Name string - Ticks uint32 + Name string `json:"name"` + Ticks uint32 `json:"ticks"` } type SarDataSpeedrunTimeSplits struct { - Name string - NSegs uint32 - Segs []SarDataSpeedrunTimeSegs + Name string `json:"name"` + NSegs uint32 `json:"n_segs"` + Segs []SarDataSpeedrunTimeSegs `json:"segs"` } type SarDataTimestamp struct { - Year uint16 - Month uint8 - Day uint8 - Hour uint8 - Minute uint8 - Second uint8 + Year uint16 `json:"year"` + Month uint8 `json:"month"` + Day uint8 `json:"day"` + Hour uint8 `json:"hour"` + Minute uint8 `json:"minute"` + Second uint8 `json:"second"` } type SarDataFileChecksum struct { - Sum uint32 - Path string + Sum uint32 `json:"sum"` + Path string `json:"path"` } -func (sarData *SarData) ParseSarData(reader *bitreader.Reader) (err error) { +func (sarData *SarData) ParseSarData(reader *bitreader.Reader, demo *types.Demo) (err error) { reader.SkipBytes(8) len := reader.TryReadRemainingBits() / 8 if len == 0 { @@ -164,32 +164,32 @@ func (sarData *SarData) ParseSarData(reader *bitreader.Reader) (err error) { len = 9 } dataReader := bitreader.NewReaderFromBytes(reader.TryReadBytesToSlice(len-1), true) - writer.AppendLine("\tMessage: %s (%d):", sarData.Type.String(), sarData.Type) + demo.Writer.AppendLine("\tMessage: %s (%d):", sarData.Type.String(), sarData.Type) switch sarData.Type { case ESarDataTimescaleCheat: - sarData.Data, err = parseTimescaleCheatData(dataReader, len) + sarData.Data, err = parseTimescaleCheatData(dataReader, len, demo) if err != nil { sarData.Data = nil } case ESarDataInitialCVar: - sarData.Data = parseInitialCVarData(dataReader) + sarData.Data = parseInitialCVarData(dataReader, demo) case ESarDataEntityInputSlot: sarData.Slot = int(dataReader.TryReadBytes(1)) - writer.AppendLine("\t\tSlot: %d", sarData.Slot) + demo.Writer.AppendLine("\t\tSlot: %d", sarData.Slot) case ESarDataEntityInput: - sarData.Data = parseEntityInputData(dataReader) + sarData.Data = parseEntityInputData(dataReader, demo) case ESarDataChecksum: - sarData.Data, err = parseChecksumData(dataReader, len) + sarData.Data, err = parseChecksumData(dataReader, len, demo) if err != nil { sarData.Data = nil } case ESarDataChecksumV2: - sarData.Data, err = parseChecksumV2Data(dataReader, len) + sarData.Data, err = parseChecksumV2Data(dataReader, len, demo) if err != nil { sarData.Data = nil } case ESarDataPortalPlacement: - data, slot, err := parsePortalPlacementData(dataReader, len) + data, slot, err := parsePortalPlacementData(dataReader, len, demo) if err != nil { sarData.Data = nil } else { @@ -201,34 +201,34 @@ func (sarData *SarData) ParseSarData(reader *bitreader.Reader) (err error) { if err != nil { sarData.Data = nil } - writer.AppendLine("\t\tSlot: %d", sarData.Slot) + demo.Writer.AppendLine("\t\tSlot: %d", sarData.Slot) case ESarDataPause: - sarData.Data, err = parsePauseData(dataReader, len) + sarData.Data, err = parsePauseData(dataReader, len, demo) if err != nil { sarData.Data = nil } case ESarDataWaitRun: - sarData.Data, err = parseWaitRunData(dataReader, len) + sarData.Data, err = parseWaitRunData(dataReader, len, demo) if err != nil { sarData.Data = nil } case ESarDataHWaitRun: - sarData.Data, err = parseHWaitRunData(dataReader, len) + sarData.Data, err = parseHWaitRunData(dataReader, len, demo) if err != nil { sarData.Data = nil } case ESarDataSpeedrunTime: - sarData.Data, err = parseSpeedrunTimeData(dataReader, len) + sarData.Data, err = parseSpeedrunTimeData(dataReader, len, demo) if err != nil { sarData.Data = nil } case ESarDataTimestamp: - sarData.Data, err = parseTimestampData(dataReader, len) + sarData.Data, err = parseTimestampData(dataReader, len, demo) if err != nil { sarData.Data = nil } case ESarDataFileChecksum: - sarData.Data, err = parseFileChecksumData(dataReader, len) + sarData.Data, err = parseFileChecksumData(dataReader, len, demo) if err != nil { sarData.Data = nil } @@ -239,41 +239,41 @@ func (sarData *SarData) ParseSarData(reader *bitreader.Reader) (err error) { return nil } -func parseTimescaleCheatData(reader *bitreader.Reader, length uint64) (SarDataTimescaleCheat, error) { +func parseTimescaleCheatData(reader *bitreader.Reader, length uint64, demo *types.Demo) (SarDataTimescaleCheat, error) { if length != 5 { return SarDataTimescaleCheat{}, errors.New("sar data invalid") } sarDataTimescaleCheat := SarDataTimescaleCheat{ Timescale: reader.TryReadFloat32(), } - writer.AppendLine("\t\tTimescale: %f", sarDataTimescaleCheat.Timescale) + demo.Writer.AppendLine("\t\tTimescale: %f", sarDataTimescaleCheat.Timescale) return sarDataTimescaleCheat, nil } -func parseInitialCVarData(reader *bitreader.Reader) SarDataInitialCVar { +func parseInitialCVarData(reader *bitreader.Reader, demo *types.Demo) SarDataInitialCVar { sarDataInitialCvar := SarDataInitialCVar{ CVar: reader.TryReadString(), Val: reader.TryReadString(), } - writer.AppendLine("\t\tCvar: \"%s\" = \"%s\"", sarDataInitialCvar.CVar, sarDataInitialCvar.Val) + demo.Writer.AppendLine("\t\tCvar: \"%s\" = \"%s\"", sarDataInitialCvar.CVar, sarDataInitialCvar.Val) return sarDataInitialCvar } -func parseEntityInputData(reader *bitreader.Reader) SarDataEntityInput { +func parseEntityInputData(reader *bitreader.Reader, demo *types.Demo) SarDataEntityInput { sarDataEntityInput := SarDataEntityInput{ TargetName: reader.TryReadString(), ClassName: reader.TryReadString(), InputName: reader.TryReadString(), Parameter: reader.TryReadString(), } - writer.AppendLine("\t\tTarget: %s", sarDataEntityInput.TargetName) - writer.AppendLine("\t\tClass: %s", sarDataEntityInput.ClassName) - writer.AppendLine("\t\tInput: %s", sarDataEntityInput.InputName) - writer.AppendLine("\t\tParameter: %s", sarDataEntityInput.Parameter) + demo.Writer.AppendLine("\t\tTarget: %s", sarDataEntityInput.TargetName) + demo.Writer.AppendLine("\t\tClass: %s", sarDataEntityInput.ClassName) + demo.Writer.AppendLine("\t\tInput: %s", sarDataEntityInput.InputName) + demo.Writer.AppendLine("\t\tParameter: %s", sarDataEntityInput.Parameter) return sarDataEntityInput } -func parseChecksumData(reader *bitreader.Reader, length uint64) (SarDataChecksum, error) { +func parseChecksumData(reader *bitreader.Reader, length uint64, demo *types.Demo) (SarDataChecksum, error) { if length != 9 { return SarDataChecksum{}, errors.New("sar data invalid") } @@ -281,12 +281,12 @@ func parseChecksumData(reader *bitreader.Reader, length uint64) (SarDataChecksum DemoSum: reader.TryReadUInt32(), SarSum: reader.TryReadUInt32(), } - writer.AppendLine("\t\tDemo Checksum: %d", sarDataChecksum.DemoSum) - writer.AppendLine("\t\tSAR Checksum: %d", sarDataChecksum.SarSum) + demo.Writer.AppendLine("\t\tDemo Checksum: %d", sarDataChecksum.DemoSum) + demo.Writer.AppendLine("\t\tSAR Checksum: %d", sarDataChecksum.SarSum) return sarDataChecksum, nil } -func parseChecksumV2Data(reader *bitreader.Reader, length uint64) (SarDataChecksumV2, error) { +func parseChecksumV2Data(reader *bitreader.Reader, length uint64, demo *types.Demo) (SarDataChecksumV2, error) { if length != 69 { return SarDataChecksumV2{}, errors.New("sar data invalid") } @@ -294,12 +294,12 @@ func parseChecksumV2Data(reader *bitreader.Reader, length uint64) (SarDataChecks SarSum: reader.TryReadUInt32(), Signature: [64]byte(reader.TryReadBytesToSlice(60)), } - writer.AppendLine("\t\tSAR Checksum: %d", sarDataChecksumV2.SarSum) - writer.AppendLine("\t\tSignature: %v", sarDataChecksumV2.Signature) + demo.Writer.AppendLine("\t\tSAR Checksum: %d", sarDataChecksumV2.SarSum) + demo.Writer.AppendLine("\t\tSignature: %v", sarDataChecksumV2.Signature) return sarDataChecksumV2, nil } -func parsePortalPlacementData(reader *bitreader.Reader, length uint64) (SarDataPortalPlacement, int, error) { +func parsePortalPlacementData(reader *bitreader.Reader, length uint64, demo *types.Demo) (SarDataPortalPlacement, int, error) { if length != 15 { return SarDataPortalPlacement{}, 0, errors.New("sar data invalid") } @@ -312,10 +312,10 @@ func parsePortalPlacementData(reader *bitreader.Reader, length uint64) (SarDataP Y: reader.TryReadFloat32(), Z: reader.TryReadFloat32(), } - writer.AppendLine("\t\tOrange: %t", orange) - writer.AppendLine("\t\tX: %f", sarDataPortalPlacement.X) - writer.AppendLine("\t\tY: %f", sarDataPortalPlacement.Y) - writer.AppendLine("\t\tZ: %f", sarDataPortalPlacement.Z) + demo.Writer.AppendLine("\t\tOrange: %t", orange) + demo.Writer.AppendLine("\t\tX: %f", sarDataPortalPlacement.X) + demo.Writer.AppendLine("\t\tY: %f", sarDataPortalPlacement.Y) + demo.Writer.AppendLine("\t\tZ: %f", sarDataPortalPlacement.Z) return sarDataPortalPlacement, slot, nil } @@ -326,18 +326,18 @@ func parseChallengeFlagsCrouchFlyData(reader *bitreader.Reader, length uint64) ( return int(reader.TryReadBytes(1)), nil } -func parsePauseData(reader *bitreader.Reader, length uint64) (SarDataPause, error) { +func parsePauseData(reader *bitreader.Reader, length uint64, demo *types.Demo) (SarDataPause, error) { if length != 5 { return SarDataPause{}, errors.New("sar data invalid") } sarDataPause := SarDataPause{ PauseTicks: reader.TryReadUInt32(), } - writer.AppendLine("\t\tPause Ticks: %d", sarDataPause.PauseTicks) + demo.Writer.AppendLine("\t\tPause Ticks: %d", sarDataPause.PauseTicks) return sarDataPause, nil } -func parseWaitRunData(reader *bitreader.Reader, length uint64) (SarDataWaitRun, error) { +func parseWaitRunData(reader *bitreader.Reader, length uint64, demo *types.Demo) (SarDataWaitRun, error) { if length < 6 { return SarDataWaitRun{}, errors.New("sar data invalid") } @@ -345,12 +345,12 @@ func parseWaitRunData(reader *bitreader.Reader, length uint64) (SarDataWaitRun, Ticks: int(reader.TryReadUInt32()), Cmd: reader.TryReadString(), } - writer.AppendLine("\t\tTicks: %d", sarDataWaitRun.Ticks) - writer.AppendLine("\t\tCmd: \"%s\"", sarDataWaitRun.Cmd) + demo.Writer.AppendLine("\t\tTicks: %d", sarDataWaitRun.Ticks) + demo.Writer.AppendLine("\t\tCmd: \"%s\"", sarDataWaitRun.Cmd) return sarDataWaitRun, nil } -func parseHWaitRunData(reader *bitreader.Reader, length uint64) (SarDataHWaitRun, error) { +func parseHWaitRunData(reader *bitreader.Reader, length uint64, demo *types.Demo) (SarDataHWaitRun, error) { if length < 6 { return SarDataHWaitRun{}, errors.New("sar data invalid") } @@ -358,12 +358,12 @@ func parseHWaitRunData(reader *bitreader.Reader, length uint64) (SarDataHWaitRun Ticks: int(reader.TryReadUInt32()), Cmd: reader.TryReadString(), } - writer.AppendLine("\t\tTicks: %d", sarDataHWaitRun.Ticks) - writer.AppendLine("\t\tCmd: \"%s\"", sarDataHWaitRun.Cmd) + demo.Writer.AppendLine("\t\tTicks: %d", sarDataHWaitRun.Ticks) + demo.Writer.AppendLine("\t\tCmd: \"%s\"", sarDataHWaitRun.Cmd) return sarDataHWaitRun, nil } -func parseSpeedrunTimeData(reader *bitreader.Reader, length uint64) (SarDataSpeedrunTime, error) { +func parseSpeedrunTimeData(reader *bitreader.Reader, length uint64, demo *types.Demo) (SarDataSpeedrunTime, error) { if length < 5 { return SarDataSpeedrunTime{}, errors.New("sar data invalid") } @@ -372,14 +372,14 @@ func parseSpeedrunTimeData(reader *bitreader.Reader, length uint64) (SarDataSpee for splitCount := 0; splitCount < int(numberOfSplits); splitCount++ { splits[splitCount].Name = reader.TryReadString() splits[splitCount].NSegs = reader.TryReadUInt32() - writer.AppendLine("\t\t[%d] Split Name: \"%s\"", splitCount, splits[splitCount].Name) - writer.AppendLine("\t\t[%d] Number of Segments: %d", splitCount, splits[splitCount].NSegs) + demo.Writer.AppendLine("\t\t[%d] Split Name: \"%s\"", splitCount, splits[splitCount].Name) + demo.Writer.AppendLine("\t\t[%d] Number of Segments: %d", splitCount, splits[splitCount].NSegs) splits[splitCount].Segs = make([]SarDataSpeedrunTimeSegs, splits[splitCount].NSegs) for segCount := 0; segCount < int(splits[splitCount].NSegs); segCount++ { splits[splitCount].Segs[segCount].Name = reader.TryReadString() splits[splitCount].Segs[segCount].Ticks = reader.TryReadUInt32() - writer.AppendLine("\t\t\t[%d] Segment Name: \"%s\"", segCount, splits[splitCount].Segs[segCount].Name) - writer.AppendLine("\t\t\t[%d] Segment Ticks: %d", segCount, splits[splitCount].Segs[segCount].Ticks) + demo.Writer.AppendLine("\t\t\t[%d] Segment Name: \"%s\"", segCount, splits[splitCount].Segs[segCount].Name) + demo.Writer.AppendLine("\t\t\t[%d] Segment Ticks: %d", segCount, splits[splitCount].Segs[segCount].Ticks) } } return SarDataSpeedrunTime{ @@ -388,7 +388,7 @@ func parseSpeedrunTimeData(reader *bitreader.Reader, length uint64) (SarDataSpee }, nil } -func parseTimestampData(reader *bitreader.Reader, length uint64) (SarDataTimestamp, error) { +func parseTimestampData(reader *bitreader.Reader, length uint64, demo *types.Demo) (SarDataTimestamp, error) { if length != 8 { return SarDataTimestamp{}, errors.New("sar data invalid") } @@ -401,16 +401,16 @@ func parseTimestampData(reader *bitreader.Reader, length uint64) (SarDataTimesta Minute: timestamp[5], Second: timestamp[6], } - writer.AppendLine("\t\tYear: %d", sarDataTimeStamp.Year) - writer.AppendLine("\t\tMonth: %d", sarDataTimeStamp.Month) - writer.AppendLine("\t\tDay: %d", sarDataTimeStamp.Day) - writer.AppendLine("\t\tHour: %d", sarDataTimeStamp.Hour) - writer.AppendLine("\t\tMinute: %d", sarDataTimeStamp.Minute) - writer.AppendLine("\t\tSecond: %d", sarDataTimeStamp.Second) + demo.Writer.AppendLine("\t\tYear: %d", sarDataTimeStamp.Year) + demo.Writer.AppendLine("\t\tMonth: %d", sarDataTimeStamp.Month) + demo.Writer.AppendLine("\t\tDay: %d", sarDataTimeStamp.Day) + demo.Writer.AppendLine("\t\tHour: %d", sarDataTimeStamp.Hour) + demo.Writer.AppendLine("\t\tMinute: %d", sarDataTimeStamp.Minute) + demo.Writer.AppendLine("\t\tSecond: %d", sarDataTimeStamp.Second) return sarDataTimeStamp, nil } -func parseFileChecksumData(reader *bitreader.Reader, length uint64) (SarDataFileChecksum, error) { +func parseFileChecksumData(reader *bitreader.Reader, length uint64, demo *types.Demo) (SarDataFileChecksum, error) { if length < 6 { return SarDataFileChecksum{}, errors.New("sar data invalid") } @@ -418,7 +418,7 @@ func parseFileChecksumData(reader *bitreader.Reader, length uint64) (SarDataFile Sum: reader.TryReadUInt32(), Path: reader.TryReadString(), } - writer.AppendLine("\t\tChecksum: %d", sarDataFileChecksum.Sum) - writer.AppendLine("\t\tPath: \"%s\"", sarDataFileChecksum.Path) + demo.Writer.AppendLine("\t\tChecksum: %d", sarDataFileChecksum.Sum) + demo.Writer.AppendLine("\t\tPath: \"%s\"", sarDataFileChecksum.Path) return sarDataFileChecksum, nil } diff --git a/pkg/classes/signOn.go b/pkg/classes/signOn.go index 0d5ca55..e6d2f4e 100644 --- a/pkg/classes/signOn.go +++ b/pkg/classes/signOn.go @@ -3,20 +3,20 @@ package classes import ( "github.com/pektezol/bitreader" "github.com/pektezol/sdp.go/pkg/messages" - "github.com/pektezol/sdp.go/pkg/writer" + "github.com/pektezol/sdp.go/pkg/types" ) type SignOn struct { - PacketInfo []CmdInfo - InSequence uint32 - OutSequence uint32 - Size uint32 - Data []any + PacketInfo []CmdInfo `json:"packet_info"` + InSequence uint32 `json:"in_sequence"` + OutSequence uint32 `json:"out_sequence"` + Size uint32 `json:"size"` + Data []any `json:"data"` } -func (signOn *SignOn) ParseSignOn(reader *bitreader.Reader) { +func (signOn *SignOn) ParseSignOn(reader *bitreader.Reader, demo *types.Demo) { for count := 0; count < MSSC; count++ { - signOn.ParseCmdInfo(reader) + signOn.ParseCmdInfo(reader, demo) } signOn.InSequence = reader.TryReadUInt32() signOn.OutSequence = reader.TryReadUInt32() @@ -27,11 +27,11 @@ func (signOn *SignOn) ParseSignOn(reader *bitreader.Reader) { if err != nil { break } - signOn.Data = append(signOn.Data, messages.ParseMessages(messageType, packetReader)) + signOn.Data = append(signOn.Data, messages.ParseMessages(messageType, packetReader, demo)) } } -func (signOn *SignOn) ParseCmdInfo(reader *bitreader.Reader) { +func (signOn *SignOn) ParseCmdInfo(reader *bitreader.Reader, demo *types.Demo) { signOn.PacketInfo = append(signOn.PacketInfo, CmdInfo{ Flags: reader.TryReadUInt32(), ViewOrigin: []float32{reader.TryReadFloat32(), reader.TryReadFloat32(), reader.TryReadFloat32()}, @@ -41,12 +41,12 @@ func (signOn *SignOn) ParseCmdInfo(reader *bitreader.Reader) { ViewAngles2: []float32{reader.TryReadFloat32(), reader.TryReadFloat32(), reader.TryReadFloat32()}, LocalViewAngles2: []float32{reader.TryReadFloat32(), reader.TryReadFloat32(), reader.TryReadFloat32()}, }) - writer.AppendLine("\tFlags: %s", CmdInfoFlags(signOn.PacketInfo[len(signOn.PacketInfo)-1].Flags).String()) - writer.AppendLine("\tView Origin: %v", signOn.PacketInfo[len(signOn.PacketInfo)-1].ViewOrigin) - writer.AppendLine("\tView Angles: %v", signOn.PacketInfo[len(signOn.PacketInfo)-1].ViewAngles) - writer.AppendLine("\tLocal View Angles: %v", signOn.PacketInfo[len(signOn.PacketInfo)-1].LocalViewAngles) - writer.AppendLine("\tView Origin 2: %v", signOn.PacketInfo[len(signOn.PacketInfo)-1].ViewOrigin2) - writer.AppendLine("\tView Angles 2: %v", signOn.PacketInfo[len(signOn.PacketInfo)-1].ViewAngles2) - writer.AppendLine("\tLocal View Angles 2: %v", signOn.PacketInfo[len(signOn.PacketInfo)-1].LocalViewAngles2) - writer.AppendLine("") + demo.Writer.AppendLine("\tFlags: %s", CmdInfoFlags(signOn.PacketInfo[len(signOn.PacketInfo)-1].Flags).String()) + demo.Writer.AppendLine("\tView Origin: %v", signOn.PacketInfo[len(signOn.PacketInfo)-1].ViewOrigin) + demo.Writer.AppendLine("\tView Angles: %v", signOn.PacketInfo[len(signOn.PacketInfo)-1].ViewAngles) + demo.Writer.AppendLine("\tLocal View Angles: %v", signOn.PacketInfo[len(signOn.PacketInfo)-1].LocalViewAngles) + demo.Writer.AppendLine("\tView Origin 2: %v", signOn.PacketInfo[len(signOn.PacketInfo)-1].ViewOrigin2) + demo.Writer.AppendLine("\tView Angles 2: %v", signOn.PacketInfo[len(signOn.PacketInfo)-1].ViewAngles2) + demo.Writer.AppendLine("\tLocal View Angles 2: %v", signOn.PacketInfo[len(signOn.PacketInfo)-1].LocalViewAngles2) + demo.Writer.AppendLine("") } diff --git a/pkg/classes/stop.go b/pkg/classes/stop.go index 97db6cf..c6b52a9 100644 --- a/pkg/classes/stop.go +++ b/pkg/classes/stop.go @@ -2,16 +2,16 @@ package classes import ( "github.com/pektezol/bitreader" - "github.com/pektezol/sdp.go/pkg/writer" + "github.com/pektezol/sdp.go/pkg/types" ) type Stop struct { - RemainingData []byte + RemainingData []byte `json:"remaining_data"` } -func (stop *Stop) ParseStop(reader *bitreader.Reader) { +func (stop *Stop) ParseStop(reader *bitreader.Reader, demo *types.Demo) { if reader.TryReadBool() { stop.RemainingData = reader.TryReadBitsToSlice(uint64(reader.TryReadRemainingBits())) - writer.AppendLine("\tRemaining Data: %v", stop.RemainingData) + demo.Writer.AppendLine("\tRemaining Data: %v", stop.RemainingData) } } diff --git a/pkg/classes/stringTables.go b/pkg/classes/stringTables.go index 7848b1c..6e1510c 100644 --- a/pkg/classes/stringTables.go +++ b/pkg/classes/stringTables.go @@ -5,58 +5,58 @@ import ( "strings" "github.com/pektezol/bitreader" - "github.com/pektezol/sdp.go/pkg/writer" + "github.com/pektezol/sdp.go/pkg/types" ) type StringTables struct { - Size int32 - Data []StringTable + Size int32 `json:"size"` + Data []StringTable `json:"data"` } type StringTable struct { - Name string - TableEntries []StringTableEntry - Classes []StringTableClass + Name string `json:"name"` + TableEntries []StringTableEntry `json:"table_entries"` + Classes []StringTableClass `json:"classes"` } type StringTableClass struct { - Name string - Data string + Name string `json:"name"` + Data string `json:"data"` } type StringTableEntry struct { - Name string - EntryData any + Name string `json:"name"` + EntryData any `json:"entry_data"` } -func (stringTables *StringTables) ParseStringTables(reader *bitreader.Reader) { +func (stringTables *StringTables) ParseStringTables(reader *bitreader.Reader, demo *types.Demo) { stringTables.Size = reader.TryReadSInt32() stringTableReader := bitreader.NewReaderFromBytes(reader.TryReadBytesToSlice(uint64(stringTables.Size)), true) tableCount := stringTableReader.TryReadBits(8) tables := make([]StringTable, tableCount) for i := 0; i < int(tableCount); i++ { var table StringTable - table.ParseStream(stringTableReader) + table.ParseStream(stringTableReader, demo) tables[i] = table } stringTables.Data = tables } -func (stringTable *StringTable) ParseStream(reader *bitreader.Reader) { +func (stringTable *StringTable) ParseStream(reader *bitreader.Reader, demo *types.Demo) { stringTable.Name = reader.TryReadString() entryCount := reader.TryReadBits(16) - writer.AppendLine("\tTable Name: %s", stringTable.Name) + demo.Writer.AppendLine("\tTable Name: %s", stringTable.Name) stringTable.TableEntries = make([]StringTableEntry, entryCount) for i := 0; i < int(entryCount); i++ { var entry StringTableEntry - entry.Parse(stringTable.Name, reader) + entry.Parse(stringTable.Name, reader, demo) stringTable.TableEntries[i] = entry } if entryCount != 0 { - writer.AppendLine("\t\t%d Table Entries:", entryCount) - writer.AppendOutputFromTemp() + demo.Writer.AppendLine("\t\t%d Table Entries:", entryCount) + demo.Writer.AppendOutputFromTemp() } else { - writer.AppendLine("\t\tNo Table Entries") + demo.Writer.AppendLine("\t\tNo Table Entries") } if reader.TryReadBool() { classCount := reader.TryReadBits(16) @@ -64,28 +64,28 @@ func (stringTable *StringTable) ParseStream(reader *bitreader.Reader) { for i := 0; i < int(classCount); i++ { var class StringTableClass - class.Parse(reader) + class.Parse(reader, demo) stringTable.Classes[i] = class } - writer.AppendLine("\t\t%d Classes:", classCount) - writer.AppendOutputFromTemp() + demo.Writer.AppendLine("\t\t%d Classes:", classCount) + demo.Writer.AppendOutputFromTemp() } else { - writer.AppendLine("\t\tNo Class Entries") + demo.Writer.AppendLine("\t\tNo Class Entries") } } -func (stringTableClass *StringTableClass) Parse(reader *bitreader.Reader) { +func (stringTableClass *StringTableClass) Parse(reader *bitreader.Reader, demo *types.Demo) { stringTableClass.Name = reader.TryReadString() - writer.TempAppendLine("\t\t\tName: %s", stringTableClass.Name) + demo.Writer.TempAppendLine("\t\t\tName: %s", stringTableClass.Name) if reader.TryReadBool() { stringTableClass.Data = reader.TryReadStringLength(uint64(reader.TryReadUInt16())) - writer.TempAppendLine("\t\t\tData: %s", stringTableClass.Data) + demo.Writer.TempAppendLine("\t\t\tData: %s", stringTableClass.Data) } } -func (stringTableEntry *StringTableEntry) Parse(tableName string, reader *bitreader.Reader) { +func (stringTableEntry *StringTableEntry) Parse(tableName string, reader *bitreader.Reader, demo *types.Demo) { stringTableEntry.Name = reader.TryReadString() - writer.TempAppendLine("\t\t\tName: %s", stringTableEntry.Name) + demo.Writer.TempAppendLine("\t\t\tName: %s", stringTableEntry.Name) if reader.TryReadBool() { byteLen, err := reader.ReadBits(16) if err != nil { @@ -94,30 +94,30 @@ func (stringTableEntry *StringTableEntry) Parse(tableName string, reader *bitrea stringTableEntryReader := bitreader.NewReaderFromBytes(reader.TryReadBytesToSlice(byteLen), true) switch tableName { case StringTableUserInfo: - stringTableEntry.ParseUserInfo(stringTableEntryReader) + stringTableEntry.ParseUserInfo(stringTableEntryReader, demo) case StringTableServerQueryInfo: - stringTableEntry.ParseServerQueryInfo(stringTableEntryReader) + stringTableEntry.ParseServerQueryInfo(stringTableEntryReader, demo) case StringTableGameRulesCreation: - stringTableEntry.ParseGamesRulesCreation(stringTableEntryReader) + stringTableEntry.ParseGamesRulesCreation(stringTableEntryReader, demo) case StringTableInfoPanel: - stringTableEntry.ParseInfoPanel(stringTableEntryReader) + stringTableEntry.ParseInfoPanel(stringTableEntryReader, demo) case StringTableLightStyles: - stringTableEntry.ParseLightStyles(stringTableEntryReader) + stringTableEntry.ParseLightStyles(stringTableEntryReader, demo) case StringTableModelPreCache: - stringTableEntry.ParsePrecacheData(stringTableEntryReader) + stringTableEntry.ParsePrecacheData(stringTableEntryReader, demo) case StringTableGenericPreCache: - stringTableEntry.ParsePrecacheData(stringTableEntryReader) + stringTableEntry.ParsePrecacheData(stringTableEntryReader, demo) case StringTableSoundPreCache: - stringTableEntry.ParsePrecacheData(stringTableEntryReader) + stringTableEntry.ParsePrecacheData(stringTableEntryReader, demo) case StringTableDecalPreCache: - stringTableEntry.ParsePrecacheData(stringTableEntryReader) + stringTableEntry.ParsePrecacheData(stringTableEntryReader, demo) default: - stringTableEntry.ParseUnknown(stringTableEntryReader) + stringTableEntry.ParseUnknown(stringTableEntryReader, demo) } } } -func (stringTableEntry *StringTableEntry) ParseUserInfo(reader *bitreader.Reader) { +func (stringTableEntry *StringTableEntry) ParseUserInfo(reader *bitreader.Reader, demo *types.Demo) { const SignedGuidLen int32 = 32 const MaxPlayerNameLength int32 = 32 userInfo := struct { @@ -147,48 +147,48 @@ func (stringTableEntry *StringTableEntry) ParseUserInfo(reader *bitreader.Reader userInfo.FilesDownloaded = reader.TryReadUInt8() reader.SkipBytes(3) stringTableEntry.EntryData = userInfo - writer.TempAppendLine("\t\t\t\tSteam Account ID: %d", uint32((userInfo.SteamID&0xFFFFFFFF00000000)|userInfo.SteamID)) - writer.TempAppendLine("\t\t\t\tSteam Account Instance: %d", uint32(userInfo.SteamID>>32)&0x000FFFFF) - writer.TempAppendLine("\t\t\t\tSteam Account Type: %d", uint32(userInfo.SteamID>>52)&0xF) - writer.TempAppendLine("\t\t\t\tSteam Account Universe: %d", uint32(userInfo.SteamID>>56)&0xFF) - writer.TempAppendLine("\t\t\t\tName: %s", userInfo.Name) - writer.TempAppendLine("\t\t\t\tUser ID: %d", userInfo.UserID) - writer.TempAppendLine("\t\t\t\tGUID: %s", userInfo.GUID) - writer.TempAppendLine("\t\t\t\tFriends ID: %d", userInfo.FriendsID) - writer.TempAppendLine("\t\t\t\tFriends Name: %s", userInfo.FriendsName) - writer.TempAppendLine("\t\t\t\tFake Player: %t", userInfo.FakePlayer) - writer.TempAppendLine("\t\t\t\tIs Htlv: %t", userInfo.IsHltv) + demo.Writer.TempAppendLine("\t\t\t\tSteam Account ID: %d", uint32((userInfo.SteamID&0xFFFFFFFF00000000)|userInfo.SteamID)) + demo.Writer.TempAppendLine("\t\t\t\tSteam Account Instance: %d", uint32(userInfo.SteamID>>32)&0x000FFFFF) + demo.Writer.TempAppendLine("\t\t\t\tSteam Account Type: %d", uint32(userInfo.SteamID>>52)&0xF) + demo.Writer.TempAppendLine("\t\t\t\tSteam Account Universe: %d", uint32(userInfo.SteamID>>56)&0xFF) + demo.Writer.TempAppendLine("\t\t\t\tName: %s", userInfo.Name) + demo.Writer.TempAppendLine("\t\t\t\tUser ID: %d", userInfo.UserID) + demo.Writer.TempAppendLine("\t\t\t\tGUID: %s", userInfo.GUID) + demo.Writer.TempAppendLine("\t\t\t\tFriends ID: %d", userInfo.FriendsID) + demo.Writer.TempAppendLine("\t\t\t\tFriends Name: %s", userInfo.FriendsName) + demo.Writer.TempAppendLine("\t\t\t\tFake Player: %t", userInfo.FakePlayer) + demo.Writer.TempAppendLine("\t\t\t\tIs Htlv: %t", userInfo.IsHltv) if userInfo.CustomFiles != nil { - writer.TempAppendLine("\t\t\t\tCustom File CRCs: [logo: 0x%d, sounds: 0x%d, models: 0x%d, txt: 0x%d]", userInfo.CustomFiles[0], userInfo.CustomFiles[1], userInfo.CustomFiles[2], userInfo.CustomFiles[3]) + demo.Writer.TempAppendLine("\t\t\t\tCustom File CRCs: [logo: 0x%d, sounds: 0x%d, models: 0x%d, txt: 0x%d]", userInfo.CustomFiles[0], userInfo.CustomFiles[1], userInfo.CustomFiles[2], userInfo.CustomFiles[3]) } - writer.TempAppendLine("\t\t\t\tFiles Downloaded: %d", userInfo.FilesDownloaded) + demo.Writer.TempAppendLine("\t\t\t\tFiles Downloaded: %d", userInfo.FilesDownloaded) } -func (stringTableEntry *StringTableEntry) ParseServerQueryInfo(reader *bitreader.Reader) { +func (stringTableEntry *StringTableEntry) ParseServerQueryInfo(reader *bitreader.Reader, demo *types.Demo) { serverQueryInfo := struct{ Port uint32 }{ Port: reader.TryReadUInt32(), } stringTableEntry.EntryData = serverQueryInfo - writer.TempAppendLine("\t\t\t\tPort: %d", serverQueryInfo.Port) + demo.Writer.TempAppendLine("\t\t\t\tPort: %d", serverQueryInfo.Port) } -func (stringTableEntry *StringTableEntry) ParseGamesRulesCreation(reader *bitreader.Reader) { +func (stringTableEntry *StringTableEntry) ParseGamesRulesCreation(reader *bitreader.Reader, demo *types.Demo) { gamesRulesCreation := struct{ Message string }{ Message: reader.TryReadString(), } stringTableEntry.EntryData = gamesRulesCreation - writer.TempAppendLine("\t\t\t\tMessage: %s", gamesRulesCreation.Message) + demo.Writer.TempAppendLine("\t\t\t\tMessage: %s", gamesRulesCreation.Message) } -func (stringTableEntry *StringTableEntry) ParseInfoPanel(reader *bitreader.Reader) { +func (stringTableEntry *StringTableEntry) ParseInfoPanel(reader *bitreader.Reader, demo *types.Demo) { infoPanel := struct{ Message string }{ Message: reader.TryReadString(), } stringTableEntry.EntryData = infoPanel - writer.TempAppendLine("\t\t\t\tMessage: %s", infoPanel.Message) + demo.Writer.TempAppendLine("\t\t\t\tMessage: %s", infoPanel.Message) } -func (stringTableEntry *StringTableEntry) ParseLightStyles(reader *bitreader.Reader) { +func (stringTableEntry *StringTableEntry) ParseLightStyles(reader *bitreader.Reader, demo *types.Demo) { lightStyles := struct{ Values []byte }{} str := reader.TryReadString() if len(str) != 0 { @@ -199,13 +199,13 @@ func (stringTableEntry *StringTableEntry) ParseLightStyles(reader *bitreader.Rea } stringTableEntry.EntryData = lightStyles if lightStyles.Values == nil { - writer.TempAppendLine("\t\t\t\t0 Frames (256)") + demo.Writer.TempAppendLine("\t\t\t\t0 Frames (256)") } else { - writer.TempAppendLine("\t\t\t\t%d frames: %v", len(lightStyles.Values), lightStyles.Values) + demo.Writer.TempAppendLine("\t\t\t\t%d frames: %v", len(lightStyles.Values), lightStyles.Values) } } -func (stringTableEntry *StringTableEntry) ParsePrecacheData(reader *bitreader.Reader) { +func (stringTableEntry *StringTableEntry) ParsePrecacheData(reader *bitreader.Reader, demo *types.Demo) { type PrecacheFlag uint16 const ( None PrecacheFlag = 0 @@ -225,16 +225,16 @@ func (stringTableEntry *StringTableEntry) ParsePrecacheData(reader *bitreader.Re } return flagStrings } - writer.TempAppendLine("\t\t\t\tFlags: %v", getFlags(PrecacheFlag(precacheData.Flags))) + demo.Writer.TempAppendLine("\t\t\t\tFlags: %v", getFlags(PrecacheFlag(precacheData.Flags))) } -func (stringTableEntry *StringTableEntry) ParseUnknown(reader *bitreader.Reader) { +func (stringTableEntry *StringTableEntry) ParseUnknown(reader *bitreader.Reader, demo *types.Demo) { unknown := reader.TryReadBitsToSlice(reader.TryReadRemainingBits()) binaryString := "" for _, byteValue := range unknown { binaryString += fmt.Sprintf("%08b ", byteValue) } - writer.TempAppendLine("\t\t\t\tUnknown: (%s)", strings.TrimSpace(binaryString)) + demo.Writer.TempAppendLine("\t\t\t\tUnknown: (%s)", strings.TrimSpace(binaryString)) } const ( diff --git a/pkg/classes/userCmd.go b/pkg/classes/userCmd.go index dc0b56d..14ef4e0 100644 --- a/pkg/classes/userCmd.go +++ b/pkg/classes/userCmd.go @@ -2,40 +2,40 @@ package classes import ( "github.com/pektezol/bitreader" - "github.com/pektezol/sdp.go/pkg/writer" + "github.com/pektezol/sdp.go/pkg/types" ) type UserCmd struct { - Cmd uint32 - Size uint32 - Data UserCmdInfo + Cmd uint32 `json:"cmd"` + Size uint32 `json:"size"` + Data UserCmdInfo `json:"data"` } type UserCmdInfo struct { - CommandNumber uint32 - TickCount uint32 - ViewAnglesX float32 - ViewAnglesY float32 - ViewAnglesZ float32 - ForwardMove float32 - SideMove float32 - UpMove float32 - Buttons uint32 - Impulse uint8 - WeaponSelect uint16 - WeaponSubType uint8 - MouseDx uint16 - MouseDy uint16 + CommandNumber uint32 `json:"command_number"` + TickCount uint32 `json:"tick_count"` + ViewAnglesX float32 `json:"view_angles_x"` + ViewAnglesY float32 `json:"view_angles_y"` + ViewAnglesZ float32 `json:"view_angles_z"` + ForwardMove float32 `json:"forward_move"` + SideMove float32 `json:"side_move"` + UpMove float32 `json:"up_move"` + Buttons uint32 `json:"buttons"` + Impulse uint8 `json:"impulse"` + WeaponSelect uint16 `json:"weapon_select"` + WeaponSubType uint8 `json:"weapon_sub_type"` + MouseDx uint16 `json:"mouse_dx"` + MouseDy uint16 `json:"mouse_dy"` } -func (userCmd *UserCmd) ParseUserCmd(reader *bitreader.Reader) { +func (userCmd *UserCmd) ParseUserCmd(reader *bitreader.Reader, demo *types.Demo) { userCmd.Cmd = reader.TryReadUInt32() userCmd.Size = reader.TryReadUInt32() userCmdReader := bitreader.NewReaderFromBytes(reader.TryReadBytesToSlice(uint64(userCmd.Size)), true) - userCmd.ParseUserCmdInfo(userCmdReader) + userCmd.ParseUserCmdInfo(userCmdReader, demo) } -func (userCmd *UserCmd) ParseUserCmdInfo(reader *bitreader.Reader) { +func (userCmd *UserCmd) ParseUserCmdInfo(reader *bitreader.Reader, demo *types.Demo) { if reader.TryReadBool() { userCmd.Data.CommandNumber = reader.TryReadUInt32() } @@ -78,14 +78,14 @@ func (userCmd *UserCmd) ParseUserCmdInfo(reader *bitreader.Reader) { if reader.TryReadBool() { userCmd.Data.MouseDy = reader.TryReadUInt16() } - writer.AppendLine("\tCommand Number: %v", userCmd.Data.CommandNumber) - writer.AppendLine("\tTick Count: %v", userCmd.Data.TickCount) - writer.AppendLine("\tView Angles: %v", []float32{userCmd.Data.ViewAnglesX, userCmd.Data.ViewAnglesY, userCmd.Data.ViewAnglesZ}) - writer.AppendLine("\tMovement: %v", []float32{userCmd.Data.ForwardMove, userCmd.Data.SideMove, userCmd.Data.UpMove}) - writer.AppendLine("\tButtons: %v", Buttons(userCmd.Data.Buttons).GetButtons()) - writer.AppendLine("\tImpulse: %v", userCmd.Data.Impulse) - writer.AppendLine("\tWeapon, Subtype: %v, %v", userCmd.Data.WeaponSelect, userCmd.Data.WeaponSubType) - writer.AppendLine("\tMouse Dx, Mouse Dy: %v, %v", userCmd.Data.MouseDx, userCmd.Data.MouseDy) + demo.Writer.AppendLine("\tCommand Number: %v", userCmd.Data.CommandNumber) + demo.Writer.AppendLine("\tTick Count: %v", userCmd.Data.TickCount) + demo.Writer.AppendLine("\tView Angles: %v", []float32{userCmd.Data.ViewAnglesX, userCmd.Data.ViewAnglesY, userCmd.Data.ViewAnglesZ}) + demo.Writer.AppendLine("\tMovement: %v", []float32{userCmd.Data.ForwardMove, userCmd.Data.SideMove, userCmd.Data.UpMove}) + demo.Writer.AppendLine("\tButtons: %v", Buttons(userCmd.Data.Buttons).GetButtons()) + demo.Writer.AppendLine("\tImpulse: %v", userCmd.Data.Impulse) + demo.Writer.AppendLine("\tWeapon, Subtype: %v, %v", userCmd.Data.WeaponSelect, userCmd.Data.WeaponSubType) + demo.Writer.AppendLine("\tMouse Dx, Mouse Dy: %v, %v", userCmd.Data.MouseDx, userCmd.Data.MouseDy) } func (button Buttons) GetButtons() []string { -- cgit v1.2.3