aboutsummaryrefslogtreecommitdiff
path: root/pkg/classes/sarData.go
diff options
context:
space:
mode:
authorArda Serdar Pektezol <1669855+pektezol@users.noreply.github.com>2023-11-06 18:37:11 +0300
committerArda Serdar Pektezol <1669855+pektezol@users.noreply.github.com>2023-11-06 18:37:11 +0300
commit2f8c92f261586f68a976efce0cfcdd0401f402e0 (patch)
tree33189cc48987789dff4e7fba0a74d2b2326f0a04 /pkg/classes/sarData.go
parentconvert cm ticks correctly (diff)
downloadsdp.go-2f8c92f261586f68a976efce0cfcdd0401f402e0.tar.gz
sdp.go-2f8c92f261586f68a976efce0cfcdd0401f402e0.tar.bz2
sdp.go-2f8c92f261586f68a976efce0cfcdd0401f402e0.zip
dont try to understand it, feel itlp-parser
Diffstat (limited to 'pkg/classes/sarData.go')
-rw-r--r--pkg/classes/sarData.go403
1 files changed, 0 insertions, 403 deletions
diff --git a/pkg/classes/sarData.go b/pkg/classes/sarData.go
deleted file mode 100644
index 9c61304..0000000
--- a/pkg/classes/sarData.go
+++ /dev/null
@@ -1,403 +0,0 @@
1package classes
2
3import (
4 "errors"
5 "fmt"
6
7 "github.com/pektezol/bitreader"
8)
9
10type SarDataType uint8
11
12const (
13 ESarDataTimescaleCheat SarDataType = 0x01
14 ESarDataInitialCVar SarDataType = 0x02
15 ESarDataEntityInput SarDataType = 0x03
16 ESarDataEntityInputSlot SarDataType = 0x04
17 ESarDataPortalPlacement SarDataType = 0x05
18 ESarDataChallengeFlags SarDataType = 0x06
19 ESarDataCrouchFly SarDataType = 0x07
20 ESarDataPause SarDataType = 0x08
21 ESarDataWaitRun SarDataType = 0x09
22 ESarDataSpeedrunTime SarDataType = 0x0A
23 ESarDataTimestamp SarDataType = 0x0B
24 ESarDataFileChecksum SarDataType = 0x0C
25 ESarDataHWaitRun SarDataType = 0x0D
26 ESarDataChecksum SarDataType = 0xFF
27 ESarDataChecksumV2 SarDataType = 0xFE
28 ESarDataInvalid SarDataType = iota
29)
30
31func (sarDataType SarDataType) String() string {
32 switch sarDataType {
33 case ESarDataTimescaleCheat:
34 return "SarDataTimescaleCheat"
35 case ESarDataInitialCVar:
36 return "SarDataInitialCVar"
37 case ESarDataEntityInput:
38 return "SarDataEntityInput"
39 case ESarDataEntityInputSlot:
40 return "SarDataEntityInputSlot"
41 case ESarDataPortalPlacement:
42 return "SarDataPortalPlacement"
43 case ESarDataChallengeFlags:
44 return "SarDataChallengeFlags"
45 case ESarDataCrouchFly:
46 return "SarDataCrouchFly"
47 case ESarDataPause:
48 return "SarDataPause"
49 case ESarDataWaitRun:
50 return "SarDataWaitRun"
51 case ESarDataSpeedrunTime:
52 return "SarDataSpeedrunTime"
53 case ESarDataTimestamp:
54 return "SarDataTimestamp"
55 case ESarDataFileChecksum:
56 return "SarDataFileChecksum"
57 case ESarDataHWaitRun:
58 return "SarDataHWaitRun"
59 case ESarDataChecksum:
60 return "SarDataChecksum"
61 case ESarDataChecksumV2:
62 return "SarDataChecksumV2"
63 case ESarDataInvalid:
64 return "SarDataInvalid"
65 default:
66 return fmt.Sprintf("%d", int(sarDataType))
67 }
68}
69
70type SarData struct {
71 Type SarDataType
72 Slot int
73 Data any
74}
75
76type SarDataTimescaleCheat struct {
77 Timescale float32
78}
79
80type SarDataInitialCVar struct {
81 CVar string
82 Val string
83}
84
85type SarDataChecksum struct {
86 DemoSum uint32
87 SarSum uint32
88}
89
90type SarDataChecksumV2 struct {
91 SarSum uint32
92 Signature [64]byte
93}
94
95type SarDataEntityInput struct {
96 TargetName string
97 ClassName string
98 InputName string
99 Parameter string
100}
101
102type SarDataPortalPlacement struct {
103 Orange bool
104 X float32
105 Y float32
106 Z float32
107}
108
109type SarDataPause struct {
110 PauseTicks uint32
111}
112
113type SarDataWaitRun struct {
114 Ticks int
115 Cmd string
116}
117
118type SarDataHWaitRun struct {
119 Ticks int
120 Cmd string
121}
122
123type SarDataSpeedrunTime struct {
124 NSplits uint32
125 Splits []SarDataSpeedrunTimeSplits
126}
127
128type SarDataSpeedrunTimeSegs struct {
129 Name string
130 Ticks uint32
131}
132
133type SarDataSpeedrunTimeSplits struct {
134 Name string
135 NSegs uint32
136 Segs []SarDataSpeedrunTimeSegs
137}
138
139type SarDataTimestamp struct {
140 Year uint16
141 Month uint8
142 Day uint8
143 Hour uint8
144 Minute uint8
145 Second uint8
146}
147
148type SarDataFileChecksum struct {
149 Sum uint32
150 Path string
151}
152
153func (sarData *SarData) ParseSarData(reader *bitreader.Reader) (err error) {
154 reader.SkipBytes(8)
155 len := reader.TryReadRemainingBits() / 8
156 if len == 0 {
157 sarData.Type = ESarDataInvalid
158 err = errors.New("sar data invalid")
159 return err
160 }
161 sarData.Type = SarDataType(reader.TryReadBytes(1))
162 if sarData.Type == ESarDataChecksum && len == 5 {
163 len = 9
164 }
165 dataReader := bitreader.NewReaderFromBytes(reader.TryReadBytesToSlice(len-1), true)
166 switch sarData.Type {
167 case ESarDataTimescaleCheat:
168 sarData.Data, err = parseTimescaleCheatData(dataReader, len)
169 if err != nil {
170 sarData.Data = nil
171 }
172 case ESarDataInitialCVar:
173 sarData.Data = parseInitialCVarData(dataReader)
174 case ESarDataEntityInputSlot:
175 sarData.Slot = int(dataReader.TryReadBytes(1))
176 case ESarDataEntityInput:
177 sarData.Data = parseEntityInputData(dataReader)
178 case ESarDataChecksum:
179 sarData.Data, err = parseChecksumData(dataReader, len)
180 if err != nil {
181 sarData.Data = nil
182 }
183 case ESarDataChecksumV2:
184 sarData.Data, err = parseChecksumV2Data(dataReader, len)
185 if err != nil {
186 sarData.Data = nil
187 }
188 case ESarDataPortalPlacement:
189 data, slot, err := parsePortalPlacementData(dataReader, len)
190 if err != nil {
191 sarData.Data = nil
192 } else {
193 sarData.Data = data
194 sarData.Slot = slot
195 }
196 case ESarDataChallengeFlags, ESarDataCrouchFly:
197 sarData.Slot, err = parseChallengeFlagsCrouchFlyData(dataReader, len)
198 if err != nil {
199 sarData.Data = nil
200 }
201
202 case ESarDataPause:
203 sarData.Data, err = parsePauseData(dataReader, len)
204 if err != nil {
205 sarData.Data = nil
206 }
207 case ESarDataWaitRun:
208 sarData.Data, err = parseWaitRunData(dataReader, len)
209 if err != nil {
210 sarData.Data = nil
211 }
212 case ESarDataHWaitRun:
213 sarData.Data, err = parseHWaitRunData(dataReader, len)
214 if err != nil {
215 sarData.Data = nil
216 }
217 case ESarDataSpeedrunTime:
218 sarData.Data, err = parseSpeedrunTimeData(dataReader, len)
219 if err != nil {
220 sarData.Data = nil
221 }
222 case ESarDataTimestamp:
223 sarData.Data, err = parseTimestampData(dataReader, len)
224 if err != nil {
225 sarData.Data = nil
226 }
227 case ESarDataFileChecksum:
228 sarData.Data, err = parseFileChecksumData(dataReader, len)
229 if err != nil {
230 sarData.Data = nil
231 }
232 default:
233 err = errors.New("unsupported SAR data type")
234 return err
235 }
236 return nil
237}
238
239func parseTimescaleCheatData(reader *bitreader.Reader, length uint64) (SarDataTimescaleCheat, error) {
240 if length != 5 {
241 return SarDataTimescaleCheat{}, errors.New("sar data invalid")
242 }
243 sarDataTimescaleCheat := SarDataTimescaleCheat{
244 Timescale: reader.TryReadFloat32(),
245 }
246
247 return sarDataTimescaleCheat, nil
248}
249
250func parseInitialCVarData(reader *bitreader.Reader) SarDataInitialCVar {
251 sarDataInitialCvar := SarDataInitialCVar{
252 CVar: reader.TryReadString(),
253 Val: reader.TryReadString(),
254 }
255
256 return sarDataInitialCvar
257}
258
259func parseEntityInputData(reader *bitreader.Reader) SarDataEntityInput {
260 sarDataEntityInput := SarDataEntityInput{
261 TargetName: reader.TryReadString(),
262 ClassName: reader.TryReadString(),
263 InputName: reader.TryReadString(),
264 Parameter: reader.TryReadString(),
265 }
266
267 return sarDataEntityInput
268}
269
270func parseChecksumData(reader *bitreader.Reader, length uint64) (SarDataChecksum, error) {
271 if length != 9 {
272 return SarDataChecksum{}, errors.New("sar data invalid")
273 }
274 sarDataChecksum := SarDataChecksum{
275 DemoSum: reader.TryReadUInt32(),
276 SarSum: reader.TryReadUInt32(),
277 }
278
279 return sarDataChecksum, nil
280}
281
282func parseChecksumV2Data(reader *bitreader.Reader, length uint64) (SarDataChecksumV2, error) {
283 if length != 69 {
284 return SarDataChecksumV2{}, errors.New("sar data invalid")
285 }
286 sarDataChecksumV2 := SarDataChecksumV2{
287 SarSum: reader.TryReadUInt32(),
288 Signature: [64]byte(reader.TryReadBytesToSlice(60)),
289 }
290
291 return sarDataChecksumV2, nil
292}
293
294func parsePortalPlacementData(reader *bitreader.Reader, length uint64) (SarDataPortalPlacement, int, error) {
295 if length != 15 {
296 return SarDataPortalPlacement{}, 0, errors.New("sar data invalid")
297 }
298 slot := int(reader.TryReadBytes(1))
299 orange := reader.TryReadBool()
300 reader.SkipBits(7)
301 sarDataPortalPlacement := SarDataPortalPlacement{
302 Orange: orange,
303 X: reader.TryReadFloat32(),
304 Y: reader.TryReadFloat32(),
305 Z: reader.TryReadFloat32(),
306 }
307
308 return sarDataPortalPlacement, slot, nil
309}
310
311func parseChallengeFlagsCrouchFlyData(reader *bitreader.Reader, length uint64) (int, error) {
312 if length != 2 {
313 return 0, errors.New("sar data invalid")
314 }
315 return int(reader.TryReadBytes(1)), nil
316}
317
318func parsePauseData(reader *bitreader.Reader, length uint64) (SarDataPause, error) {
319 if length != 5 {
320 return SarDataPause{}, errors.New("sar data invalid")
321 }
322 sarDataPause := SarDataPause{
323 PauseTicks: reader.TryReadUInt32(),
324 }
325
326 return sarDataPause, nil
327}
328
329func parseWaitRunData(reader *bitreader.Reader, length uint64) (SarDataWaitRun, error) {
330 if length < 6 {
331 return SarDataWaitRun{}, errors.New("sar data invalid")
332 }
333 sarDataWaitRun := SarDataWaitRun{
334 Ticks: int(reader.TryReadUInt32()),
335 Cmd: reader.TryReadString(),
336 }
337
338 return sarDataWaitRun, nil
339}
340
341func parseHWaitRunData(reader *bitreader.Reader, length uint64) (SarDataHWaitRun, error) {
342 if length < 6 {
343 return SarDataHWaitRun{}, errors.New("sar data invalid")
344 }
345 sarDataHWaitRun := SarDataHWaitRun{
346 Ticks: int(reader.TryReadUInt32()),
347 Cmd: reader.TryReadString(),
348 }
349
350 return sarDataHWaitRun, nil
351}
352
353func parseSpeedrunTimeData(reader *bitreader.Reader, length uint64) (SarDataSpeedrunTime, error) {
354 if length < 5 {
355 return SarDataSpeedrunTime{}, errors.New("sar data invalid")
356 }
357 numberOfSplits := reader.TryReadUInt32()
358 splits := make([]SarDataSpeedrunTimeSplits, numberOfSplits)
359 for splitCount := 0; splitCount < int(numberOfSplits); splitCount++ {
360 splits[splitCount].Name = reader.TryReadString()
361 splits[splitCount].NSegs = reader.TryReadUInt32()
362
363 splits[splitCount].Segs = make([]SarDataSpeedrunTimeSegs, splits[splitCount].NSegs)
364 for segCount := 0; segCount < int(splits[splitCount].NSegs); segCount++ {
365 splits[splitCount].Segs[segCount].Name = reader.TryReadString()
366 splits[splitCount].Segs[segCount].Ticks = reader.TryReadUInt32()
367
368 }
369 }
370 return SarDataSpeedrunTime{
371 NSplits: numberOfSplits,
372 Splits: splits,
373 }, nil
374}
375
376func parseTimestampData(reader *bitreader.Reader, length uint64) (SarDataTimestamp, error) {
377 if length != 8 {
378 return SarDataTimestamp{}, errors.New("sar data invalid")
379 }
380 timestamp := reader.TryReadBytesToSlice(7)
381 sarDataTimeStamp := SarDataTimestamp{
382 Year: uint16(timestamp[0]) | uint16(timestamp[1])<<8,
383 Month: timestamp[2] + 1,
384 Day: timestamp[3],
385 Hour: timestamp[4],
386 Minute: timestamp[5],
387 Second: timestamp[6],
388 }
389
390 return sarDataTimeStamp, nil
391}
392
393func parseFileChecksumData(reader *bitreader.Reader, length uint64) (SarDataFileChecksum, error) {
394 if length < 6 {
395 return SarDataFileChecksum{}, errors.New("sar data invalid")
396 }
397 sarDataFileChecksum := SarDataFileChecksum{
398 Sum: reader.TryReadUInt32(),
399 Path: reader.TryReadString(),
400 }
401
402 return sarDataFileChecksum, nil
403}
generated by cgit v1.2.3 (git 2.39.1) at 2025-11-08 19:13:01 +0000