aboutsummaryrefslogtreecommitdiff
path: root/pkg/classes/sarData.go
diff options
context:
space:
mode:
Diffstat (limited to 'pkg/classes/sarData.go')
-rw-r--r--pkg/classes/sarData.go196
1 files changed, 98 insertions, 98 deletions
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}
generated by cgit v1.2.3 (git 2.39.1) at 2025-11-08 14:51:38 +0000