1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
|
package packets
import (
"github.com/pektezol/bitreader"
"github.com/pektezol/demoparser/pkg/classes"
"github.com/pektezol/demoparser/pkg/messages"
)
type PacketMessageInfo struct {
PacketType uint8
TickNumber int32
SlotNumber uint8
Data any
}
const MSSC int = 2
func ParsePackets(reader *bitreader.Reader) PacketMessageInfo {
packetType := reader.TryReadUInt8()
tickNumber := reader.TryReadSInt32()
slotNumber := reader.TryReadUInt8()
var packetData any
switch packetType {
case 1: // SignOn
signOn := SignOn{}
for count := 0; count < MSSC; count++ {
signOn.PacketInfo = append(signOn.PacketInfo, classes.ParseCmdInfo(reader))
}
signOn.InSequence = int32(reader.TryReadBits(32))
signOn.OutSequence = int32(reader.TryReadBits(32))
signOn.Size = int32(reader.TryReadSInt32())
data := reader.TryReadBytesToSlice(uint64(signOn.Size))
packetReader := bitreader.NewReaderFromBytes(data, true)
for {
messageType, err := packetReader.ReadBits(6)
if err != nil {
break
}
signOn.Data = append(signOn.Data, messages.ParseMessages(int(messageType), packetReader))
}
packetData = signOn
case 2: // Packet
packet := Packet{}
for count := 0; count < MSSC; count++ {
packet.PacketInfo = append(packet.PacketInfo, classes.ParseCmdInfo(reader))
}
packet.InSequence = int32(reader.TryReadBits(32))
packet.OutSequence = int32(reader.TryReadBits(32))
packet.Size = int32(reader.TryReadSInt32())
data := reader.TryReadBytesToSlice(uint64(packet.Size))
packetReader := bitreader.NewReaderFromBytes(data, true)
for {
messageType, err := packetReader.ReadBits(6)
if err != nil {
break
}
packet.Data = append(packet.Data, messages.ParseMessages(int(messageType), packetReader))
}
packetData = packet
case 3: // SyncTick
syncTick := SyncTick{}
packetData = syncTick
case 4: // ConsoleCmd
size := reader.TryReadSInt32()
consoleCmd := ConsoleCmd{
Size: int32(size),
Data: reader.TryReadStringLength(uint64(size)),
}
packetData = consoleCmd
case 5: // UserCmd TODO: usercmdinfo refactor
userCmd := UserCmd{}
userCmd.Cmd = int32(reader.TryReadSInt32())
userCmd.Size = int32(reader.TryReadSInt32())
data := reader.TryReadBytesToSlice(uint64(userCmd.Size))
userCmd.Data = classes.ParseUserCmdInfo(data)
packetData = userCmd
case 6: // DataTables TODO: prop stuff
dataTables := DataTables{}
dataTables.Size = int32(reader.TryReadSInt32())
data := reader.TryReadBytesToSlice(uint64(dataTables.Size))
dataTableReader := bitreader.NewReaderFromBytes(data, true)
count := 0
for dataTableReader.TryReadBool() {
count++
dataTables.SendTable = append(dataTables.SendTable, classes.ParseSendTable(dataTableReader))
}
numOfClasses := dataTableReader.TryReadBits(16)
for count = 0; count < int(numOfClasses); count++ {
dataTables.ServerClassInfo = append(dataTables.ServerClassInfo, classes.ParseServerClassInfo(dataTableReader, count, int(numOfClasses)))
}
packetData = dataTables
case 7: // Stop
stop := Stop{}
if reader.TryReadBool() {
stop.RemainingData = reader.TryReadBitsToSlice(uint64(reader.TryReadRemainingBits()))
}
packetData = stop
case 8: // CustomData
customData := CustomData{
Unknown: int32(reader.TryReadBits(32)),
Size: int32(reader.TryReadBits(32)),
}
if customData.Unknown != 0 || customData.Size == 8 {
// Not SAR data
customData.Data = string(reader.TryReadBytesToSlice(uint64(customData.Size)))
packetData = customData
break
}
// SAR data
sarData := classes.SarData{}
data := reader.TryReadBytesToSlice(uint64(customData.Size))
sarReader := bitreader.NewReaderFromBytes(data, true)
sarData.ParseSarData(sarReader)
packetData = sarData
case 9: // StringTables TODO: parsing string table data
stringTables := StringTables{
Size: int32(reader.TryReadSInt32()),
}
data := reader.TryReadBytesToSlice(uint64(stringTables.Size))
stringTableReader := bitreader.NewReaderFromBytes(data, true)
stringTables.Data = classes.ParseStringTables(stringTableReader)
packetData = stringTables
default: // invalid
panic("invalid packet type")
}
return PacketMessageInfo{
PacketType: packetType,
TickNumber: tickNumber,
SlotNumber: slotNumber,
Data: packetData,
}
}
|