aboutsummaryrefslogtreecommitdiff
path: root/pkg/classes
diff options
context:
space:
mode:
Diffstat (limited to 'pkg/classes')
-rw-r--r--pkg/classes/consoleCmd.go10
-rw-r--r--pkg/classes/customData.go19
-rw-r--r--pkg/classes/dataTables.go74
-rw-r--r--pkg/classes/packet.go50
-rw-r--r--pkg/classes/sarData.go196
-rw-r--r--pkg/classes/signOn.go36
-rw-r--r--pkg/classes/stop.go8
-rw-r--r--pkg/classes/stringTables.go128
-rw-r--r--pkg/classes/userCmd.go58
9 files changed, 290 insertions, 289 deletions
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 (
4 "strings" 4 "strings"
5 5
6 "github.com/pektezol/bitreader" 6 "github.com/pektezol/bitreader"
7 "github.com/pektezol/sdp.go/pkg/writer" 7 "github.com/pektezol/sdp.go/pkg/types"
8) 8)
9 9
10type ConsoleCmd struct { 10type ConsoleCmd struct {
11 Size int32 11 Size int32 `json:"size"`
12 Data string 12 Data string `json:"data"`
13} 13}
14 14
15func (consoleCmd *ConsoleCmd) ParseConsoleCmd(reader *bitreader.Reader) { 15func (consoleCmd *ConsoleCmd) ParseConsoleCmd(reader *bitreader.Reader, demo *types.Demo) {
16 consoleCmd.Size = reader.TryReadSInt32() 16 consoleCmd.Size = reader.TryReadSInt32()
17 consoleCmd.Data = reader.TryReadStringLength(uint64(consoleCmd.Size)) 17 consoleCmd.Data = reader.TryReadStringLength(uint64(consoleCmd.Size))
18 writer.AppendLine("\t%s", strings.TrimSpace(consoleCmd.Data)) 18 demo.Writer.AppendLine("\t%s", strings.TrimSpace(consoleCmd.Data))
19} 19}
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
2 2
3import ( 3import (
4 "github.com/pektezol/bitreader" 4 "github.com/pektezol/bitreader"
5 "github.com/pektezol/sdp.go/pkg/writer" 5 "github.com/pektezol/sdp.go/pkg/types"
6) 6)
7 7
8type CustomData struct { 8type CustomData struct {
9 Type int32 9 Type int32 `json:"type"`
10 Size int32 10 Size int32 `json:"size"`
11 Data string 11 Data any `json:"data"`
12} 12}
13 13
14func (customData *CustomData) ParseCustomData(reader *bitreader.Reader, tickNumber int32, packetType uint8) { 14func (customData *CustomData) ParseCustomData(reader *bitreader.Reader, tickNumber int32, packetType uint8, demo *types.Demo) {
15 customData.Type = reader.TryReadSInt32() 15 customData.Type = reader.TryReadSInt32()
16 customData.Size = reader.TryReadSInt32() 16 customData.Size = reader.TryReadSInt32()
17 if customData.Type != 0 || customData.Size == 8 { 17 if customData.Type != 0 || customData.Size == 8 {
18 // Not SAR data 18 // Not SAR data
19 writer.AppendLine("[%d] %s (%d):", tickNumber, "CUSTOMDATA", packetType) 19 demo.Writer.AppendLine("[%d] %s (%d):", tickNumber, "CUSTOMDATA", packetType)
20 customData.Data = string(reader.TryReadBytesToSlice(uint64(customData.Size))) 20 customData.Data = string(reader.TryReadBytesToSlice(uint64(customData.Size)))
21 writer.AppendLine("\t%s", customData.Data) 21 demo.Writer.AppendLine("\t%s", customData.Data)
22 return 22 return
23 } 23 }
24 // SAR data 24 // SAR data
25 writer.AppendLine("[%d] %s (%d):", tickNumber, "SARDATA", packetType) 25 demo.Writer.AppendLine("[%d] %s (%d):", tickNumber, "SARDATA", packetType)
26 sarData := SarData{} 26 sarData := SarData{}
27 data := reader.TryReadBytesToSlice(uint64(customData.Size)) 27 data := reader.TryReadBytesToSlice(uint64(customData.Size))
28 sarReader := bitreader.NewReaderFromBytes(data, true) 28 sarReader := bitreader.NewReaderFromBytes(data, true)
29 sarData.ParseSarData(sarReader) 29 sarData.ParseSarData(sarReader, demo)
30 customData.Data = sarData
30} 31}
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 (
4 "fmt" 4 "fmt"
5 5
6 "github.com/pektezol/bitreader" 6 "github.com/pektezol/bitreader"
7 "github.com/pektezol/sdp.go/pkg/writer" 7 "github.com/pektezol/sdp.go/pkg/types"
8) 8)
9 9
10type DataTables struct { 10type DataTables struct {
11 Size int32 11 Size int32 `json:"size"`
12 SendTable []SendTable 12 SendTable []SendTable `json:"send_table"`
13 ServerClassInfo []ServerClassInfo 13 ServerClassInfo []ServerClassInfo `json:"server_class_info"`
14} 14}
15 15
16type SendTable struct { 16type SendTable struct {
17 NeedsDecoder bool 17 NeedsDecoder bool `json:"needs_decoder"`
18 NetTableName string 18 NetTableName string `json:"net_table_name"`
19 NumOfProps int16 19 NumOfProps int16 `json:"num_of_props"`
20 Props []SendTableProp 20 Props []SendTableProp `json:"props"`
21} 21}
22 22
23type ServerClassInfo struct { 23type ServerClassInfo struct {
24 DataTableID uint16 24 DataTableID uint16 `json:"data_table_id"`
25 ClassName string 25 ClassName string `json:"class_name"`
26 DataTableName string 26 DataTableName string `json:"data_table_name"`
27} 27}
28 28
29type SendTableProp struct { 29type SendTableProp struct {
30 SendPropType SendPropType 30 SendPropType SendPropType `json:"send_prop_type"`
31 SendPropName string 31 SendPropName string `json:"send_prop_name"`
32 SendPropFlags uint32 32 SendPropFlags uint32 `json:"send_prop_flags"`
33 Priority uint8 33 Priority uint8 `json:"priority"`
34 ExcludeDtName string 34 ExcludeDtName string `json:"exclude_dt_name"`
35 LowValue float32 35 LowValue float32 `json:"low_value"`
36 HighValue float32 36 HighValue float32 `json:"high_value"`
37 NumBits int32 37 NumBits int32 `json:"num_bits"`
38 NumElements int32 38 NumElements int32 `json:"num_elements"`
39} 39}
40 40
41func (dataTables *DataTables) ParseDataTables(reader *bitreader.Reader) { 41func (dataTables *DataTables) ParseDataTables(reader *bitreader.Reader, demo *types.Demo) {
42 dataTables.Size = int32(reader.TryReadSInt32()) 42 dataTables.Size = int32(reader.TryReadSInt32())
43 dataTableReader := bitreader.NewReaderFromBytes(reader.TryReadBytesToSlice(uint64(dataTables.Size)), true) 43 dataTableReader := bitreader.NewReaderFromBytes(reader.TryReadBytesToSlice(uint64(dataTables.Size)), true)
44 count := 0 44 count := 0
45 for dataTableReader.TryReadBool() { 45 for dataTableReader.TryReadBool() {
46 count++ 46 count++
47 dataTables.SendTable = append(dataTables.SendTable, ParseSendTable(dataTableReader)) 47 dataTables.SendTable = append(dataTables.SendTable, ParseSendTable(dataTableReader, demo))
48 } 48 }
49 writer.AppendLine("\t%d Send Tables:", count) 49 demo.Writer.AppendLine("\t%d Send Tables:", count)
50 writer.AppendOutputFromTemp() 50 demo.Writer.AppendOutputFromTemp()
51 numOfClasses := dataTableReader.TryReadBits(16) 51 numOfClasses := dataTableReader.TryReadBits(16)
52 for count = 0; count < int(numOfClasses); count++ { 52 for count = 0; count < int(numOfClasses); count++ {
53 dataTables.ServerClassInfo = append(dataTables.ServerClassInfo, ParseServerClassInfo(dataTableReader, count, int(numOfClasses))) 53 dataTables.ServerClassInfo = append(dataTables.ServerClassInfo, ParseServerClassInfo(dataTableReader, count, int(numOfClasses), demo))
54 } 54 }
55 writer.AppendLine("\t%d Classes:", count) 55 demo.Writer.AppendLine("\t%d Classes:", count)
56 writer.AppendOutputFromTemp() 56 demo.Writer.AppendOutputFromTemp()
57} 57}
58 58
59func ParseSendTable(reader *bitreader.Reader) SendTable { 59func ParseSendTable(reader *bitreader.Reader, demo *types.Demo) SendTable {
60 sendTable := SendTable{ 60 sendTable := SendTable{
61 NeedsDecoder: reader.TryReadBool(), 61 NeedsDecoder: reader.TryReadBool(),
62 NetTableName: reader.TryReadString(), 62 NetTableName: reader.TryReadString(),
@@ -65,7 +65,7 @@ func ParseSendTable(reader *bitreader.Reader) SendTable {
65 if sendTable.NumOfProps < 0 { 65 if sendTable.NumOfProps < 0 {
66 return sendTable 66 return sendTable
67 } 67 }
68 writer.TempAppendLine("\t\t%s (%d Props):", sendTable.NetTableName, sendTable.NumOfProps) 68 demo.Writer.TempAppendLine("\t\t%s (%d Props):", sendTable.NetTableName, sendTable.NumOfProps)
69 for count := 0; count < int(sendTable.NumOfProps); count++ { 69 for count := 0; count < int(sendTable.NumOfProps); count++ {
70 propType := int8(reader.TryReadBits(5)) 70 propType := int8(reader.TryReadBits(5))
71 if propType >= int8(7) { 71 if propType >= int8(7) {
@@ -77,38 +77,38 @@ func ParseSendTable(reader *bitreader.Reader) SendTable {
77 SendPropFlags: uint32(reader.TryReadBits(19)), 77 SendPropFlags: uint32(reader.TryReadBits(19)),
78 Priority: reader.TryReadUInt8(), 78 Priority: reader.TryReadUInt8(),
79 } 79 }
80 writer.TempAppend("\t\t\t%s\t", prop.SendPropType) 80 demo.Writer.TempAppend("\t\t\t%s\t", prop.SendPropType)
81 if propType == int8(ESendPropTypeDataTable) || checkBit(prop.SendPropFlags, 6) { 81 if propType == int8(ESendPropTypeDataTable) || checkBit(prop.SendPropFlags, 6) {
82 prop.ExcludeDtName = reader.TryReadString() 82 prop.ExcludeDtName = reader.TryReadString()
83 writer.TempAppend(":\t%s\t", prop.ExcludeDtName) 83 demo.Writer.TempAppend(":\t%s\t", prop.ExcludeDtName)
84 } else { 84 } else {
85 switch propType { 85 switch propType {
86 case int8(ESendPropTypeString), int8(ESendPropTypeInt), int8(ESendPropTypeFloat), int8(ESendPropTypeVector3), int8(ESendPropTypeVector2): 86 case int8(ESendPropTypeString), int8(ESendPropTypeInt), int8(ESendPropTypeFloat), int8(ESendPropTypeVector3), int8(ESendPropTypeVector2):
87 prop.LowValue = reader.TryReadFloat32() 87 prop.LowValue = reader.TryReadFloat32()
88 prop.HighValue = reader.TryReadFloat32() 88 prop.HighValue = reader.TryReadFloat32()
89 prop.NumBits = int32(reader.TryReadBits(7)) 89 prop.NumBits = int32(reader.TryReadBits(7))
90 writer.TempAppend("Low: %f\tHigh: %f\t%d bits\t", prop.LowValue, prop.HighValue, prop.NumBits) 90 demo.Writer.TempAppend("Low: %f\tHigh: %f\t%d bits\t", prop.LowValue, prop.HighValue, prop.NumBits)
91 case int8(ESendPropTypeArray): 91 case int8(ESendPropTypeArray):
92 prop.NumElements = int32(reader.TryReadBits(10)) 92 prop.NumElements = int32(reader.TryReadBits(10))
93 writer.TempAppend("Elements: %d\t", prop.NumElements) 93 demo.Writer.TempAppend("Elements: %d\t", prop.NumElements)
94 default: 94 default:
95 writer.TempAppend("Unknown Prop Type: %v\t", propType) 95 demo.Writer.TempAppend("Unknown Prop Type: %v\t", propType)
96 return sendTable 96 return sendTable
97 } 97 }
98 } 98 }
99 writer.TempAppend("Flags: %v\tPriority: %d\n", prop.GetFlags(), prop.Priority) 99 demo.Writer.TempAppend("Flags: %v\tPriority: %d\n", prop.GetFlags(), prop.Priority)
100 sendTable.Props = append(sendTable.Props, prop) 100 sendTable.Props = append(sendTable.Props, prop)
101 } 101 }
102 return sendTable 102 return sendTable
103} 103}
104 104
105func ParseServerClassInfo(reader *bitreader.Reader, count int, numOfClasses int) ServerClassInfo { 105func ParseServerClassInfo(reader *bitreader.Reader, count int, numOfClasses int, demo *types.Demo) ServerClassInfo {
106 serverClassInfo := ServerClassInfo{ 106 serverClassInfo := ServerClassInfo{
107 DataTableID: reader.TryReadUInt16(), 107 DataTableID: reader.TryReadUInt16(),
108 ClassName: reader.TryReadString(), 108 ClassName: reader.TryReadString(),
109 DataTableName: reader.TryReadString(), 109 DataTableName: reader.TryReadString(),
110 } 110 }
111 writer.TempAppendLine("\t\t\t[%d] %s (%s)", serverClassInfo.DataTableID, serverClassInfo.ClassName, serverClassInfo.DataTableName) 111 demo.Writer.TempAppendLine("\t\t\t[%d] %s (%s)", serverClassInfo.DataTableID, serverClassInfo.ClassName, serverClassInfo.DataTableName)
112 return serverClassInfo 112 return serverClassInfo
113} 113}
114 114
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 (
5 5
6 "github.com/pektezol/bitreader" 6 "github.com/pektezol/bitreader"
7 "github.com/pektezol/sdp.go/pkg/messages" 7 "github.com/pektezol/sdp.go/pkg/messages"
8 "github.com/pektezol/sdp.go/pkg/writer" 8 "github.com/pektezol/sdp.go/pkg/types"
9) 9)
10 10
11const MSSC int = 2 11const MSSC int = 2
12 12
13type Packet struct { 13type Packet struct {
14 PacketInfo []CmdInfo 14 PacketInfo []CmdInfo `json:"packet_info"`
15 InSequence uint32 15 InSequence uint32 `json:"in_sequence"`
16 OutSequence uint32 16 OutSequence uint32 `json:"out_sequence"`
17 Size uint32 17 Size uint32 `json:"size"`
18 Data []any 18 Data []any `json:"data"`
19} 19}
20 20
21type CmdInfo struct { 21type CmdInfo struct {
22 Flags uint32 22 Flags uint32 `json:"flags"`
23 ViewOrigin []float32 23 ViewOrigin []float32 `json:"view_origin"`
24 ViewAngles []float32 24 ViewAngles []float32 `json:"view_angles"`
25 LocalViewAngles []float32 25 LocalViewAngles []float32 `json:"local_view_angles"`
26 ViewOrigin2 []float32 26 ViewOrigin2 []float32 `json:"view_origin_2"`
27 ViewAngles2 []float32 27 ViewAngles2 []float32 `json:"view_angles_2"`
28 LocalViewAngles2 []float32 28 LocalViewAngles2 []float32 `json:"local_view_angles_2"`
29} 29}
30 30
31func (packet *Packet) ParsePacket(reader *bitreader.Reader) { 31func (packet *Packet) ParsePacket(reader *bitreader.Reader, demo *types.Demo) {
32 for count := 0; count < MSSC; count++ { 32 for count := 0; count < MSSC; count++ {
33 packet.ParseCmdInfo(reader) 33 packet.ParseCmdInfo(reader, demo)
34 } 34 }
35 packet.InSequence = reader.TryReadUInt32() 35 packet.InSequence = reader.TryReadUInt32()
36 packet.OutSequence = reader.TryReadUInt32() 36 packet.OutSequence = reader.TryReadUInt32()
@@ -41,11 +41,11 @@ func (packet *Packet) ParsePacket(reader *bitreader.Reader) {
41 if err != nil { 41 if err != nil {
42 break 42 break
43 } 43 }
44 packet.Data = append(packet.Data, messages.ParseMessages(messageType, packetReader)) 44 packet.Data = append(packet.Data, messages.ParseMessages(messageType, packetReader, demo))
45 } 45 }
46} 46}
47 47
48func (packet *Packet) ParseCmdInfo(reader *bitreader.Reader) { 48func (packet *Packet) ParseCmdInfo(reader *bitreader.Reader, demo *types.Demo) {
49 packet.PacketInfo = append(packet.PacketInfo, CmdInfo{ 49 packet.PacketInfo = append(packet.PacketInfo, CmdInfo{
50 Flags: reader.TryReadUInt32(), 50 Flags: reader.TryReadUInt32(),
51 ViewOrigin: []float32{reader.TryReadFloat32(), reader.TryReadFloat32(), reader.TryReadFloat32()}, 51 ViewOrigin: []float32{reader.TryReadFloat32(), reader.TryReadFloat32(), reader.TryReadFloat32()},
@@ -55,14 +55,14 @@ func (packet *Packet) ParseCmdInfo(reader *bitreader.Reader) {
55 ViewAngles2: []float32{reader.TryReadFloat32(), reader.TryReadFloat32(), reader.TryReadFloat32()}, 55 ViewAngles2: []float32{reader.TryReadFloat32(), reader.TryReadFloat32(), reader.TryReadFloat32()},
56 LocalViewAngles2: []float32{reader.TryReadFloat32(), reader.TryReadFloat32(), reader.TryReadFloat32()}, 56 LocalViewAngles2: []float32{reader.TryReadFloat32(), reader.TryReadFloat32(), reader.TryReadFloat32()},
57 }) 57 })
58 writer.AppendLine("\tFlags: %s", CmdInfoFlags(packet.PacketInfo[len(packet.PacketInfo)-1].Flags).String()) 58 demo.Writer.AppendLine("\tFlags: %s", CmdInfoFlags(packet.PacketInfo[len(packet.PacketInfo)-1].Flags).String())
59 writer.AppendLine("\tView Origin: %v", packet.PacketInfo[len(packet.PacketInfo)-1].ViewOrigin) 59 demo.Writer.AppendLine("\tView Origin: %v", packet.PacketInfo[len(packet.PacketInfo)-1].ViewOrigin)
60 writer.AppendLine("\tView Angles: %v", packet.PacketInfo[len(packet.PacketInfo)-1].ViewAngles) 60 demo.Writer.AppendLine("\tView Angles: %v", packet.PacketInfo[len(packet.PacketInfo)-1].ViewAngles)
61 writer.AppendLine("\tLocal View Angles: %v", packet.PacketInfo[len(packet.PacketInfo)-1].LocalViewAngles) 61 demo.Writer.AppendLine("\tLocal View Angles: %v", packet.PacketInfo[len(packet.PacketInfo)-1].LocalViewAngles)
62 writer.AppendLine("\tView Origin 2: %v", packet.PacketInfo[len(packet.PacketInfo)-1].ViewOrigin2) 62 demo.Writer.AppendLine("\tView Origin 2: %v", packet.PacketInfo[len(packet.PacketInfo)-1].ViewOrigin2)
63 writer.AppendLine("\tView Angles 2: %v", packet.PacketInfo[len(packet.PacketInfo)-1].ViewAngles2) 63 demo.Writer.AppendLine("\tView Angles 2: %v", packet.PacketInfo[len(packet.PacketInfo)-1].ViewAngles2)
64 writer.AppendLine("\tLocal View Angles 2: %v", packet.PacketInfo[len(packet.PacketInfo)-1].LocalViewAngles2) 64 demo.Writer.AppendLine("\tLocal View Angles 2: %v", packet.PacketInfo[len(packet.PacketInfo)-1].LocalViewAngles2)
65 writer.AppendLine("") 65 demo.Writer.AppendLine("")
66} 66}
67 67
68type CmdInfoFlags int 68type 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 (
5 "fmt" 5 "fmt"
6 6
7 "github.com/pektezol/bitreader" 7 "github.com/pektezol/bitreader"
8 "github.com/pektezol/sdp.go/pkg/writer" 8 "github.com/pektezol/sdp.go/pkg/types"
9) 9)
10 10
11type SarDataType uint8 11type SarDataType uint8
@@ -69,89 +69,89 @@ func (sarDataType SarDataType) String() string {
69} 69}
70 70
71type SarData struct { 71type SarData struct {
72 Type SarDataType 72 Type SarDataType `json:"type"`
73 Slot int 73 Slot int `json:"slot"`
74 Data any 74 Data any `json:"data"`
75} 75}
76 76
77type SarDataTimescaleCheat struct { 77type SarDataTimescaleCheat struct {
78 Timescale float32 78 Timescale float32 `json:"timescale"`
79} 79}
80 80
81type SarDataInitialCVar struct { 81type SarDataInitialCVar struct {
82 CVar string 82 CVar string `json:"cvar"`
83 Val string 83 Val string `json:"val"`
84} 84}
85 85
86type SarDataChecksum struct { 86type SarDataChecksum struct {
87 DemoSum uint32 87 DemoSum uint32 `json:"demo_sum"`
88 SarSum uint32 88 SarSum uint32 `json:"sar_sum"`
89} 89}
90 90
91type SarDataChecksumV2 struct { 91type SarDataChecksumV2 struct {
92 SarSum uint32 92 SarSum uint32 `json:"sar_sum"`
93 Signature [64]byte 93 Signature [64]byte `json:"signature"`
94} 94}
95 95
96type SarDataEntityInput struct { 96type SarDataEntityInput struct {
97 TargetName string 97 TargetName string `json:"target_name"`
98 ClassName string 98 ClassName string `json:"class_name"`
99 InputName string 99 InputName string `json:"input_name"`
100 Parameter string 100 Parameter string `json:"parameter"`
101} 101}
102 102
103type SarDataPortalPlacement struct { 103type SarDataPortalPlacement struct {
104 Orange bool 104 Orange bool `json:"orange"`
105 X float32 105 X float32 `json:"x"`
106 Y float32 106 Y float32 `json:"y"`
107 Z float32 107 Z float32 `json:"z"`
108} 108}
109 109
110type SarDataPause struct { 110type SarDataPause struct {
111 PauseTicks uint32 111 PauseTicks uint32 `json:"pause_ticks"`
112} 112}
113 113
114type SarDataWaitRun struct { 114type SarDataWaitRun struct {
115 Ticks int 115 Ticks int `json:"ticks"`
116 Cmd string 116 Cmd string `json:"cmd"`
117} 117}
118 118
119type SarDataHWaitRun struct { 119type SarDataHWaitRun struct {
120 Ticks int 120 Ticks int `json:"ticks"`
121 Cmd string 121 Cmd string `json:"cmd"`
122} 122}
123 123
124type SarDataSpeedrunTime struct { 124type SarDataSpeedrunTime struct {
125 NSplits uint32 125 NSplits uint32 `json:"n_splits"`
126 Splits []SarDataSpeedrunTimeSplits 126 Splits []SarDataSpeedrunTimeSplits `json:"splits"`
127} 127}
128 128
129type SarDataSpeedrunTimeSegs struct { 129type SarDataSpeedrunTimeSegs struct {
130 Name string 130 Name string `json:"name"`
131 Ticks uint32 131 Ticks uint32 `json:"ticks"`
132} 132}
133 133
134type SarDataSpeedrunTimeSplits struct { 134type SarDataSpeedrunTimeSplits struct {
135 Name string 135 Name string `json:"name"`
136 NSegs uint32 136 NSegs uint32 `json:"n_segs"`
137 Segs []SarDataSpeedrunTimeSegs 137 Segs []SarDataSpeedrunTimeSegs `json:"segs"`
138} 138}
139 139
140type SarDataTimestamp struct { 140type SarDataTimestamp struct {
141 Year uint16 141 Year uint16 `json:"year"`
142 Month uint8 142 Month uint8 `json:"month"`
143 Day uint8 143 Day uint8 `json:"day"`
144 Hour uint8 144 Hour uint8 `json:"hour"`
145 Minute uint8 145 Minute uint8 `json:"minute"`
146 Second uint8 146 Second uint8 `json:"second"`
147} 147}
148 148
149type SarDataFileChecksum struct { 149type SarDataFileChecksum struct {
150 Sum uint32 150 Sum uint32 `json:"sum"`
151 Path string 151 Path string `json:"path"`
152} 152}
153 153
154func (sarData *SarData) ParseSarData(reader *bitreader.Reader) (err error) { 154func (sarData *SarData) ParseSarData(reader *bitreader.Reader, demo *types.Demo) (err error) {
155 reader.SkipBytes(8) 155 reader.SkipBytes(8)
156 len := reader.TryReadRemainingBits() / 8 156 len := reader.TryReadRemainingBits() / 8
157 if len == 0 { 157 if len == 0 {
@@ -164,32 +164,32 @@ func (sarData *SarData) ParseSarData(reader *bitreader.Reader) (err error) {
164 len = 9 164 len = 9
165 } 165 }
166 dataReader := bitreader.NewReaderFromBytes(reader.TryReadBytesToSlice(len-1), true) 166 dataReader := bitreader.NewReaderFromBytes(reader.TryReadBytesToSlice(len-1), true)
167 writer.AppendLine("\tMessage: %s (%d):", sarData.Type.String(), sarData.Type) 167 demo.Writer.AppendLine("\tMessage: %s (%d):", sarData.Type.String(), sarData.Type)
168 switch sarData.Type { 168 switch sarData.Type {
169 case ESarDataTimescaleCheat: 169 case ESarDataTimescaleCheat:
170 sarData.Data, err = parseTimescaleCheatData(dataReader, len) 170 sarData.Data, err = parseTimescaleCheatData(dataReader, len, demo)
171 if err != nil { 171 if err != nil {
172 sarData.Data = nil 172 sarData.Data = nil
173 } 173 }
174 case ESarDataInitialCVar: 174 case ESarDataInitialCVar:
175 sarData.Data = parseInitialCVarData(dataReader) 175 sarData.Data = parseInitialCVarData(dataReader, demo)
176 case ESarDataEntityInputSlot: 176 case ESarDataEntityInputSlot:
177 sarData.Slot = int(dataReader.TryReadBytes(1)) 177 sarData.Slot = int(dataReader.TryReadBytes(1))
178 writer.AppendLine("\t\tSlot: %d", sarData.Slot) 178 demo.Writer.AppendLine("\t\tSlot: %d", sarData.Slot)
179 case ESarDataEntityInput: 179 case ESarDataEntityInput:
180 sarData.Data = parseEntityInputData(dataReader) 180 sarData.Data = parseEntityInputData(dataReader, demo)
181 case ESarDataChecksum: 181 case ESarDataChecksum:
182 sarData.Data, err = parseChecksumData(dataReader, len) 182 sarData.Data, err = parseChecksumData(dataReader, len, demo)
183 if err != nil { 183 if err != nil {
184 sarData.Data = nil 184 sarData.Data = nil
185 } 185 }
186 case ESarDataChecksumV2: 186 case ESarDataChecksumV2:
187 sarData.Data, err = parseChecksumV2Data(dataReader, len) 187 sarData.Data, err = parseChecksumV2Data(dataReader, len, demo)
188 if err != nil { 188 if err != nil {
189 sarData.Data = nil 189 sarData.Data = nil
190 } 190 }
191 case ESarDataPortalPlacement: 191 case ESarDataPortalPlacement:
192 data, slot, err := parsePortalPlacementData(dataReader, len) 192 data, slot, err := parsePortalPlacementData(dataReader, len, demo)
193 if err != nil { 193 if err != nil {
194 sarData.Data = nil 194 sarData.Data = nil
195 } else { 195 } else {
@@ -201,34 +201,34 @@ func (sarData *SarData) ParseSarData(reader *bitreader.Reader) (err error) {
201 if err != nil { 201 if err != nil {
202 sarData.Data = nil 202 sarData.Data = nil
203 } 203 }
204 writer.AppendLine("\t\tSlot: %d", sarData.Slot) 204 demo.Writer.AppendLine("\t\tSlot: %d", sarData.Slot)
205 case ESarDataPause: 205 case ESarDataPause:
206 sarData.Data, err = parsePauseData(dataReader, len) 206 sarData.Data, err = parsePauseData(dataReader, len, demo)
207 if err != nil { 207 if err != nil {
208 sarData.Data = nil 208 sarData.Data = nil
209 } 209 }
210 case ESarDataWaitRun: 210 case ESarDataWaitRun:
211 sarData.Data, err = parseWaitRunData(dataReader, len) 211 sarData.Data, err = parseWaitRunData(dataReader, len, demo)
212 if err != nil { 212 if err != nil {
213 sarData.Data = nil 213 sarData.Data = nil
214 } 214 }
215 case ESarDataHWaitRun: 215 case ESarDataHWaitRun:
216 sarData.Data, err = parseHWaitRunData(dataReader, len) 216 sarData.Data, err = parseHWaitRunData(dataReader, len, demo)
217 if err != nil { 217 if err != nil {
218 sarData.Data = nil 218 sarData.Data = nil
219 } 219 }
220 case ESarDataSpeedrunTime: 220 case ESarDataSpeedrunTime:
221 sarData.Data, err = parseSpeedrunTimeData(dataReader, len) 221 sarData.Data, err = parseSpeedrunTimeData(dataReader, len, demo)
222 if err != nil { 222 if err != nil {
223 sarData.Data = nil 223 sarData.Data = nil
224 } 224 }
225 case ESarDataTimestamp: 225 case ESarDataTimestamp:
226 sarData.Data, err = parseTimestampData(dataReader, len) 226 sarData.Data, err = parseTimestampData(dataReader, len, demo)
227 if err != nil { 227 if err != nil {
228 sarData.Data = nil 228 sarData.Data = nil
229 } 229 }
230 case ESarDataFileChecksum: 230 case ESarDataFileChecksum:
231 sarData.Data, err = parseFileChecksumData(dataReader, len) 231 sarData.Data, err = parseFileChecksumData(dataReader, len, demo)
232 if err != nil { 232 if err != nil {
233 sarData.Data = nil 233 sarData.Data = nil
234 } 234 }
@@ -239,41 +239,41 @@ func (sarData *SarData) ParseSarData(reader *bitreader.Reader) (err error) {
239 return nil 239 return nil
240} 240}
241 241
242func parseTimescaleCheatData(reader *bitreader.Reader, length uint64) (SarDataTimescaleCheat, error) { 242func parseTimescaleCheatData(reader *bitreader.Reader, length uint64, demo *types.Demo) (SarDataTimescaleCheat, error) {
243 if length != 5 { 243 if length != 5 {
244 return SarDataTimescaleCheat{}, errors.New("sar data invalid") 244 return SarDataTimescaleCheat{}, errors.New("sar data invalid")
245 } 245 }
246 sarDataTimescaleCheat := SarDataTimescaleCheat{ 246 sarDataTimescaleCheat := SarDataTimescaleCheat{
247 Timescale: reader.TryReadFloat32(), 247 Timescale: reader.TryReadFloat32(),
248 } 248 }
249 writer.AppendLine("\t\tTimescale: %f", sarDataTimescaleCheat.Timescale) 249 demo.Writer.AppendLine("\t\tTimescale: %f", sarDataTimescaleCheat.Timescale)
250 return sarDataTimescaleCheat, nil 250 return sarDataTimescaleCheat, nil
251} 251}
252 252
253func parseInitialCVarData(reader *bitreader.Reader) SarDataInitialCVar { 253func parseInitialCVarData(reader *bitreader.Reader, demo *types.Demo) SarDataInitialCVar {
254 sarDataInitialCvar := SarDataInitialCVar{ 254 sarDataInitialCvar := SarDataInitialCVar{
255 CVar: reader.TryReadString(), 255 CVar: reader.TryReadString(),
256 Val: reader.TryReadString(), 256 Val: reader.TryReadString(),
257 } 257 }
258 writer.AppendLine("\t\tCvar: \"%s\" = \"%s\"", sarDataInitialCvar.CVar, sarDataInitialCvar.Val) 258 demo.Writer.AppendLine("\t\tCvar: \"%s\" = \"%s\"", sarDataInitialCvar.CVar, sarDataInitialCvar.Val)
259 return sarDataInitialCvar 259 return sarDataInitialCvar
260} 260}
261 261
262func parseEntityInputData(reader *bitreader.Reader) SarDataEntityInput { 262func parseEntityInputData(reader *bitreader.Reader, demo *types.Demo) SarDataEntityInput {
263 sarDataEntityInput := SarDataEntityInput{ 263 sarDataEntityInput := SarDataEntityInput{
264 TargetName: reader.TryReadString(), 264 TargetName: reader.TryReadString(),
265 ClassName: reader.TryReadString(), 265 ClassName: reader.TryReadString(),
266 InputName: reader.TryReadString(), 266 InputName: reader.TryReadString(),
267 Parameter: reader.TryReadString(), 267 Parameter: reader.TryReadString(),
268 } 268 }
269 writer.AppendLine("\t\tTarget: %s", sarDataEntityInput.TargetName) 269 demo.Writer.AppendLine("\t\tTarget: %s", sarDataEntityInput.TargetName)
270 writer.AppendLine("\t\tClass: %s", sarDataEntityInput.ClassName) 270 demo.Writer.AppendLine("\t\tClass: %s", sarDataEntityInput.ClassName)
271 writer.AppendLine("\t\tInput: %s", sarDataEntityInput.InputName) 271 demo.Writer.AppendLine("\t\tInput: %s", sarDataEntityInput.InputName)
272 writer.AppendLine("\t\tParameter: %s", sarDataEntityInput.Parameter) 272 demo.Writer.AppendLine("\t\tParameter: %s", sarDataEntityInput.Parameter)
273 return sarDataEntityInput 273 return sarDataEntityInput
274} 274}
275 275
276func parseChecksumData(reader *bitreader.Reader, length uint64) (SarDataChecksum, error) { 276func parseChecksumData(reader *bitreader.Reader, length uint64, demo *types.Demo) (SarDataChecksum, error) {
277 if length != 9 { 277 if length != 9 {
278 return SarDataChecksum{}, errors.New("sar data invalid") 278 return SarDataChecksum{}, errors.New("sar data invalid")
279 } 279 }
@@ -281,12 +281,12 @@ func parseChecksumData(reader *bitreader.Reader, length uint64) (SarDataChecksum
281 DemoSum: reader.TryReadUInt32(), 281 DemoSum: reader.TryReadUInt32(),
282 SarSum: reader.TryReadUInt32(), 282 SarSum: reader.TryReadUInt32(),
283 } 283 }
284 writer.AppendLine("\t\tDemo Checksum: %d", sarDataChecksum.DemoSum) 284 demo.Writer.AppendLine("\t\tDemo Checksum: %d", sarDataChecksum.DemoSum)
285 writer.AppendLine("\t\tSAR Checksum: %d", sarDataChecksum.SarSum) 285 demo.Writer.AppendLine("\t\tSAR Checksum: %d", sarDataChecksum.SarSum)
286 return sarDataChecksum, nil 286 return sarDataChecksum, nil
287} 287}
288 288
289func parseChecksumV2Data(reader *bitreader.Reader, length uint64) (SarDataChecksumV2, error) { 289func parseChecksumV2Data(reader *bitreader.Reader, length uint64, demo *types.Demo) (SarDataChecksumV2, error) {
290 if length != 69 { 290 if length != 69 {
291 return SarDataChecksumV2{}, errors.New("sar data invalid") 291 return SarDataChecksumV2{}, errors.New("sar data invalid")
292 } 292 }
@@ -294,12 +294,12 @@ func parseChecksumV2Data(reader *bitreader.Reader, length uint64) (SarDataChecks
294 SarSum: reader.TryReadUInt32(), 294 SarSum: reader.TryReadUInt32(),
295 Signature: [64]byte(reader.TryReadBytesToSlice(60)), 295 Signature: [64]byte(reader.TryReadBytesToSlice(60)),
296 } 296 }
297 writer.AppendLine("\t\tSAR Checksum: %d", sarDataChecksumV2.SarSum) 297 demo.Writer.AppendLine("\t\tSAR Checksum: %d", sarDataChecksumV2.SarSum)
298 writer.AppendLine("\t\tSignature: %v", sarDataChecksumV2.Signature) 298 demo.Writer.AppendLine("\t\tSignature: %v", sarDataChecksumV2.Signature)
299 return sarDataChecksumV2, nil 299 return sarDataChecksumV2, nil
300} 300}
301 301
302func parsePortalPlacementData(reader *bitreader.Reader, length uint64) (SarDataPortalPlacement, int, error) { 302func parsePortalPlacementData(reader *bitreader.Reader, length uint64, demo *types.Demo) (SarDataPortalPlacement, int, error) {
303 if length != 15 { 303 if length != 15 {
304 return SarDataPortalPlacement{}, 0, errors.New("sar data invalid") 304 return SarDataPortalPlacement{}, 0, errors.New("sar data invalid")
305 } 305 }
@@ -312,10 +312,10 @@ func parsePortalPlacementData(reader *bitreader.Reader, length uint64) (SarDataP
312 Y: reader.TryReadFloat32(), 312 Y: reader.TryReadFloat32(),
313 Z: reader.TryReadFloat32(), 313 Z: reader.TryReadFloat32(),
314 } 314 }
315 writer.AppendLine("\t\tOrange: %t", orange) 315 demo.Writer.AppendLine("\t\tOrange: %t", orange)
316 writer.AppendLine("\t\tX: %f", sarDataPortalPlacement.X) 316 demo.Writer.AppendLine("\t\tX: %f", sarDataPortalPlacement.X)
317 writer.AppendLine("\t\tY: %f", sarDataPortalPlacement.Y) 317 demo.Writer.AppendLine("\t\tY: %f", sarDataPortalPlacement.Y)
318 writer.AppendLine("\t\tZ: %f", sarDataPortalPlacement.Z) 318 demo.Writer.AppendLine("\t\tZ: %f", sarDataPortalPlacement.Z)
319 return sarDataPortalPlacement, slot, nil 319 return sarDataPortalPlacement, slot, nil
320} 320}
321 321
@@ -326,18 +326,18 @@ func parseChallengeFlagsCrouchFlyData(reader *bitreader.Reader, length uint64) (
326 return int(reader.TryReadBytes(1)), nil 326 return int(reader.TryReadBytes(1)), nil
327} 327}
328 328
329func parsePauseData(reader *bitreader.Reader, length uint64) (SarDataPause, error) { 329func parsePauseData(reader *bitreader.Reader, length uint64, demo *types.Demo) (SarDataPause, error) {
330 if length != 5 { 330 if length != 5 {
331 return SarDataPause{}, errors.New("sar data invalid") 331 return SarDataPause{}, errors.New("sar data invalid")
332 } 332 }
333 sarDataPause := SarDataPause{ 333 sarDataPause := SarDataPause{
334 PauseTicks: reader.TryReadUInt32(), 334 PauseTicks: reader.TryReadUInt32(),
335 } 335 }
336 writer.AppendLine("\t\tPause Ticks: %d", sarDataPause.PauseTicks) 336 demo.Writer.AppendLine("\t\tPause Ticks: %d", sarDataPause.PauseTicks)
337 return sarDataPause, nil 337 return sarDataPause, nil
338} 338}
339 339
340func parseWaitRunData(reader *bitreader.Reader, length uint64) (SarDataWaitRun, error) { 340func parseWaitRunData(reader *bitreader.Reader, length uint64, demo *types.Demo) (SarDataWaitRun, error) {
341 if length < 6 { 341 if length < 6 {
342 return SarDataWaitRun{}, errors.New("sar data invalid") 342 return SarDataWaitRun{}, errors.New("sar data invalid")
343 } 343 }
@@ -345,12 +345,12 @@ func parseWaitRunData(reader *bitreader.Reader, length uint64) (SarDataWaitRun,
345 Ticks: int(reader.TryReadUInt32()), 345 Ticks: int(reader.TryReadUInt32()),
346 Cmd: reader.TryReadString(), 346 Cmd: reader.TryReadString(),
347 } 347 }
348 writer.AppendLine("\t\tTicks: %d", sarDataWaitRun.Ticks) 348 demo.Writer.AppendLine("\t\tTicks: %d", sarDataWaitRun.Ticks)
349 writer.AppendLine("\t\tCmd: \"%s\"", sarDataWaitRun.Cmd) 349 demo.Writer.AppendLine("\t\tCmd: \"%s\"", sarDataWaitRun.Cmd)
350 return sarDataWaitRun, nil 350 return sarDataWaitRun, nil
351} 351}
352 352
353func parseHWaitRunData(reader *bitreader.Reader, length uint64) (SarDataHWaitRun, error) { 353func parseHWaitRunData(reader *bitreader.Reader, length uint64, demo *types.Demo) (SarDataHWaitRun, error) {
354 if length < 6 { 354 if length < 6 {
355 return SarDataHWaitRun{}, errors.New("sar data invalid") 355 return SarDataHWaitRun{}, errors.New("sar data invalid")
356 } 356 }
@@ -358,12 +358,12 @@ func parseHWaitRunData(reader *bitreader.Reader, length uint64) (SarDataHWaitRun
358 Ticks: int(reader.TryReadUInt32()), 358 Ticks: int(reader.TryReadUInt32()),
359 Cmd: reader.TryReadString(), 359 Cmd: reader.TryReadString(),
360 } 360 }
361 writer.AppendLine("\t\tTicks: %d", sarDataHWaitRun.Ticks) 361 demo.Writer.AppendLine("\t\tTicks: %d", sarDataHWaitRun.Ticks)
362 writer.AppendLine("\t\tCmd: \"%s\"", sarDataHWaitRun.Cmd) 362 demo.Writer.AppendLine("\t\tCmd: \"%s\"", sarDataHWaitRun.Cmd)
363 return sarDataHWaitRun, nil 363 return sarDataHWaitRun, nil
364} 364}
365 365
366func parseSpeedrunTimeData(reader *bitreader.Reader, length uint64) (SarDataSpeedrunTime, error) { 366func parseSpeedrunTimeData(reader *bitreader.Reader, length uint64, demo *types.Demo) (SarDataSpeedrunTime, error) {
367 if length < 5 { 367 if length < 5 {
368 return SarDataSpeedrunTime{}, errors.New("sar data invalid") 368 return SarDataSpeedrunTime{}, errors.New("sar data invalid")
369 } 369 }
@@ -372,14 +372,14 @@ func parseSpeedrunTimeData(reader *bitreader.Reader, length uint64) (SarDataSpee
372 for splitCount := 0; splitCount < int(numberOfSplits); splitCount++ { 372 for splitCount := 0; splitCount < int(numberOfSplits); splitCount++ {
373 splits[splitCount].Name = reader.TryReadString() 373 splits[splitCount].Name = reader.TryReadString()
374 splits[splitCount].NSegs = reader.TryReadUInt32() 374 splits[splitCount].NSegs = reader.TryReadUInt32()
375 writer.AppendLine("\t\t[%d] Split Name: \"%s\"", splitCount, splits[splitCount].Name) 375 demo.Writer.AppendLine("\t\t[%d] Split Name: \"%s\"", splitCount, splits[splitCount].Name)
376 writer.AppendLine("\t\t[%d] Number of Segments: %d", splitCount, splits[splitCount].NSegs) 376 demo.Writer.AppendLine("\t\t[%d] Number of Segments: %d", splitCount, splits[splitCount].NSegs)
377 splits[splitCount].Segs = make([]SarDataSpeedrunTimeSegs, splits[splitCount].NSegs) 377 splits[splitCount].Segs = make([]SarDataSpeedrunTimeSegs, splits[splitCount].NSegs)
378 for segCount := 0; segCount < int(splits[splitCount].NSegs); segCount++ { 378 for segCount := 0; segCount < int(splits[splitCount].NSegs); segCount++ {
379 splits[splitCount].Segs[segCount].Name = reader.TryReadString() 379 splits[splitCount].Segs[segCount].Name = reader.TryReadString()
380 splits[splitCount].Segs[segCount].Ticks = reader.TryReadUInt32() 380 splits[splitCount].Segs[segCount].Ticks = reader.TryReadUInt32()
381 writer.AppendLine("\t\t\t[%d] Segment Name: \"%s\"", segCount, splits[splitCount].Segs[segCount].Name) 381 demo.Writer.AppendLine("\t\t\t[%d] Segment Name: \"%s\"", segCount, splits[splitCount].Segs[segCount].Name)
382 writer.AppendLine("\t\t\t[%d] Segment Ticks: %d", segCount, splits[splitCount].Segs[segCount].Ticks) 382 demo.Writer.AppendLine("\t\t\t[%d] Segment Ticks: %d", segCount, splits[splitCount].Segs[segCount].Ticks)
383 } 383 }
384 } 384 }
385 return SarDataSpeedrunTime{ 385 return SarDataSpeedrunTime{
@@ -388,7 +388,7 @@ func parseSpeedrunTimeData(reader *bitreader.Reader, length uint64) (SarDataSpee
388 }, nil 388 }, nil
389} 389}
390 390
391func parseTimestampData(reader *bitreader.Reader, length uint64) (SarDataTimestamp, error) { 391func parseTimestampData(reader *bitreader.Reader, length uint64, demo *types.Demo) (SarDataTimestamp, error) {
392 if length != 8 { 392 if length != 8 {
393 return SarDataTimestamp{}, errors.New("sar data invalid") 393 return SarDataTimestamp{}, errors.New("sar data invalid")
394 } 394 }
@@ -401,16 +401,16 @@ func parseTimestampData(reader *bitreader.Reader, length uint64) (SarDataTimesta
401 Minute: timestamp[5], 401 Minute: timestamp[5],
402 Second: timestamp[6], 402 Second: timestamp[6],
403 } 403 }
404 writer.AppendLine("\t\tYear: %d", sarDataTimeStamp.Year) 404 demo.Writer.AppendLine("\t\tYear: %d", sarDataTimeStamp.Year)
405 writer.AppendLine("\t\tMonth: %d", sarDataTimeStamp.Month) 405 demo.Writer.AppendLine("\t\tMonth: %d", sarDataTimeStamp.Month)
406 writer.AppendLine("\t\tDay: %d", sarDataTimeStamp.Day) 406 demo.Writer.AppendLine("\t\tDay: %d", sarDataTimeStamp.Day)
407 writer.AppendLine("\t\tHour: %d", sarDataTimeStamp.Hour) 407 demo.Writer.AppendLine("\t\tHour: %d", sarDataTimeStamp.Hour)
408 writer.AppendLine("\t\tMinute: %d", sarDataTimeStamp.Minute) 408 demo.Writer.AppendLine("\t\tMinute: %d", sarDataTimeStamp.Minute)
409 writer.AppendLine("\t\tSecond: %d", sarDataTimeStamp.Second) 409 demo.Writer.AppendLine("\t\tSecond: %d", sarDataTimeStamp.Second)
410 return sarDataTimeStamp, nil 410 return sarDataTimeStamp, nil
411} 411}
412 412
413func parseFileChecksumData(reader *bitreader.Reader, length uint64) (SarDataFileChecksum, error) { 413func parseFileChecksumData(reader *bitreader.Reader, length uint64, demo *types.Demo) (SarDataFileChecksum, error) {
414 if length < 6 { 414 if length < 6 {
415 return SarDataFileChecksum{}, errors.New("sar data invalid") 415 return SarDataFileChecksum{}, errors.New("sar data invalid")
416 } 416 }
@@ -418,7 +418,7 @@ func parseFileChecksumData(reader *bitreader.Reader, length uint64) (SarDataFile
418 Sum: reader.TryReadUInt32(), 418 Sum: reader.TryReadUInt32(),
419 Path: reader.TryReadString(), 419 Path: reader.TryReadString(),
420 } 420 }
421 writer.AppendLine("\t\tChecksum: %d", sarDataFileChecksum.Sum) 421 demo.Writer.AppendLine("\t\tChecksum: %d", sarDataFileChecksum.Sum)
422 writer.AppendLine("\t\tPath: \"%s\"", sarDataFileChecksum.Path) 422 demo.Writer.AppendLine("\t\tPath: \"%s\"", sarDataFileChecksum.Path)
423 return sarDataFileChecksum, nil 423 return sarDataFileChecksum, nil
424} 424}
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
3import ( 3import (
4 "github.com/pektezol/bitreader" 4 "github.com/pektezol/bitreader"
5 "github.com/pektezol/sdp.go/pkg/messages" 5 "github.com/pektezol/sdp.go/pkg/messages"
6 "github.com/pektezol/sdp.go/pkg/writer" 6 "github.com/pektezol/sdp.go/pkg/types"
7) 7)
8 8
9type SignOn struct { 9type SignOn struct {
10 PacketInfo []CmdInfo 10 PacketInfo []CmdInfo `json:"packet_info"`
11 InSequence uint32 11 InSequence uint32 `json:"in_sequence"`
12 OutSequence uint32 12 OutSequence uint32 `json:"out_sequence"`
13 Size uint32 13 Size uint32 `json:"size"`
14 Data []any 14 Data []any `json:"data"`
15} 15}
16 16
17func (signOn *SignOn) ParseSignOn(reader *bitreader.Reader) { 17func (signOn *SignOn) ParseSignOn(reader *bitreader.Reader, demo *types.Demo) {
18 for count := 0; count < MSSC; count++ { 18 for count := 0; count < MSSC; count++ {
19 signOn.ParseCmdInfo(reader) 19 signOn.ParseCmdInfo(reader, demo)
20 } 20 }
21 signOn.InSequence = reader.TryReadUInt32() 21 signOn.InSequence = reader.TryReadUInt32()
22 signOn.OutSequence = reader.TryReadUInt32() 22 signOn.OutSequence = reader.TryReadUInt32()
@@ -27,11 +27,11 @@ func (signOn *SignOn) ParseSignOn(reader *bitreader.Reader) {
27 if err != nil { 27 if err != nil {
28 break 28 break
29 } 29 }
30 signOn.Data = append(signOn.Data, messages.ParseMessages(messageType, packetReader)) 30 signOn.Data = append(signOn.Data, messages.ParseMessages(messageType, packetReader, demo))
31 } 31 }
32} 32}
33 33
34func (signOn *SignOn) ParseCmdInfo(reader *bitreader.Reader) { 34func (signOn *SignOn) ParseCmdInfo(reader *bitreader.Reader, demo *types.Demo) {
35 signOn.PacketInfo = append(signOn.PacketInfo, CmdInfo{ 35 signOn.PacketInfo = append(signOn.PacketInfo, CmdInfo{
36 Flags: reader.TryReadUInt32(), 36 Flags: reader.TryReadUInt32(),
37 ViewOrigin: []float32{reader.TryReadFloat32(), reader.TryReadFloat32(), reader.TryReadFloat32()}, 37 ViewOrigin: []float32{reader.TryReadFloat32(), reader.TryReadFloat32(), reader.TryReadFloat32()},
@@ -41,12 +41,12 @@ func (signOn *SignOn) ParseCmdInfo(reader *bitreader.Reader) {
41 ViewAngles2: []float32{reader.TryReadFloat32(), reader.TryReadFloat32(), reader.TryReadFloat32()}, 41 ViewAngles2: []float32{reader.TryReadFloat32(), reader.TryReadFloat32(), reader.TryReadFloat32()},
42 LocalViewAngles2: []float32{reader.TryReadFloat32(), reader.TryReadFloat32(), reader.TryReadFloat32()}, 42 LocalViewAngles2: []float32{reader.TryReadFloat32(), reader.TryReadFloat32(), reader.TryReadFloat32()},
43 }) 43 })
44 writer.AppendLine("\tFlags: %s", CmdInfoFlags(signOn.PacketInfo[len(signOn.PacketInfo)-1].Flags).String()) 44 demo.Writer.AppendLine("\tFlags: %s", CmdInfoFlags(signOn.PacketInfo[len(signOn.PacketInfo)-1].Flags).String())
45 writer.AppendLine("\tView Origin: %v", signOn.PacketInfo[len(signOn.PacketInfo)-1].ViewOrigin) 45 demo.Writer.AppendLine("\tView Origin: %v", signOn.PacketInfo[len(signOn.PacketInfo)-1].ViewOrigin)
46 writer.AppendLine("\tView Angles: %v", signOn.PacketInfo[len(signOn.PacketInfo)-1].ViewAngles) 46 demo.Writer.AppendLine("\tView Angles: %v", signOn.PacketInfo[len(signOn.PacketInfo)-1].ViewAngles)
47 writer.AppendLine("\tLocal View Angles: %v", signOn.PacketInfo[len(signOn.PacketInfo)-1].LocalViewAngles) 47 demo.Writer.AppendLine("\tLocal View Angles: %v", signOn.PacketInfo[len(signOn.PacketInfo)-1].LocalViewAngles)
48 writer.AppendLine("\tView Origin 2: %v", signOn.PacketInfo[len(signOn.PacketInfo)-1].ViewOrigin2) 48 demo.Writer.AppendLine("\tView Origin 2: %v", signOn.PacketInfo[len(signOn.PacketInfo)-1].ViewOrigin2)
49 writer.AppendLine("\tView Angles 2: %v", signOn.PacketInfo[len(signOn.PacketInfo)-1].ViewAngles2) 49 demo.Writer.AppendLine("\tView Angles 2: %v", signOn.PacketInfo[len(signOn.PacketInfo)-1].ViewAngles2)
50 writer.AppendLine("\tLocal View Angles 2: %v", signOn.PacketInfo[len(signOn.PacketInfo)-1].LocalViewAngles2) 50 demo.Writer.AppendLine("\tLocal View Angles 2: %v", signOn.PacketInfo[len(signOn.PacketInfo)-1].LocalViewAngles2)
51 writer.AppendLine("") 51 demo.Writer.AppendLine("")
52} 52}
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
2 2
3import ( 3import (
4 "github.com/pektezol/bitreader" 4 "github.com/pektezol/bitreader"
5 "github.com/pektezol/sdp.go/pkg/writer" 5 "github.com/pektezol/sdp.go/pkg/types"
6) 6)
7 7
8type Stop struct { 8type Stop struct {
9 RemainingData []byte 9 RemainingData []byte `json:"remaining_data"`
10} 10}
11 11
12func (stop *Stop) ParseStop(reader *bitreader.Reader) { 12func (stop *Stop) ParseStop(reader *bitreader.Reader, demo *types.Demo) {
13 if reader.TryReadBool() { 13 if reader.TryReadBool() {
14 stop.RemainingData = reader.TryReadBitsToSlice(uint64(reader.TryReadRemainingBits())) 14 stop.RemainingData = reader.TryReadBitsToSlice(uint64(reader.TryReadRemainingBits()))
15 writer.AppendLine("\tRemaining Data: %v", stop.RemainingData) 15 demo.Writer.AppendLine("\tRemaining Data: %v", stop.RemainingData)
16 } 16 }
17} 17}
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 (
5 "strings" 5 "strings"
6 6
7 "github.com/pektezol/bitreader" 7 "github.com/pektezol/bitreader"
8 "github.com/pektezol/sdp.go/pkg/writer" 8 "github.com/pektezol/sdp.go/pkg/types"
9) 9)
10 10
11type StringTables struct { 11type StringTables struct {
12 Size int32 12 Size int32 `json:"size"`
13 Data []StringTable 13 Data []StringTable `json:"data"`
14} 14}
15 15
16type StringTable struct { 16type StringTable struct {
17 Name string 17 Name string `json:"name"`
18 TableEntries []StringTableEntry 18 TableEntries []StringTableEntry `json:"table_entries"`
19 Classes []StringTableClass 19 Classes []StringTableClass `json:"classes"`
20} 20}
21 21
22type StringTableClass struct { 22type StringTableClass struct {
23 Name string 23 Name string `json:"name"`
24 Data string 24 Data string `json:"data"`
25} 25}
26type StringTableEntry struct { 26type StringTableEntry struct {
27 Name string 27 Name string `json:"name"`
28 EntryData any 28 EntryData any `json:"entry_data"`
29} 29}
30 30
31func (stringTables *StringTables) ParseStringTables(reader *bitreader.Reader) { 31func (stringTables *StringTables) ParseStringTables(reader *bitreader.Reader, demo *types.Demo) {
32 stringTables.Size = reader.TryReadSInt32() 32 stringTables.Size = reader.TryReadSInt32()
33 stringTableReader := bitreader.NewReaderFromBytes(reader.TryReadBytesToSlice(uint64(stringTables.Size)), true) 33 stringTableReader := bitreader.NewReaderFromBytes(reader.TryReadBytesToSlice(uint64(stringTables.Size)), true)
34 tableCount := stringTableReader.TryReadBits(8) 34 tableCount := stringTableReader.TryReadBits(8)
35 tables := make([]StringTable, tableCount) 35 tables := make([]StringTable, tableCount)
36 for i := 0; i < int(tableCount); i++ { 36 for i := 0; i < int(tableCount); i++ {
37 var table StringTable 37 var table StringTable
38 table.ParseStream(stringTableReader) 38 table.ParseStream(stringTableReader, demo)
39 tables[i] = table 39 tables[i] = table
40 } 40 }
41 stringTables.Data = tables 41 stringTables.Data = tables
42} 42}
43 43
44func (stringTable *StringTable) ParseStream(reader *bitreader.Reader) { 44func (stringTable *StringTable) ParseStream(reader *bitreader.Reader, demo *types.Demo) {
45 stringTable.Name = reader.TryReadString() 45 stringTable.Name = reader.TryReadString()
46 entryCount := reader.TryReadBits(16) 46 entryCount := reader.TryReadBits(16)
47 writer.AppendLine("\tTable Name: %s", stringTable.Name) 47 demo.Writer.AppendLine("\tTable Name: %s", stringTable.Name)
48 stringTable.TableEntries = make([]StringTableEntry, entryCount) 48 stringTable.TableEntries = make([]StringTableEntry, entryCount)
49 49
50 for i := 0; i < int(entryCount); i++ { 50 for i := 0; i < int(entryCount); i++ {
51 var entry StringTableEntry 51 var entry StringTableEntry
52 entry.Parse(stringTable.Name, reader) 52 entry.Parse(stringTable.Name, reader, demo)
53 stringTable.TableEntries[i] = entry 53 stringTable.TableEntries[i] = entry
54 } 54 }
55 if entryCount != 0 { 55 if entryCount != 0 {
56 writer.AppendLine("\t\t%d Table Entries:", entryCount) 56 demo.Writer.AppendLine("\t\t%d Table Entries:", entryCount)
57 writer.AppendOutputFromTemp() 57 demo.Writer.AppendOutputFromTemp()
58 } else { 58 } else {
59 writer.AppendLine("\t\tNo Table Entries") 59 demo.Writer.AppendLine("\t\tNo Table Entries")
60 } 60 }
61 if reader.TryReadBool() { 61 if reader.TryReadBool() {
62 classCount := reader.TryReadBits(16) 62 classCount := reader.TryReadBits(16)
@@ -64,28 +64,28 @@ func (stringTable *StringTable) ParseStream(reader *bitreader.Reader) {
64 64
65 for i := 0; i < int(classCount); i++ { 65 for i := 0; i < int(classCount); i++ {
66 var class StringTableClass 66 var class StringTableClass
67 class.Parse(reader) 67 class.Parse(reader, demo)
68 stringTable.Classes[i] = class 68 stringTable.Classes[i] = class
69 } 69 }
70 writer.AppendLine("\t\t%d Classes:", classCount) 70 demo.Writer.AppendLine("\t\t%d Classes:", classCount)
71 writer.AppendOutputFromTemp() 71 demo.Writer.AppendOutputFromTemp()
72 } else { 72 } else {
73 writer.AppendLine("\t\tNo Class Entries") 73 demo.Writer.AppendLine("\t\tNo Class Entries")
74 } 74 }
75} 75}
76 76
77func (stringTableClass *StringTableClass) Parse(reader *bitreader.Reader) { 77func (stringTableClass *StringTableClass) Parse(reader *bitreader.Reader, demo *types.Demo) {
78 stringTableClass.Name = reader.TryReadString() 78 stringTableClass.Name = reader.TryReadString()
79 writer.TempAppendLine("\t\t\tName: %s", stringTableClass.Name) 79 demo.Writer.TempAppendLine("\t\t\tName: %s", stringTableClass.Name)
80 if reader.TryReadBool() { 80 if reader.TryReadBool() {
81 stringTableClass.Data = reader.TryReadStringLength(uint64(reader.TryReadUInt16())) 81 stringTableClass.Data = reader.TryReadStringLength(uint64(reader.TryReadUInt16()))
82 writer.TempAppendLine("\t\t\tData: %s", stringTableClass.Data) 82 demo.Writer.TempAppendLine("\t\t\tData: %s", stringTableClass.Data)
83 } 83 }
84} 84}
85 85
86func (stringTableEntry *StringTableEntry) Parse(tableName string, reader *bitreader.Reader) { 86func (stringTableEntry *StringTableEntry) Parse(tableName string, reader *bitreader.Reader, demo *types.Demo) {
87 stringTableEntry.Name = reader.TryReadString() 87 stringTableEntry.Name = reader.TryReadString()
88 writer.TempAppendLine("\t\t\tName: %s", stringTableEntry.Name) 88 demo.Writer.TempAppendLine("\t\t\tName: %s", stringTableEntry.Name)
89 if reader.TryReadBool() { 89 if reader.TryReadBool() {
90 byteLen, err := reader.ReadBits(16) 90 byteLen, err := reader.ReadBits(16)
91 if err != nil { 91 if err != nil {
@@ -94,30 +94,30 @@ func (stringTableEntry *StringTableEntry) Parse(tableName string, reader *bitrea
94 stringTableEntryReader := bitreader.NewReaderFromBytes(reader.TryReadBytesToSlice(byteLen), true) 94 stringTableEntryReader := bitreader.NewReaderFromBytes(reader.TryReadBytesToSlice(byteLen), true)
95 switch tableName { 95 switch tableName {
96 case StringTableUserInfo: 96 case StringTableUserInfo:
97 stringTableEntry.ParseUserInfo(stringTableEntryReader) 97 stringTableEntry.ParseUserInfo(stringTableEntryReader, demo)
98 case StringTableServerQueryInfo: 98 case StringTableServerQueryInfo:
99 stringTableEntry.ParseServerQueryInfo(stringTableEntryReader) 99 stringTableEntry.ParseServerQueryInfo(stringTableEntryReader, demo)
100 case StringTableGameRulesCreation: 100 case StringTableGameRulesCreation:
101 stringTableEntry.ParseGamesRulesCreation(stringTableEntryReader) 101 stringTableEntry.ParseGamesRulesCreation(stringTableEntryReader, demo)
102 case StringTableInfoPanel: 102 case StringTableInfoPanel:
103 stringTableEntry.ParseInfoPanel(stringTableEntryReader) 103 stringTableEntry.ParseInfoPanel(stringTableEntryReader, demo)
104 case StringTableLightStyles: 104 case StringTableLightStyles:
105 stringTableEntry.ParseLightStyles(stringTableEntryReader) 105 stringTableEntry.ParseLightStyles(stringTableEntryReader, demo)
106 case StringTableModelPreCache: 106 case StringTableModelPreCache:
107 stringTableEntry.ParsePrecacheData(stringTableEntryReader) 107 stringTableEntry.ParsePrecacheData(stringTableEntryReader, demo)
108 case StringTableGenericPreCache: 108 case StringTableGenericPreCache:
109 stringTableEntry.ParsePrecacheData(stringTableEntryReader) 109 stringTableEntry.ParsePrecacheData(stringTableEntryReader, demo)
110 case StringTableSoundPreCache: 110 case StringTableSoundPreCache:
111 stringTableEntry.ParsePrecacheData(stringTableEntryReader) 111 stringTableEntry.ParsePrecacheData(stringTableEntryReader, demo)
112 case StringTableDecalPreCache: 112 case StringTableDecalPreCache:
113 stringTableEntry.ParsePrecacheData(stringTableEntryReader) 113 stringTableEntry.ParsePrecacheData(stringTableEntryReader, demo)
114 default: 114 default:
115 stringTableEntry.ParseUnknown(stringTableEntryReader) 115 stringTableEntry.ParseUnknown(stringTableEntryReader, demo)
116 } 116 }
117 } 117 }
118} 118}
119 119
120func (stringTableEntry *StringTableEntry) ParseUserInfo(reader *bitreader.Reader) { 120func (stringTableEntry *StringTableEntry) ParseUserInfo(reader *bitreader.Reader, demo *types.Demo) {
121 const SignedGuidLen int32 = 32 121 const SignedGuidLen int32 = 32
122 const MaxPlayerNameLength int32 = 32 122 const MaxPlayerNameLength int32 = 32
123 userInfo := struct { 123 userInfo := struct {
@@ -147,48 +147,48 @@ func (stringTableEntry *StringTableEntry) ParseUserInfo(reader *bitreader.Reader
147 userInfo.FilesDownloaded = reader.TryReadUInt8() 147 userInfo.FilesDownloaded = reader.TryReadUInt8()
148 reader.SkipBytes(3) 148 reader.SkipBytes(3)
149 stringTableEntry.EntryData = userInfo 149 stringTableEntry.EntryData = userInfo
150 writer.TempAppendLine("\t\t\t\tSteam Account ID: %d", uint32((userInfo.SteamID&0xFFFFFFFF00000000)|userInfo.SteamID)) 150 demo.Writer.TempAppendLine("\t\t\t\tSteam Account ID: %d", uint32((userInfo.SteamID&0xFFFFFFFF00000000)|userInfo.SteamID))
151 writer.TempAppendLine("\t\t\t\tSteam Account Instance: %d", uint32(userInfo.SteamID>>32)&0x000FFFFF) 151 demo.Writer.TempAppendLine("\t\t\t\tSteam Account Instance: %d", uint32(userInfo.SteamID>>32)&0x000FFFFF)
152 writer.TempAppendLine("\t\t\t\tSteam Account Type: %d", uint32(userInfo.SteamID>>52)&0xF) 152 demo.Writer.TempAppendLine("\t\t\t\tSteam Account Type: %d", uint32(userInfo.SteamID>>52)&0xF)
153 writer.TempAppendLine("\t\t\t\tSteam Account Universe: %d", uint32(userInfo.SteamID>>56)&0xFF) 153 demo.Writer.TempAppendLine("\t\t\t\tSteam Account Universe: %d", uint32(userInfo.SteamID>>56)&0xFF)
154 writer.TempAppendLine("\t\t\t\tName: %s", userInfo.Name) 154 demo.Writer.TempAppendLine("\t\t\t\tName: %s", userInfo.Name)
155 writer.TempAppendLine("\t\t\t\tUser ID: %d", userInfo.UserID) 155 demo.Writer.TempAppendLine("\t\t\t\tUser ID: %d", userInfo.UserID)
156 writer.TempAppendLine("\t\t\t\tGUID: %s", userInfo.GUID) 156 demo.Writer.TempAppendLine("\t\t\t\tGUID: %s", userInfo.GUID)
157 writer.TempAppendLine("\t\t\t\tFriends ID: %d", userInfo.FriendsID) 157 demo.Writer.TempAppendLine("\t\t\t\tFriends ID: %d", userInfo.FriendsID)
158 writer.TempAppendLine("\t\t\t\tFriends Name: %s", userInfo.FriendsName) 158 demo.Writer.TempAppendLine("\t\t\t\tFriends Name: %s", userInfo.FriendsName)
159 writer.TempAppendLine("\t\t\t\tFake Player: %t", userInfo.FakePlayer) 159 demo.Writer.TempAppendLine("\t\t\t\tFake Player: %t", userInfo.FakePlayer)
160 writer.TempAppendLine("\t\t\t\tIs Htlv: %t", userInfo.IsHltv) 160 demo.Writer.TempAppendLine("\t\t\t\tIs Htlv: %t", userInfo.IsHltv)
161 if userInfo.CustomFiles != nil { 161 if userInfo.CustomFiles != nil {
162 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]) 162 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])
163 } 163 }
164 writer.TempAppendLine("\t\t\t\tFiles Downloaded: %d", userInfo.FilesDownloaded) 164 demo.Writer.TempAppendLine("\t\t\t\tFiles Downloaded: %d", userInfo.FilesDownloaded)
165} 165}
166 166
167func (stringTableEntry *StringTableEntry) ParseServerQueryInfo(reader *bitreader.Reader) { 167func (stringTableEntry *StringTableEntry) ParseServerQueryInfo(reader *bitreader.Reader, demo *types.Demo) {
168 serverQueryInfo := struct{ Port uint32 }{ 168 serverQueryInfo := struct{ Port uint32 }{
169 Port: reader.TryReadUInt32(), 169 Port: reader.TryReadUInt32(),
170 } 170 }
171 stringTableEntry.EntryData = serverQueryInfo 171 stringTableEntry.EntryData = serverQueryInfo
172 writer.TempAppendLine("\t\t\t\tPort: %d", serverQueryInfo.Port) 172 demo.Writer.TempAppendLine("\t\t\t\tPort: %d", serverQueryInfo.Port)
173} 173}
174 174
175func (stringTableEntry *StringTableEntry) ParseGamesRulesCreation(reader *bitreader.Reader) { 175func (stringTableEntry *StringTableEntry) ParseGamesRulesCreation(reader *bitreader.Reader, demo *types.Demo) {
176 gamesRulesCreation := struct{ Message string }{ 176 gamesRulesCreation := struct{ Message string }{
177 Message: reader.TryReadString(), 177 Message: reader.TryReadString(),
178 } 178 }
179 stringTableEntry.EntryData = gamesRulesCreation 179 stringTableEntry.EntryData = gamesRulesCreation
180 writer.TempAppendLine("\t\t\t\tMessage: %s", gamesRulesCreation.Message) 180 demo.Writer.TempAppendLine("\t\t\t\tMessage: %s", gamesRulesCreation.Message)
181} 181}
182 182
183func (stringTableEntry *StringTableEntry) ParseInfoPanel(reader *bitreader.Reader) { 183func (stringTableEntry *StringTableEntry) ParseInfoPanel(reader *bitreader.Reader, demo *types.Demo) {
184 infoPanel := struct{ Message string }{ 184 infoPanel := struct{ Message string }{
185 Message: reader.TryReadString(), 185 Message: reader.TryReadString(),
186 } 186 }
187 stringTableEntry.EntryData = infoPanel 187 stringTableEntry.EntryData = infoPanel
188 writer.TempAppendLine("\t\t\t\tMessage: %s", infoPanel.Message) 188 demo.Writer.TempAppendLine("\t\t\t\tMessage: %s", infoPanel.Message)
189} 189}
190 190
191func (stringTableEntry *StringTableEntry) ParseLightStyles(reader *bitreader.Reader) { 191func (stringTableEntry *StringTableEntry) ParseLightStyles(reader *bitreader.Reader, demo *types.Demo) {
192 lightStyles := struct{ Values []byte }{} 192 lightStyles := struct{ Values []byte }{}
193 str := reader.TryReadString() 193 str := reader.TryReadString()
194 if len(str) != 0 { 194 if len(str) != 0 {
@@ -199,13 +199,13 @@ func (stringTableEntry *StringTableEntry) ParseLightStyles(reader *bitreader.Rea
199 } 199 }
200 stringTableEntry.EntryData = lightStyles 200 stringTableEntry.EntryData = lightStyles
201 if lightStyles.Values == nil { 201 if lightStyles.Values == nil {
202 writer.TempAppendLine("\t\t\t\t0 Frames (256)") 202 demo.Writer.TempAppendLine("\t\t\t\t0 Frames (256)")
203 } else { 203 } else {
204 writer.TempAppendLine("\t\t\t\t%d frames: %v", len(lightStyles.Values), lightStyles.Values) 204 demo.Writer.TempAppendLine("\t\t\t\t%d frames: %v", len(lightStyles.Values), lightStyles.Values)
205 } 205 }
206} 206}
207 207
208func (stringTableEntry *StringTableEntry) ParsePrecacheData(reader *bitreader.Reader) { 208func (stringTableEntry *StringTableEntry) ParsePrecacheData(reader *bitreader.Reader, demo *types.Demo) {
209 type PrecacheFlag uint16 209 type PrecacheFlag uint16
210 const ( 210 const (
211 None PrecacheFlag = 0 211 None PrecacheFlag = 0
@@ -225,16 +225,16 @@ func (stringTableEntry *StringTableEntry) ParsePrecacheData(reader *bitreader.Re
225 } 225 }
226 return flagStrings 226 return flagStrings
227 } 227 }
228 writer.TempAppendLine("\t\t\t\tFlags: %v", getFlags(PrecacheFlag(precacheData.Flags))) 228 demo.Writer.TempAppendLine("\t\t\t\tFlags: %v", getFlags(PrecacheFlag(precacheData.Flags)))
229} 229}
230 230
231func (stringTableEntry *StringTableEntry) ParseUnknown(reader *bitreader.Reader) { 231func (stringTableEntry *StringTableEntry) ParseUnknown(reader *bitreader.Reader, demo *types.Demo) {
232 unknown := reader.TryReadBitsToSlice(reader.TryReadRemainingBits()) 232 unknown := reader.TryReadBitsToSlice(reader.TryReadRemainingBits())
233 binaryString := "" 233 binaryString := ""
234 for _, byteValue := range unknown { 234 for _, byteValue := range unknown {
235 binaryString += fmt.Sprintf("%08b ", byteValue) 235 binaryString += fmt.Sprintf("%08b ", byteValue)
236 } 236 }
237 writer.TempAppendLine("\t\t\t\tUnknown: (%s)", strings.TrimSpace(binaryString)) 237 demo.Writer.TempAppendLine("\t\t\t\tUnknown: (%s)", strings.TrimSpace(binaryString))
238} 238}
239 239
240const ( 240const (
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
2 2
3import ( 3import (
4 "github.com/pektezol/bitreader" 4 "github.com/pektezol/bitreader"
5 "github.com/pektezol/sdp.go/pkg/writer" 5 "github.com/pektezol/sdp.go/pkg/types"
6) 6)
7 7
8type UserCmd struct { 8type UserCmd struct {
9 Cmd uint32 9 Cmd uint32 `json:"cmd"`
10 Size uint32 10 Size uint32 `json:"size"`
11 Data UserCmdInfo 11 Data UserCmdInfo `json:"data"`
12} 12}
13 13
14type UserCmdInfo struct { 14type UserCmdInfo struct {
15 CommandNumber uint32 15 CommandNumber uint32 `json:"command_number"`
16 TickCount uint32 16 TickCount uint32 `json:"tick_count"`
17 ViewAnglesX float32 17 ViewAnglesX float32 `json:"view_angles_x"`
18 ViewAnglesY float32 18 ViewAnglesY float32 `json:"view_angles_y"`
19 ViewAnglesZ float32 19 ViewAnglesZ float32 `json:"view_angles_z"`
20 ForwardMove float32 20 ForwardMove float32 `json:"forward_move"`
21 SideMove float32 21 SideMove float32 `json:"side_move"`
22 UpMove float32 22 UpMove float32 `json:"up_move"`
23 Buttons uint32 23 Buttons uint32 `json:"buttons"`
24 Impulse uint8 24 Impulse uint8 `json:"impulse"`
25 WeaponSelect uint16 25 WeaponSelect uint16 `json:"weapon_select"`
26 WeaponSubType uint8 26 WeaponSubType uint8 `json:"weapon_sub_type"`
27 MouseDx uint16 27 MouseDx uint16 `json:"mouse_dx"`
28 MouseDy uint16 28 MouseDy uint16 `json:"mouse_dy"`
29} 29}
30 30
31func (userCmd *UserCmd) ParseUserCmd(reader *bitreader.Reader) { 31func (userCmd *UserCmd) ParseUserCmd(reader *bitreader.Reader, demo *types.Demo) {
32 userCmd.Cmd = reader.TryReadUInt32() 32 userCmd.Cmd = reader.TryReadUInt32()
33 userCmd.Size = reader.TryReadUInt32() 33 userCmd.Size = reader.TryReadUInt32()
34 userCmdReader := bitreader.NewReaderFromBytes(reader.TryReadBytesToSlice(uint64(userCmd.Size)), true) 34 userCmdReader := bitreader.NewReaderFromBytes(reader.TryReadBytesToSlice(uint64(userCmd.Size)), true)
35 userCmd.ParseUserCmdInfo(userCmdReader) 35 userCmd.ParseUserCmdInfo(userCmdReader, demo)
36} 36}
37 37
38func (userCmd *UserCmd) ParseUserCmdInfo(reader *bitreader.Reader) { 38func (userCmd *UserCmd) ParseUserCmdInfo(reader *bitreader.Reader, demo *types.Demo) {
39 if reader.TryReadBool() { 39 if reader.TryReadBool() {
40 userCmd.Data.CommandNumber = reader.TryReadUInt32() 40 userCmd.Data.CommandNumber = reader.TryReadUInt32()
41 } 41 }
@@ -78,14 +78,14 @@ func (userCmd *UserCmd) ParseUserCmdInfo(reader *bitreader.Reader) {
78 if reader.TryReadBool() { 78 if reader.TryReadBool() {
79 userCmd.Data.MouseDy = reader.TryReadUInt16() 79 userCmd.Data.MouseDy = reader.TryReadUInt16()
80 } 80 }
81 writer.AppendLine("\tCommand Number: %v", userCmd.Data.CommandNumber) 81 demo.Writer.AppendLine("\tCommand Number: %v", userCmd.Data.CommandNumber)
82 writer.AppendLine("\tTick Count: %v", userCmd.Data.TickCount) 82 demo.Writer.AppendLine("\tTick Count: %v", userCmd.Data.TickCount)
83 writer.AppendLine("\tView Angles: %v", []float32{userCmd.Data.ViewAnglesX, userCmd.Data.ViewAnglesY, userCmd.Data.ViewAnglesZ}) 83 demo.Writer.AppendLine("\tView Angles: %v", []float32{userCmd.Data.ViewAnglesX, userCmd.Data.ViewAnglesY, userCmd.Data.ViewAnglesZ})
84 writer.AppendLine("\tMovement: %v", []float32{userCmd.Data.ForwardMove, userCmd.Data.SideMove, userCmd.Data.UpMove}) 84 demo.Writer.AppendLine("\tMovement: %v", []float32{userCmd.Data.ForwardMove, userCmd.Data.SideMove, userCmd.Data.UpMove})
85 writer.AppendLine("\tButtons: %v", Buttons(userCmd.Data.Buttons).GetButtons()) 85 demo.Writer.AppendLine("\tButtons: %v", Buttons(userCmd.Data.Buttons).GetButtons())
86 writer.AppendLine("\tImpulse: %v", userCmd.Data.Impulse) 86 demo.Writer.AppendLine("\tImpulse: %v", userCmd.Data.Impulse)
87 writer.AppendLine("\tWeapon, Subtype: %v, %v", userCmd.Data.WeaponSelect, userCmd.Data.WeaponSubType) 87 demo.Writer.AppendLine("\tWeapon, Subtype: %v, %v", userCmd.Data.WeaponSelect, userCmd.Data.WeaponSubType)
88 writer.AppendLine("\tMouse Dx, Mouse Dy: %v, %v", userCmd.Data.MouseDx, userCmd.Data.MouseDy) 88 demo.Writer.AppendLine("\tMouse Dx, Mouse Dy: %v, %v", userCmd.Data.MouseDx, userCmd.Data.MouseDy)
89} 89}
90 90
91func (button Buttons) GetButtons() []string { 91func (button Buttons) GetButtons() []string {
generated by cgit v1.2.3 (git 2.39.1) at 2025-11-08 16:56:11 +0000