another rewrite, v1.0.0

43 files changed, 1338 insertions, 0 deletions

diff --git a/pkg/classes/cmdInfo.go b/pkg/classes/cmdInfo.go
new file mode 100644
index 0000000..6e56c41
--- /dev/null
+++ b/pkg/classes/cmdInfo.go
@@ -0,0 +1,27 @@
+package classes
+
+import (
+        "github.com/pektezol/bitreader"
+)
+
+type CmdInfo struct {
+        Flags            int32
+        ViewOrigin       []float32
+        ViewAngles       []float32
+        LocalViewAngles  []float32
+        ViewOrigin2      []float32
+        ViewAngles2      []float32
+        LocalViewAngles2 []float32
+}
+
+func ParseCmdInfo(reader *bitreader.ReaderType) CmdInfo {
+        return CmdInfo{
+                Flags:            int32(reader.TryReadBits(32)),
+                ViewOrigin:       []float32{reader.TryReadFloat32(), reader.TryReadFloat32(), reader.TryReadFloat32()},
+                ViewAngles:       []float32{reader.TryReadFloat32(), reader.TryReadFloat32(), reader.TryReadFloat32()},
+                LocalViewAngles:  []float32{reader.TryReadFloat32(), reader.TryReadFloat32(), reader.TryReadFloat32()},
+                ViewOrigin2:      []float32{reader.TryReadFloat32(), reader.TryReadFloat32(), reader.TryReadFloat32()},
+                ViewAngles2:      []float32{reader.TryReadFloat32(), reader.TryReadFloat32(), reader.TryReadFloat32()},
+                LocalViewAngles2: []float32{reader.TryReadFloat32(), reader.TryReadFloat32(), reader.TryReadFloat32()},
+        }
+}
diff --git a/pkg/classes/sendTable.go b/pkg/classes/sendTable.go
new file mode 100644
index 0000000..4521464
--- /dev/null
+++ b/pkg/classes/sendTable.go
@@ -0,0 +1,106 @@
+package classes
+
+import (
+        "github.com/pektezol/bitreader"
+)
+
+type SendTable struct {
+        NeedsDecoder bool
+        NetTableName string
+        NumOfProps   int16
+        Props        []prop
+}
+
+type prop struct {
+        SendPropType  int8
+        SendPropName  string
+        SendPropFlags int32
+        Priority      int8
+        ExcludeDtName string
+        LowValue      float32
+        HighValue     float32
+        NumBits       int32
+        NumElements   int32
+}
+
+type sendPropFlag int
+
+const (
+        Unsigned sendPropFlag = iota
+        Coord
+        NoScale
+        RoundDown
+        RoundUp
+        Normal
+        Exclude
+        Xyze
+        InsideArray
+        ProxyAlwaysYes
+        IsVectorElem
+        Collapsible
+        CoordMp
+        CoordMpLp // low precision
+        CoordMpInt
+        CellCoord
+        CellCoordLp
+        CellCoordInt
+        ChangesOften
+)
+
+type sendPropType int
+
+const (
+        Int sendPropType = iota
+        Float
+        Vector3
+        Vector2
+        String
+        Array
+        DataTable
+)
+
+func ParseSendTable(reader *bitreader.ReaderType) SendTable {
+        sendTable := SendTable{
+                NeedsDecoder: reader.TryReadBool(),
+                NetTableName: reader.TryReadString(),
+                NumOfProps:   int16(reader.TryReadBits(10)),
+                // SendPropType:  int8(reader.TryReadBits(5)),
+                // SendPropName:  reader.TryReadString(),
+                // SendPropFlags: int16(reader.TryReadBits(16)),
+        }
+        if sendTable.NumOfProps < 0 {
+                return sendTable
+        }
+        for count := 0; count < int(sendTable.NumOfProps); count++ {
+                propType := int8(reader.TryReadBits(5))
+                if propType >= int8(7) {
+                        return sendTable
+                }
+                prop := prop{
+                        SendPropType:  propType,
+                        SendPropName:  reader.TryReadString(),
+                        SendPropFlags: int32(reader.TryReadBits(19)),
+                        Priority:      int8(reader.TryReadBits(8)),
+                }
+                if propType == int8(DataTable) || CheckBit(int64(prop.SendPropFlags), int(Exclude)) {
+                        prop.ExcludeDtName = reader.TryReadString()
+                } else {
+                        switch propType {
+                        case int8(String), int8(Int), int8(Float), int8(Vector3), int8(Vector2):
+                                prop.LowValue = reader.TryReadFloat32()
+                                prop.HighValue = reader.TryReadFloat32()
+                                prop.NumBits = int32(reader.TryReadBits(7))
+                        case int8(Array):
+                                prop.NumElements = int32(reader.TryReadBits(10))
+                        default:
+                                return sendTable
+                        }
+                }
+                sendTable.Props = append(sendTable.Props, prop)
+        }
+        return sendTable
+}
+
+func CheckBit(val int64, bit int) bool {
+        return (val & (int64(1) << bit)) != 0
+}
diff --git a/pkg/classes/serverClassInfo.go b/pkg/classes/serverClassInfo.go
new file mode 100644
index 0000000..c60dad1
--- /dev/null
+++ b/pkg/classes/serverClassInfo.go
@@ -0,0 +1,30 @@
+package classes
+
+import (
+        "github.com/pektezol/bitreader"
+)
+
+type ServerClassInfo struct {
+        ClassId       int16
+        ClassName     string
+        DataTableName string
+}
+
+func ParseServerClassInfo(reader *bitreader.ReaderType, count int, numOfClasses int) ServerClassInfo {
+        return ServerClassInfo{
+                ClassId:       int16(reader.TryReadBits(16)),
+                ClassName:     reader.TryReadString(),
+                DataTableName: reader.TryReadString(),
+        }
+}
+
+// func serverClassBits(numOfClasses int) int {
+//      return highestBitIndex(uint(numOfClasses)) + 1
+// }
+
+// func highestBitIndex(i uint) int {
+//      var j int
+//      for j = 31; j >= 0 && (i&(1<<j)) == 0; j-- {
+//      }
+//      return j
+// }
diff --git a/pkg/classes/stringTable.go b/pkg/classes/stringTable.go
new file mode 100644
index 0000000..c6709f5
--- /dev/null
+++ b/pkg/classes/stringTable.go
@@ -0,0 +1,82 @@
+package classes
+
+import (
+        "bytes"
+
+        "github.com/pektezol/bitreader"
+)
+
+type StringTable struct {
+        Name         string
+        TableEntries []StringTableEntry
+        Classes      []StringTableClass
+}
+
+type StringTableEntry struct {
+        Name      string
+        EntryData StringTableEntryData
+}
+
+type StringTableEntryData struct {
+        // TODO: Parse StringTableEntry
+}
+
+type StringTableClass struct {
+        Name string
+        Data string
+}
+
+func ParseStringTables(reader *bitreader.ReaderType) []StringTable {
+        tableCount := reader.TryReadBits(8)
+        stringTables := make([]StringTable, tableCount)
+        for i := 0; i < int(tableCount); i++ {
+                var table StringTable
+                table.ParseStream(reader)
+                stringTables[i] = table
+        }
+        return stringTables
+}
+
+func (stringTable *StringTable) ParseStream(reader *bitreader.ReaderType) {
+        stringTable.Name = reader.TryReadString()
+        entryCount := reader.TryReadBits(16)
+        stringTable.TableEntries = make([]StringTableEntry, entryCount)
+
+        for i := 0; i < int(entryCount); i++ {
+                var entry StringTableEntry
+                entry.Parse(reader)
+                stringTable.TableEntries[i] = entry
+        }
+
+        if reader.TryReadBool() {
+                classCount := reader.TryReadBits(16)
+                stringTable.Classes = make([]StringTableClass, classCount)
+
+                for i := 0; i < int(classCount); i++ {
+                        var class StringTableClass
+                        class.Parse(reader)
+                        stringTable.Classes[i] = class
+                }
+        }
+}
+
+func (stringTableEntry *StringTableEntry) Parse(reader *bitreader.ReaderType) {
+        stringTableEntry.Name = reader.TryReadString()
+        if reader.TryReadBool() {
+                byteLen, err := reader.ReadBits(16)
+                if err != nil {
+                        return
+                }
+                dataBsr := reader.TryReadBytesToSlice(int(byteLen))
+                _ = bitreader.Reader(bytes.NewReader(dataBsr), true) // TODO: Parse StringTableEntry
+                // stringTableEntry.EntryData.ParseStream(entryReader)
+        }
+}
+
+func (stringTableClass *StringTableClass) Parse(reader *bitreader.ReaderType) {
+        stringTableClass.Name = reader.TryReadString()
+        if reader.TryReadBool() {
+                dataLen := reader.TryReadBits(16)
+                stringTableClass.Data = reader.TryReadStringLen(int(dataLen))
+        }
+}
diff --git a/pkg/classes/userCmdInfo.go b/pkg/classes/userCmdInfo.go
new file mode 100644
index 0000000..a6d9091
--- /dev/null
+++ b/pkg/classes/userCmdInfo.go
@@ -0,0 +1,72 @@
+package classes
+
+import (
+        "bytes"
+
+        "github.com/pektezol/bitreader"
+)
+
+type UserCmdInfo struct {
+        CommandNumber int32
+        TickCount     int32
+        ViewAnglesX   float32
+        ViewAnglesY   float32
+        ViewAnglesZ   float32
+        ForwardMove   float32
+        SideMove      float32
+        UpMove        float32
+        Buttons       int32
+        Impulse       int8
+        WeaponSelect  int16
+        WeaponSubType int8
+        MouseDx       int16
+        MouseDy       int16
+}
+
+func ParseUserCmdInfo(data []byte) UserCmdInfo {
+        reader := bitreader.Reader(bytes.NewReader(data), true)
+        userCmdInfo := UserCmdInfo{}
+        if reader.TryReadBool() {
+                userCmdInfo.CommandNumber = int32(reader.TryReadBits(32))
+        }
+        if reader.TryReadBool() {
+                userCmdInfo.TickCount = int32(reader.TryReadBits(32))
+        }
+        if reader.TryReadBool() {
+                userCmdInfo.ViewAnglesX = reader.TryReadFloat32()
+        }
+        if reader.TryReadBool() {
+                userCmdInfo.ViewAnglesY = reader.TryReadFloat32()
+        }
+        if reader.TryReadBool() {
+                userCmdInfo.ViewAnglesZ = reader.TryReadFloat32()
+        }
+        if reader.TryReadBool() {
+                userCmdInfo.ForwardMove = reader.TryReadFloat32()
+        }
+        if reader.TryReadBool() {
+                userCmdInfo.SideMove = reader.TryReadFloat32()
+        }
+        if reader.TryReadBool() {
+                userCmdInfo.UpMove = reader.TryReadFloat32()
+        }
+        if reader.TryReadBool() {
+                userCmdInfo.Buttons = int32(reader.TryReadBits(32))
+        }
+        if reader.TryReadBool() {
+                userCmdInfo.Impulse = int8(reader.TryReadBits(8))
+        }
+        if reader.TryReadBool() {
+                userCmdInfo.WeaponSelect = int16(reader.TryReadBits(11))
+                if reader.TryReadBool() {
+                        userCmdInfo.WeaponSubType = int8(reader.TryReadBits(6))
+                }
+        }
+        if reader.TryReadBool() {
+                userCmdInfo.MouseDx = int16(reader.TryReadBits(16))
+        }
+        if reader.TryReadBool() {
+                userCmdInfo.MouseDy = int16(reader.TryReadBits(16))
+        }
+        return userCmdInfo
+}
diff --git a/pkg/messages/messages.go b/pkg/messages/messages.go
new file mode 100644
index 0000000..39f89e9
--- /dev/null
+++ b/pkg/messages/messages.go
@@ -0,0 +1,87 @@
+package messages
+
+import (
+        "fmt"
+        "reflect"
+
+        "github.com/pektezol/bitreader"
+        messages "github.com/pektezol/demoparser/pkg/messages/types"
+)
+
+func ParseMessages(messageType int, reader *bitreader.ReaderType) any {
+        var messageData any
+        switch messageType {
+        case 0:
+                messageData = messages.ParseNetNop(reader)
+        case 1:
+                messageData = messages.ParseNetDisconnect(reader)
+        case 2:
+                messageData = messages.ParseNetFile(reader)
+        case 3:
+                messageData = messages.ParseNetSplitScreenUser(reader)
+        case 4:
+                messageData = messages.ParseNetTick(reader)
+        case 5:
+                messageData = messages.ParseNetStringCmd(reader)
+        case 6:
+                messageData = messages.ParseNetSetConVar(reader)
+        case 7:
+                messageData = messages.ParseNetSignOnState(reader)
+        case 8:
+                messageData = messages.ParseSvcServerInfo(reader)
+        case 9:
+                messageData = messages.ParseSvcSendTable(reader)
+        case 10:
+                messageData = messages.ParseSvcClassInfo(reader)
+        case 11:
+                messageData = messages.ParseSvcSetPause(reader)
+        case 12:
+                messageData = messages.ParseSvcCreateStringTable(reader)
+        case 13:
+                messageData = messages.ParseSvcUpdateStringTable(reader)
+        case 14:
+                messageData = messages.ParseSvcVoiceInit(reader)
+        case 15:
+                messageData = messages.ParseSvcVoiceData(reader)
+        case 16:
+                messageData = messages.ParseSvcPrint(reader)
+        case 17:
+                messageData = messages.ParseSvcSounds(reader)
+        case 18:
+                messageData = messages.ParseSvcSetView(reader)
+        case 19:
+                messageData = messages.ParseSvcFixAngle(reader)
+        case 20:
+                messageData = messages.ParseSvcCrosshairAngle(reader)
+        case 21:
+                messageData = messages.ParseSvcBspDecal(reader)
+        case 22:
+                messageData = messages.ParseSvcSplitScreen(reader)
+        case 23:
+                messageData = messages.ParseSvcUserMessage(reader)
+        case 24:
+                messageData = messages.ParseSvcEntityMessage(reader)
+        case 25:
+                messageData = messages.ParseSvcGameEvent(reader)
+        case 26:
+                messageData = messages.ParseSvcPacketEntities(reader)
+        case 27:
+                messageData = messages.ParseSvcTempEntities(reader)
+        case 28:
+                messageData = messages.ParseSvcPrefetch(reader)
+        case 29:
+                messageData = messages.ParseSvcMenu(reader)
+        case 30:
+                messageData = messages.ParseSvcGameEventList(reader)
+        case 31:
+                messageData = messages.ParseSvcGetCvarValue(reader)
+        case 32:
+                messageData = messages.ParseSvcCmdKeyValues(reader)
+        case 33:
+                messageData = messages.ParseSvcPaintmapData(reader)
+        default:
+                return nil
+        }
+        fmt.Printf("\t\t(%d) %s:\n\t\t\t%+v\n", messageType, reflect.ValueOf(messageData).Type(), messageData)
+        return messageData
+}
diff --git a/pkg/messages/types/netDisconnect.go b/pkg/messages/types/netDisconnect.go
new file mode 100644
index 0000000..69d4a67
--- /dev/null
+++ b/pkg/messages/types/netDisconnect.go
@@ -0,0 +1,13 @@
+package messages
+
+import "github.com/pektezol/bitreader"
+
+type NetDisconnect struct {
+        Text string
+}
+
+func ParseNetDisconnect(reader *bitreader.ReaderType) NetDisconnect {
+        return NetDisconnect{
+                Text: reader.TryReadString(),
+        }
+}
diff --git a/pkg/messages/types/netFile.go b/pkg/messages/types/netFile.go
new file mode 100644
index 0000000..a41a0cf
--- /dev/null
+++ b/pkg/messages/types/netFile.go
@@ -0,0 +1,17 @@
+package messages
+
+import "github.com/pektezol/bitreader"
+
+type NetFile struct {
+        TransferId    int32
+        FileName      string
+        FileRequested bool
+}
+
+func ParseNetFile(reader *bitreader.ReaderType) NetFile {
+        return NetFile{
+                TransferId:    int32(reader.TryReadBits(32)),
+                FileName:      reader.TryReadString(),
+                FileRequested: reader.TryReadBool(),
+        }
+}
diff --git a/pkg/messages/types/netNop.go b/pkg/messages/types/netNop.go
new file mode 100644
index 0000000..33f8e25
--- /dev/null
+++ b/pkg/messages/types/netNop.go
@@ -0,0 +1,9 @@
+package messages
+
+import "github.com/pektezol/bitreader"
+
+type NetNop struct{}
+
+func ParseNetNop(reader *bitreader.ReaderType) NetNop {
+        return NetNop{}
+}
diff --git a/pkg/messages/types/netSetConVar.go b/pkg/messages/types/netSetConVar.go
new file mode 100644
index 0000000..08042ae
--- /dev/null
+++ b/pkg/messages/types/netSetConVar.go
@@ -0,0 +1,29 @@
+package messages
+
+import "github.com/pektezol/bitreader"
+
+type NetSetConVar struct {
+        Length  int8
+        ConVars []conVar
+}
+
+type conVar struct {
+        Name  string
+        Value string
+}
+
+func ParseNetSetConVar(reader *bitreader.ReaderType) NetSetConVar {
+        length := reader.TryReadBits(8)
+        convars := []conVar{}
+        for count := 0; count < int(length); count++ {
+                convar := conVar{
+                        Name:  reader.TryReadString(),
+                        Value: reader.TryReadString(),
+                }
+                convars = append(convars, convar)
+        }
+        return NetSetConVar{
+                Length:  int8(length),
+                ConVars: convars,
+        }
+}
diff --git a/pkg/messages/types/netSignOnState.go b/pkg/messages/types/netSignOnState.go
new file mode 100644
index 0000000..4609ff2
--- /dev/null
+++ b/pkg/messages/types/netSignOnState.go
@@ -0,0 +1,26 @@
+package messages
+
+import "github.com/pektezol/bitreader"
+
+type NetSignOnState struct {
+        SignOnState        int8
+        SpawnCount         int32
+        NumServerPlayers   int32
+        IdsLength          int32
+        PlayersNetworksIds []byte
+        MapNameLength      int32
+        MapName            string
+}
+
+func ParseNetSignOnState(reader *bitreader.ReaderType) NetSignOnState {
+        netSignOnState := NetSignOnState{
+                SignOnState:      int8(reader.TryReadBits(8)),
+                SpawnCount:       int32(reader.TryReadBits(32)),
+                NumServerPlayers: int32(reader.TryReadBits(32)),
+                IdsLength:        int32(reader.TryReadBits(32)),
+        }
+        netSignOnState.PlayersNetworksIds = reader.TryReadBytesToSlice(int(netSignOnState.IdsLength))
+        netSignOnState.MapNameLength = int32(reader.TryReadBits(32))
+        netSignOnState.MapName = reader.TryReadStringLen(int(netSignOnState.MapNameLength))
+        return netSignOnState
+}
diff --git a/pkg/messages/types/netSplitScreenUser.go b/pkg/messages/types/netSplitScreenUser.go
new file mode 100644
index 0000000..65e85f3
--- /dev/null
+++ b/pkg/messages/types/netSplitScreenUser.go
@@ -0,0 +1,13 @@
+package messages
+
+import "github.com/pektezol/bitreader"
+
+type NetSplitScreenUser struct {
+        Unknown bool
+}
+
+func ParseNetSplitScreenUser(reader *bitreader.ReaderType) NetSplitScreenUser {
+        return NetSplitScreenUser{
+                Unknown: reader.TryReadBool(),
+        }
+}
diff --git a/pkg/messages/types/netStringCmd.go b/pkg/messages/types/netStringCmd.go
new file mode 100644
index 0000000..158658e
--- /dev/null
+++ b/pkg/messages/types/netStringCmd.go
@@ -0,0 +1,13 @@
+package messages
+
+import "github.com/pektezol/bitreader"
+
+type NetStringCmd struct {
+        Command string
+}
+
+func ParseNetStringCmd(reader *bitreader.ReaderType) NetStringCmd {
+        return NetStringCmd{
+                Command: reader.TryReadString(),
+        }
+}
diff --git a/pkg/messages/types/netTick.go b/pkg/messages/types/netTick.go
new file mode 100644
index 0000000..e14f259
--- /dev/null
+++ b/pkg/messages/types/netTick.go
@@ -0,0 +1,17 @@
+package messages
+
+import "github.com/pektezol/bitreader"
+
+type NetTick struct {
+        Tick                      int32
+        HostFrameTime             int16
+        HostFrameTimeStdDeviation int16
+}
+
+func ParseNetTick(reader *bitreader.ReaderType) NetTick {
+        return NetTick{
+                Tick:                      int32(reader.TryReadBits(32)),
+                HostFrameTime:             int16(reader.TryReadBits(16) / 10e5),
+                HostFrameTimeStdDeviation: int16(reader.TryReadBits(16) / 10e5),
+        }
+}
diff --git a/pkg/messages/types/svcBspDecal.go b/pkg/messages/types/svcBspDecal.go
new file mode 100644
index 0000000..484497f
--- /dev/null
+++ b/pkg/messages/types/svcBspDecal.go
@@ -0,0 +1,61 @@
+package messages
+
+import (
+        "github.com/pektezol/bitreader"
+)
+
+type SvcBspDecal struct {
+        Pos               []vectorCoord
+        DecalTextureIndex int16
+        EntityIndex       int16
+        ModelIndex        int16
+        LowPriority       int8
+}
+
+type vectorCoord struct {
+        Value float32
+        Valid bool
+}
+
+func ParseSvcBspDecal(reader *bitreader.ReaderType) SvcBspDecal {
+        svcBspDecal := SvcBspDecal{
+                Pos:               readVectorCoords(reader),
+                DecalTextureIndex: int16(reader.TryReadBits(9)),
+        }
+        if reader.TryReadBool() {
+                svcBspDecal.EntityIndex = int16(reader.TryReadBits(11))
+                svcBspDecal.ModelIndex = int16(reader.TryReadBits(11))
+        }
+        svcBspDecal.LowPriority = int8(reader.TryReadBits(1))
+        return svcBspDecal
+}
+
+func readVectorCoords(reader *bitreader.ReaderType) []vectorCoord {
+        const COORD_INTEGER_BITS uint8 = 14
+        const COORD_FRACTIONAL_BITS uint8 = 5
+        const COORD_DENOMINATOR uint8 = 1 << COORD_FRACTIONAL_BITS
+        const COORD_RESOLUTION float32 = 1.0 / float32(COORD_DENOMINATOR)
+        readVectorCoord := func() float32 {
+                value := float32(0)
+                integer := reader.TryReadBits(1)
+                fraction := reader.TryReadBits(1)
+                if integer != 0 || fraction != 0 {
+                        sign := reader.TryReadBits(1)
+                        if integer != 0 {
+                                integer = reader.TryReadBits(int(COORD_INTEGER_BITS)) + 1
+                        }
+                        if fraction != 0 {
+                                fraction = reader.TryReadBits(int(COORD_FRACTIONAL_BITS))
+                        }
+                        value = float32(integer) + float32(fraction)*COORD_RESOLUTION
+                        if sign != 0 {
+                                value = -value
+                        }
+                }
+                return value
+        }
+        x := reader.TryReadBits(1)
+        y := reader.TryReadBits(1)
+        z := reader.TryReadBits(1)
+        return []vectorCoord{{Value: readVectorCoord(), Valid: x != 0}, {Value: readVectorCoord(), Valid: y != 0}, {Value: readVectorCoord(), Valid: z != 0}}
+}
diff --git a/pkg/messages/types/svcClassInfo.go b/pkg/messages/types/svcClassInfo.go
new file mode 100644
index 0000000..9f367d3
--- /dev/null
+++ b/pkg/messages/types/svcClassInfo.go
@@ -0,0 +1,40 @@
+package messages
+
+import (
+        "fmt"
+        "math"
+
+        "github.com/pektezol/bitreader"
+)
+
+type SvcClassInfo struct {
+        Length         int16
+        CreateOnClient bool
+        ServerClasses  []serverClass
+}
+
+type serverClass struct {
+        ClassId       int16
+        ClassName     string
+        DataTableName string
+}
+
+func ParseSvcClassInfo(reader *bitreader.ReaderType) SvcClassInfo {
+        svcClassInfo := SvcClassInfo{
+                Length:         int16(reader.TryReadBits(16)),
+                CreateOnClient: reader.TryReadBool(),
+        }
+        classes := []serverClass{}
+        if !svcClassInfo.CreateOnClient {
+                for count := 0; count < int(svcClassInfo.Length); count++ {
+                        fmt.Println(classes)
+                        classes = append(classes, serverClass{
+                                ClassId:       int16(reader.TryReadBits(int(math.Log2(float64(svcClassInfo.Length)) + 1))),
+                                ClassName:     reader.TryReadString(),
+                                DataTableName: reader.TryReadString(),
+                        })
+                }
+        }
+        svcClassInfo.ServerClasses = classes
+        return svcClassInfo
+}
diff --git a/pkg/messages/types/svcCmdKeyValues.go b/pkg/messages/types/svcCmdKeyValues.go
new file mode 100644
index 0000000..1c4d819
--- /dev/null
+++ b/pkg/messages/types/svcCmdKeyValues.go
@@ -0,0 +1,16 @@
+package messages
+
+import "github.com/pektezol/bitreader"
+
+type SvcCmdKeyValues struct {
+        Length int32
+        Data   []byte
+}
+
+func ParseSvcCmdKeyValues(reader *bitreader.ReaderType) SvcCmdKeyValues {
+        svcCmdKeyValues := SvcCmdKeyValues{
+                Length: int32(reader.TryReadBits(32)),
+        }
+        svcCmdKeyValues.Data = reader.TryReadBytesToSlice(int(svcCmdKeyValues.Length))
+        return svcCmdKeyValues
+}
diff --git a/pkg/messages/types/svcCreateStringTable.go b/pkg/messages/types/svcCreateStringTable.go
new file mode 100644
index 0000000..ed9e477
--- /dev/null
+++ b/pkg/messages/types/svcCreateStringTable.go
@@ -0,0 +1,36 @@
+package messages
+
+import (
+        "math"
+
+        "github.com/pektezol/bitreader"
+)
+
+type SvcCreateStringTable struct {
+        Name              string
+        MaxEntries        int16
+        NumEntries        int8
+        Length            int32
+        UserDataFixedSize bool
+        UserDataSize      int16
+        UserDataSizeBits  int8
+        Flags             int8
+        StringData        int
+}
+
+func ParseSvcCreateStringTable(reader *bitreader.ReaderType) SvcCreateStringTable {
+        svcCreateStringTable := SvcCreateStringTable{
+                Name:       reader.TryReadString(),
+                MaxEntries: int16(reader.TryReadBits(16)),
+        }
+        svcCreateStringTable.NumEntries = int8(reader.TryReadBits(int(math.Log2(float64(svcCreateStringTable.MaxEntries))) + 1))
+        svcCreateStringTable.Length = int32(reader.TryReadBits(20))
+        svcCreateStringTable.UserDataFixedSize = reader.TryReadBool()
+        if svcCreateStringTable.UserDataFixedSize {
+                svcCreateStringTable.UserDataSize = int16(reader.TryReadBits(12))
+                svcCreateStringTable.UserDataSizeBits = int8(reader.TryReadBits(4))
+        }
+        svcCreateStringTable.Flags = int8(reader.TryReadBits(2))
+        reader.SkipBits(int(svcCreateStringTable.Length)) // TODO: StringTable parsing
+        return svcCreateStringTable
+}
diff --git a/pkg/messages/types/svcCrosshairAngle.go b/pkg/messages/types/svcCrosshairAngle.go
new file mode 100644
index 0000000..cf18212
--- /dev/null
+++ b/pkg/messages/types/svcCrosshairAngle.go
@@ -0,0 +1,13 @@
+package messages
+
+import "github.com/pektezol/bitreader"
+
+type SvcCrosshairAngle struct {
+        Angle []int16
+}
+
+func ParseSvcCrosshairAngle(reader *bitreader.ReaderType) SvcCrosshairAngle {
+        return SvcCrosshairAngle{
+                Angle: []int16{int16(reader.TryReadBits(16)), int16(reader.TryReadBits(16)), int16(reader.TryReadBits(16))},
+        }
+}
diff --git a/pkg/messages/types/svcEntityMessage.go b/pkg/messages/types/svcEntityMessage.go
new file mode 100644
index 0000000..9726ced
--- /dev/null
+++ b/pkg/messages/types/svcEntityMessage.go
@@ -0,0 +1,20 @@
+package messages
+
+import "github.com/pektezol/bitreader"
+
+type SvcEntityMessage struct {
+        EntityIndex int16
+        ClassId     int16
+        Length      int16
+        Data        []byte
+}
+
+func ParseSvcEntityMessage(reader *bitreader.ReaderType) SvcEntityMessage {
+        svcEntityMessage := SvcEntityMessage{
+                EntityIndex: int16(reader.TryReadBits(11)),
+                ClassId:     int16(reader.TryReadBits(9)),
+                Length:      int16(reader.TryReadBits(11)),
+        }
+        svcEntityMessage.Data = reader.TryReadBitsToSlice(int(svcEntityMessage.Length))
+        return svcEntityMessage
+}
diff --git a/pkg/messages/types/svcFixAngle.go b/pkg/messages/types/svcFixAngle.go
new file mode 100644
index 0000000..56acf04
--- /dev/null
+++ b/pkg/messages/types/svcFixAngle.go
@@ -0,0 +1,15 @@
+package messages
+
+import "github.com/pektezol/bitreader"
+
+type SvcFixAngle struct {
+        Relative bool
+        Angle    []int16
+}
+
+func ParseSvcFixAngle(reader *bitreader.ReaderType) SvcFixAngle {
+        return SvcFixAngle{
+                Relative: reader.TryReadBool(),
+                Angle:    []int16{int16(reader.TryReadBits(16)), int16(reader.TryReadBits(16)), int16(reader.TryReadBits(16))},
+        }
+}
diff --git a/pkg/messages/types/svcGameEvent.go b/pkg/messages/types/svcGameEvent.go
new file mode 100644
index 0000000..6ee4d01
--- /dev/null
+++ b/pkg/messages/types/svcGameEvent.go
@@ -0,0 +1,16 @@
+package messages
+
+import "github.com/pektezol/bitreader"
+
+type SvcGameEvent struct {
+        Length int16
+        Data   []byte // TODO: GameEvent[]
+}
+
+func ParseSvcGameEvent(reader *bitreader.ReaderType) SvcGameEvent {
+        svcGameEvent := SvcGameEvent{
+                Length: int16(reader.TryReadBits(11)),
+        }
+        svcGameEvent.Data = reader.TryReadBitsToSlice(int(svcGameEvent.Length))
+        return svcGameEvent
+}
diff --git a/pkg/messages/types/svcGameEventList.go b/pkg/messages/types/svcGameEventList.go
new file mode 100644
index 0000000..b99ce28
--- /dev/null
+++ b/pkg/messages/types/svcGameEventList.go
@@ -0,0 +1,21 @@
+package messages
+
+import "github.com/pektezol/bitreader"
+
+type SvcGameEventList struct {
+        Events              int16
+        Length              int32
+        GameEventDescriptor []gameEventDescriptor
+}
+
+type gameEventDescriptor struct {
+}
+
+func ParseSvcGameEventList(reader *bitreader.ReaderType) SvcGameEventList {
+        svcGameEventList := SvcGameEventList{
+                Events: int16(reader.TryReadBits(9)),
+                Length: int32(reader.TryReadBits(20)),
+        }
+        reader.TryReadBitsToSlice(int(svcGameEventList.Length))
+        return svcGameEventList
+}
diff --git a/pkg/messages/types/svcGetCvarValue.go b/pkg/messages/types/svcGetCvarValue.go
new file mode 100644
index 0000000..aef5c8e
--- /dev/null
+++ b/pkg/messages/types/svcGetCvarValue.go
@@ -0,0 +1,16 @@
+package messages
+
+import "github.com/pektezol/bitreader"
+
+type SvcGetCvarValue struct {
+        Cookie   string
+        CvarName string
+}
+
+func ParseSvcGetCvarValue(reader *bitreader.ReaderType) SvcGetCvarValue {
+        svcGetCvarValue := SvcGetCvarValue{
+                Cookie:   reader.TryReadStringLen(4),
+                CvarName: reader.TryReadString(),
+        }
+        return svcGetCvarValue
+}
diff --git a/pkg/messages/types/svcMenu.go b/pkg/messages/types/svcMenu.go
new file mode 100644
index 0000000..d89f52c
--- /dev/null
+++ b/pkg/messages/types/svcMenu.go
@@ -0,0 +1,18 @@
+package messages
+
+import "github.com/pektezol/bitreader"
+
+type SvcMenu struct {
+        MenuType int16
+        Length   int32
+        Data     []byte
+}
+
+func ParseSvcMenu(reader *bitreader.ReaderType) SvcMenu {
+        svcMenu := SvcMenu{
+                MenuType: int16(reader.TryReadBits(16)),
+                Length:   int32(reader.TryReadBits(32)),
+        }
+        svcMenu.Data = reader.TryReadBitsToSlice(int(svcMenu.Length))
+        return svcMenu
+}
diff --git a/pkg/messages/types/svcPacketEntities.go b/pkg/messages/types/svcPacketEntities.go
new file mode 100644
index 0000000..b1c23e5
--- /dev/null
+++ b/pkg/messages/types/svcPacketEntities.go
@@ -0,0 +1,30 @@
+package messages
+
+import "github.com/pektezol/bitreader"
+
+type SvcPacketEntities struct {
+        MaxEntries      int16
+        IsDelta         bool
+        DeltaFrom       int32
+        BaseLine        bool
+        UpdatedEntries  int16
+        Length          int32
+        UpdatedBaseline bool
+        Data            []byte
+}
+
+func ParseSvcPacketEntities(reader *bitreader.ReaderType) SvcPacketEntities {
+        svcPacketEntities := SvcPacketEntities{
+                MaxEntries: int16(reader.TryReadBits(11)),
+                IsDelta:    reader.TryReadBool(),
+        }
+        if svcPacketEntities.IsDelta {
+                svcPacketEntities.DeltaFrom = int32(reader.TryReadBits(32))
+        }
+        svcPacketEntities.BaseLine = reader.TryReadBool()
+        svcPacketEntities.UpdatedEntries = int16(reader.TryReadBits(11))
+        svcPacketEntities.Length = int32(reader.TryReadBits(20))
+        svcPacketEntities.UpdatedBaseline = reader.TryReadBool()
+        svcPacketEntities.Data = reader.TryReadBitsToSlice(int(svcPacketEntities.Length))
+        return svcPacketEntities
+}
diff --git a/pkg/messages/types/svcPaintmapData.go b/pkg/messages/types/svcPaintmapData.go
new file mode 100644
index 0000000..6b041da
--- /dev/null
+++ b/pkg/messages/types/svcPaintmapData.go
@@ -0,0 +1,16 @@
+package messages
+
+import "github.com/pektezol/bitreader"
+
+type SvcPaintmapData struct {
+        Length int32
+        Data   []byte
+}
+
+func ParseSvcPaintmapData(reader *bitreader.ReaderType) SvcPaintmapData {
+        svcPaintmapData := SvcPaintmapData{
+                Length: int32(reader.TryReadBits(32)),
+        }
+        svcPaintmapData.Data = reader.TryReadBitsToSlice(int(svcPaintmapData.Length))
+        return svcPaintmapData
+}
diff --git a/pkg/messages/types/svcPrefetch.go b/pkg/messages/types/svcPrefetch.go
new file mode 100644
index 0000000..549f926
--- /dev/null
+++ b/pkg/messages/types/svcPrefetch.go
@@ -0,0 +1,13 @@
+package messages
+
+import "github.com/pektezol/bitreader"
+
+type SvcPrefetch struct {
+        SoundIndex int16
+}
+
+func ParseSvcPrefetch(reader *bitreader.ReaderType) SvcPrefetch {
+        return SvcPrefetch{
+                SoundIndex: int16(reader.TryReadBits(13)),
+        }
+}
diff --git a/pkg/messages/types/svcPrint.go b/pkg/messages/types/svcPrint.go
new file mode 100644
index 0000000..8aff927
--- /dev/null
+++ b/pkg/messages/types/svcPrint.go
@@ -0,0 +1,13 @@
+package messages
+
+import "github.com/pektezol/bitreader"
+
+type SvcPrint struct {
+        Message string
+}
+
+func ParseSvcPrint(reader *bitreader.ReaderType) SvcPrint {
+        return SvcPrint{
+                Message: reader.TryReadString(),
+        }
+}
diff --git a/pkg/messages/types/svcSendTable.go b/pkg/messages/types/svcSendTable.go
new file mode 100644
index 0000000..ae8960b
--- /dev/null
+++ b/pkg/messages/types/svcSendTable.go
@@ -0,0 +1,17 @@
+package messages
+
+import "github.com/pektezol/bitreader"
+
+type SvcSendTable struct {
+        NeedsDecoder int8
+        Length       int8
+        Props        int32
+}
+
+func ParseSvcSendTable(reader *bitreader.ReaderType) SvcSendTable {
+        return SvcSendTable{
+                NeedsDecoder: int8(reader.TryReadBits(8)),
+                Length:       int8(reader.TryReadBits(8)),
+                Props:        int32(reader.TryReadBits(32)),
+        }
+}
diff --git a/pkg/messages/types/svcServerInfo.go b/pkg/messages/types/svcServerInfo.go
new file mode 100644
index 0000000..b8bb308
--- /dev/null
+++ b/pkg/messages/types/svcServerInfo.go
@@ -0,0 +1,43 @@
+package messages
+
+import "github.com/pektezol/bitreader"
+
+type SvcServerInfo struct {
+        Protocol     int16
+        ServerCount  int32
+        IsHltv       bool
+        IsDedicated  bool
+        ClientCrc    int32
+        MaxClasses   int16
+        MapCrc       int32
+        PlayerSlot   int8
+        MaxClients   int8
+        Unk          int32
+        TickInterval int32
+        COs          int8
+        GameDir      string
+        MapName      string
+        SkyName      string
+        HostName     string
+}
+
+func ParseSvcServerInfo(reader *bitreader.ReaderType) SvcServerInfo {
+        return SvcServerInfo{
+                Protocol:     int16(reader.TryReadBits(16)),
+                ServerCount:  int32(reader.TryReadBits(32)),
+                IsHltv:       reader.TryReadBool(),
+                IsDedicated:  reader.TryReadBool(),
+                ClientCrc:    int32(reader.TryReadBits(32)),
+                MaxClasses:   int16(reader.TryReadBits(16)),
+                MapCrc:       int32(reader.TryReadBits(32)),
+                PlayerSlot:   int8(reader.TryReadBits(8)),
+                MaxClients:   int8(reader.TryReadBits(8)),
+                Unk:          int32(reader.TryReadBits(32)),
+                TickInterval: int32(reader.TryReadBits(32)),
+                COs:          int8(reader.TryReadBits(8)),
+                GameDir:      reader.TryReadString(),
+                MapName:      reader.TryReadString(),
+                SkyName:      reader.TryReadString(),
+                HostName:     reader.TryReadString(),
+        }
+}
diff --git a/pkg/messages/types/svcSetPause.go b/pkg/messages/types/svcSetPause.go
new file mode 100644
index 0000000..94303b7
--- /dev/null
+++ b/pkg/messages/types/svcSetPause.go
@@ -0,0 +1,13 @@
+package messages
+
+import "github.com/pektezol/bitreader"
+
+type SvcSetPause struct {
+        Paused bool
+}
+
+func ParseSvcSetPause(reader *bitreader.ReaderType) SvcSetPause {
+        return SvcSetPause{
+                Paused: reader.TryReadBool(),
+        }
+}
diff --git a/pkg/messages/types/svcSetView.go b/pkg/messages/types/svcSetView.go
new file mode 100644
index 0000000..70d1e2b
--- /dev/null
+++ b/pkg/messages/types/svcSetView.go
@@ -0,0 +1,13 @@
+package messages
+
+import "github.com/pektezol/bitreader"
+
+type SvcSetView struct {
+        EntityIndex int16
+}
+
+func ParseSvcSetView(reader *bitreader.ReaderType) SvcSetView {
+        return SvcSetView{
+                EntityIndex: int16(reader.TryReadBits(11)),
+        }
+}
diff --git a/pkg/messages/types/svcSounds.go b/pkg/messages/types/svcSounds.go
new file mode 100644
index 0000000..e87d584
--- /dev/null
+++ b/pkg/messages/types/svcSounds.go
@@ -0,0 +1,25 @@
+package messages
+
+import "github.com/pektezol/bitreader"
+
+type SvcSounds struct {
+        ReliableSound bool
+        Size          int8
+        Length        int16
+        Data          []byte
+}
+
+func ParseSvcSounds(reader *bitreader.ReaderType) SvcSounds {
+        svcSounds := SvcSounds{
+                ReliableSound: reader.TryReadBool(),
+        }
+        if svcSounds.ReliableSound {
+                svcSounds.Size = 1
+                svcSounds.Length = int16(reader.TryReadBits(8))
+        } else {
+                svcSounds.Size = int8(reader.TryReadBits(8))
+                svcSounds.Length = int16(reader.TryReadBits(16))
+        }
+        svcSounds.Data = reader.TryReadBitsToSlice(int(svcSounds.Length))
+        return svcSounds
+}
diff --git a/pkg/messages/types/svcSplitScreen.go b/pkg/messages/types/svcSplitScreen.go
new file mode 100644
index 0000000..9c808bc
--- /dev/null
+++ b/pkg/messages/types/svcSplitScreen.go
@@ -0,0 +1,18 @@
+package messages
+
+import "github.com/pektezol/bitreader"
+
+type SvcSplitScreen struct {
+        Unk    bool
+        Length int16
+        Data   []byte
+}
+
+func ParseSvcSplitScreen(reader *bitreader.ReaderType) SvcSplitScreen {
+        svcSplitScreen := SvcSplitScreen{
+                Unk:    reader.TryReadBool(),
+                Length: int16(reader.TryReadBits(11)),
+        }
+        svcSplitScreen.Data = reader.TryReadBitsToSlice(int(svcSplitScreen.Length))
+        return svcSplitScreen
+}
diff --git a/pkg/messages/types/svcTempEntities.go b/pkg/messages/types/svcTempEntities.go
new file mode 100644
index 0000000..d22423d
--- /dev/null
+++ b/pkg/messages/types/svcTempEntities.go
@@ -0,0 +1,18 @@
+package messages
+
+import "github.com/pektezol/bitreader"
+
+type SvcTempEntities struct {
+        NumEntries int8
+        Length     int32
+        Data       []byte
+}
+
+func ParseSvcTempEntities(reader *bitreader.ReaderType) SvcTempEntities {
+        svcTempEntities := SvcTempEntities{
+                NumEntries: int8(reader.TryReadBits(8)),
+                Length:     int32(reader.TryReadBits(17)),
+        }
+        svcTempEntities.Data = reader.TryReadBitsToSlice(int(svcTempEntities.Length))
+        return svcTempEntities
+}
diff --git a/pkg/messages/types/svcUpdateStringTable.go b/pkg/messages/types/svcUpdateStringTable.go
new file mode 100644
index 0000000..2840482
--- /dev/null
+++ b/pkg/messages/types/svcUpdateStringTable.go
@@ -0,0 +1,22 @@
+package messages
+
+import "github.com/pektezol/bitreader"
+
+type SvcUpdateStringTable struct {
+        TableId           int8
+        NumChangedEntries int16
+        Length            int32
+        Data              []byte
+}
+
+func ParseSvcUpdateStringTable(reader *bitreader.ReaderType) SvcUpdateStringTable {
+        svcUpdateStringTable := SvcUpdateStringTable{
+                TableId: int8(reader.TryReadBits(5)),
+        }
+        if reader.TryReadBool() {
+                svcUpdateStringTable.NumChangedEntries = int16(reader.TryReadBits(16))
+        }
+        svcUpdateStringTable.Length = int32(reader.TryReadBits(20))
+        svcUpdateStringTable.Data = reader.TryReadBitsToSlice(int(svcUpdateStringTable.Length))
+        return svcUpdateStringTable
+}
diff --git a/pkg/messages/types/svcUserMessage.go b/pkg/messages/types/svcUserMessage.go
new file mode 100644
index 0000000..b53c7c0
--- /dev/null
+++ b/pkg/messages/types/svcUserMessage.go
@@ -0,0 +1,18 @@
+package messages
+
+import "github.com/pektezol/bitreader"
+
+type SvcUserMessage struct {
+        MsgType int8
+        Length  int16
+        Data    []byte
+}
+
+func ParseSvcUserMessage(reader *bitreader.ReaderType) SvcUserMessage {
+        svcUserMessage := SvcUserMessage{
+                MsgType: int8(reader.TryReadBits(8)),
+                Length:  int16(reader.TryReadBits(12)),
+        }
+        svcUserMessage.Data = reader.TryReadBitsToSlice(int(svcUserMessage.Length))
+        return svcUserMessage
+}
diff --git a/pkg/messages/types/svcVoiceData.go b/pkg/messages/types/svcVoiceData.go
new file mode 100644
index 0000000..b6c81d4
--- /dev/null
+++ b/pkg/messages/types/svcVoiceData.go
@@ -0,0 +1,20 @@
+package messages
+
+import "github.com/pektezol/bitreader"
+
+type SvcVoiceData struct {
+        Client    int8
+        Proximity int8
+        Length    int16
+        Data      []byte
+}
+
+func ParseSvcVoiceData(reader *bitreader.ReaderType) SvcVoiceData {
+        svcVoiceData := SvcVoiceData{
+                Client:    int8(reader.TryReadBits(8)),
+                Proximity: int8(reader.TryReadBits(8)),
+                Length:    int16(reader.TryReadBits(16)),
+        }
+        svcVoiceData.Data = reader.TryReadBitsToSlice(int(svcVoiceData.Length))
+        return svcVoiceData
+}
diff --git a/pkg/messages/types/svcVoiceInit.go b/pkg/messages/types/svcVoiceInit.go
new file mode 100644
index 0000000..4c95aab
--- /dev/null
+++ b/pkg/messages/types/svcVoiceInit.go
@@ -0,0 +1,20 @@
+package messages
+
+import "github.com/pektezol/bitreader"
+
+type SvcVoiceInit struct {
+        Codec   string
+        Quality uint8
+        Unk     float32
+}
+
+func ParseSvcVoiceInit(reader *bitreader.ReaderType) SvcVoiceInit {
+        svcVoiceInit := SvcVoiceInit{
+                Codec:   reader.TryReadString(),
+                Quality: uint8(reader.TryReadBits(8)),
+        }
+        if svcVoiceInit.Quality == 0b11111111 {
+                svcVoiceInit.Unk = reader.TryReadFloat32()
+        }
+        return svcVoiceInit
+}
diff --git a/pkg/packets/headers.go b/pkg/packets/headers.go
new file mode 100644
index 0000000..543476b
--- /dev/null
+++ b/pkg/packets/headers.go
@@ -0,0 +1,48 @@
+package packets
+
+import (
+        "fmt"
+
+        "github.com/pektezol/bitreader"
+)
+
+type Headers struct {
+        DemoFileStamp   string
+        DemoProtocol    int32
+        NetworkProtocol int32
+        ServerName      string
+        ClientName      string
+        MapName         string
+        GameDirectory   string
+        PlaybackTime    float32
+        PlaybackTicks   int32
+        PlaybackFrames  int32
+        SignOnLength    int32
+}
+
+func ParseHeaders(reader *bitreader.ReaderType) Headers {
+        headers := Headers{
+                DemoFileStamp:   reader.TryReadString(),
+                DemoProtocol:    int32(reader.TryReadInt32()),
+                NetworkProtocol: int32(reader.TryReadInt32()),
+                ServerName:      reader.TryReadStringLen(260),
+                ClientName:      reader.TryReadStringLen(260),
+                MapName:         reader.TryReadStringLen(260),
+                GameDirectory:   reader.TryReadStringLen(260),
+                PlaybackTime:    reader.TryReadFloat32(),
+                PlaybackTicks:   int32(reader.TryReadInt32()),
+                PlaybackFrames:  int32(reader.TryReadInt32()),
+                SignOnLength:    int32(reader.TryReadInt32()),
+        }
+        if headers.DemoFileStamp != "HL2DEMO" {
+                panic("invalid demo file stamp")
+        }
+        if headers.DemoProtocol != 4 {
+                panic("this parser only supports demos from new engine")
+        }
+        if headers.NetworkProtocol != 2001 {
+                panic("this parser only supports demos from portal 2")
+        }
+        fmt.Printf("Headers: %+v\n", headers)
+        return headers
+}
diff --git a/pkg/packets/packets.go b/pkg/packets/packets.go
new file mode 100644
index 0000000..a84da21
--- /dev/null
+++ b/pkg/packets/packets.go
@@ -0,0 +1,125 @@
+package packets
+
+import (
+        "bytes"
+
+        "github.com/pektezol/bitreader"
+        "github.com/pektezol/demoparser/pkg/classes"
+        "github.com/pektezol/demoparser/pkg/messages"
+)
+
+type PacketMessageInfo struct {
+        PacketType int8
+        TickNumber int32
+        SlotNumber int8
+        Data       any
+}
+
+const MSSC = 2
+
+func ParsePackets(reader *bitreader.ReaderType) PacketMessageInfo {
+        packetType := reader.TryReadBits(8)
+        tickNumber := reader.TryReadBits(32)
+        slotNumber := reader.TryReadBits(8)
+        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.TryReadInt32())
+                data := reader.TryReadBytesToSlice(int(signOn.Size))
+                packetReader := bitreader.Reader(bytes.NewReader(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.TryReadInt32())
+                data := reader.TryReadBytesToSlice(int(packet.Size))
+                packetReader := bitreader.Reader(bytes.NewReader(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.TryReadInt32()
+                consoleCmd := ConsoleCmd{
+                        Size: int32(size),
+                        Data: reader.TryReadStringLen(int(size)),
+                }
+                packetData = consoleCmd
+        case 5: // UserCmd
+                userCmd := UserCmd{}
+                userCmd.Cmd = int32(reader.TryReadInt32())
+                userCmd.Size = int32(reader.TryReadInt32())
+                data := reader.TryReadBytesToSlice(int(userCmd.Size))
+                userCmd.Data = classes.ParseUserCmdInfo(data)
+                packetData = userCmd
+        case 6: // DataTables
+                dataTables := DataTables{}
+                dataTables.Size = int32(reader.TryReadInt32())
+                data := reader.TryReadBytesToSlice(int(dataTables.Size))
+                dataTableReader := bitreader.Reader(bytes.NewReader(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() {
+                        // read remaining data
+                        stop.RemainingData = []byte{}
+                }
+                packetData = stop
+        case 8: // CustomData
+                customData := CustomData{
+                        Unknown: int32(reader.TryReadBits(32)),
+                        Size:    int32(reader.TryReadBits(32)),
+                }
+                customData.Data = string(reader.TryReadBytesToSlice(int(customData.Size)))
+                packetData = customData
+        case 9: // StringTables
+                stringTables := StringTables{
+                        Size: int32(reader.TryReadInt32()),
+                }
+                data := reader.TryReadBytesToSlice(int(stringTables.Size))
+                stringTableReader := bitreader.Reader(bytes.NewReader(data), true)
+                stringTables.Data = classes.ParseStringTables(stringTableReader)
+                packetData = stringTables
+        default: // invalid
+                panic("invalid packet type")
+        }
+        return PacketMessageInfo{
+                PacketType: int8(packetType),
+                TickNumber: int32(tickNumber),
+                SlotNumber: int8(slotNumber),
+                Data:       packetData,
+        }
+}
diff --git a/pkg/packets/types.go b/pkg/packets/types.go
new file mode 100644
index 0000000..6297b01
--- /dev/null
+++ b/pkg/packets/types.go
@@ -0,0 +1,53 @@
+package packets
+
+import "github.com/pektezol/demoparser/pkg/classes"
+
+type SignOn struct {
+        PacketInfo  []classes.CmdInfo
+        InSequence  int32
+        OutSequence int32
+        Size        int32
+        Data        []any
+}
+
+type Packet struct {
+        PacketInfo  []classes.CmdInfo
+        InSequence  int32
+        OutSequence int32
+        Size        int32
+        Data        []any
+}
+
+type SyncTick struct{}
+
+type ConsoleCmd struct {
+        Size int32
+        Data string
+}
+
+type UserCmd struct {
+        Cmd  int32
+        Size int32
+        Data classes.UserCmdInfo
+}
+
+type DataTables struct {
+        Size            int32
+        SendTable       []classes.SendTable
+        ServerClassInfo []classes.ServerClassInfo
+}
+
+type Stop struct {
+        RemainingData []byte
+}
+
+type CustomData struct {
+        Unknown int32
+        Size    int32
+        Data    string
+}
+
+type StringTables struct {
+        Size int32
+        Data []classes.StringTable
+}