From 44eefefe67a4a5f514faa4594370346fd1b54996 Mon Sep 17 00:00:00 2001
From: Arda Serdar Pektezol <1669855+pektezol@users.noreply.github.com>
Date: Thu, 21 Sep 2023 19:26:40 +0300
Subject: organize packets and classes (#9)

---
 README.md                      |  18 ++-
 pkg/classes/cmdInfo.go         |  63 -----------
 pkg/classes/consoleCmd.go      |  19 ++++
 pkg/classes/customData.go      |  30 +++++
 pkg/classes/dataTables.go      | 245 +++++++++++++++++++++++++++++++++++++++++
 pkg/classes/packet.go          |  90 +++++++++++++++
 pkg/classes/sendTable.go       | 194 --------------------------------
 pkg/classes/serverClassInfo.go |  33 ------
 pkg/classes/signOn.go          |  52 +++++++++
 pkg/classes/stop.go            |  17 +++
 pkg/classes/stringTable.go     |  93 ----------------
 pkg/classes/stringTables.go    | 100 +++++++++++++++++
 pkg/classes/syncTick.go        |   5 +
 pkg/classes/userCmd.go         | 231 ++++++++++++++++++++++++++++++++++++++
 pkg/classes/userCmdInfo.go     |  87 ---------------
 pkg/messages/messages.go       |   2 +-
 pkg/packets/packets.go         | 125 ++++-----------------
 pkg/packets/types.go           |  53 ---------
 18 files changed, 824 insertions(+), 633 deletions(-)
 delete mode 100644 pkg/classes/cmdInfo.go
 create mode 100644 pkg/classes/consoleCmd.go
 create mode 100644 pkg/classes/customData.go
 create mode 100644 pkg/classes/dataTables.go
 create mode 100644 pkg/classes/packet.go
 delete mode 100644 pkg/classes/sendTable.go
 delete mode 100644 pkg/classes/serverClassInfo.go
 create mode 100644 pkg/classes/signOn.go
 create mode 100644 pkg/classes/stop.go
 delete mode 100644 pkg/classes/stringTable.go
 create mode 100644 pkg/classes/stringTables.go
 create mode 100644 pkg/classes/syncTick.go
 create mode 100644 pkg/classes/userCmd.go
 delete mode 100644 pkg/classes/userCmdInfo.go
 delete mode 100644 pkg/packets/types.go

diff --git a/README.md b/README.md
index e446603..b916ac1 100644
--- a/README.md
+++ b/README.md
@@ -2,20 +2,28 @@
 
 Work-In-Progress demo parser for Portal 2 written in Golang.
 
-Usage:
+## Couldn't Do This Without Them
+
+- [@UncraftedName](https://github.com/UncraftedName): For [UntitledParser](https://github.com/UncraftedName/UntitledParser)
+- [@NeKzor](https://github.com/NeKzor): For [nekz.me/dem](https://nekz.me/dem)
+
+## Usage
 
 ```bash
 $ ./parser demo.dem
 ```
 
-Currently supports:
+## Currently Supports
 
 - File or folder input using the CLI.
 - Basic parsing of demo headers each message type.
 - Basic parsing of packet classes.
 - Custom injected SAR data parsing.
 
-TODO:
+## TODO
+
+- StringTableEntry parsing. ([#8][i8])
+- In-depth packet class parsing for each class. ([#7][i7])
 
-- StringTableEntry parsing.
-- In-depth packet class parsing for each class.
+[i8]: https://github.com/pektezol/DemoParser/issues/8
+[i7]: https://github.com/pektezol/DemoParser/issues/7
\ No newline at end of file
diff --git a/pkg/classes/cmdInfo.go b/pkg/classes/cmdInfo.go
deleted file mode 100644
index eccfe99..0000000
--- a/pkg/classes/cmdInfo.go
+++ /dev/null
@@ -1,63 +0,0 @@
-package classes
-
-import (
-	"fmt"
-
-	"github.com/pektezol/bitreader"
-	"github.com/pektezol/demoparser/pkg/writer"
-)
-
-type CmdInfo struct {
-	Flags            string
-	ViewOrigin       []float32
-	ViewAngles       []float32
-	LocalViewAngles  []float32
-	ViewOrigin2      []float32
-	ViewAngles2      []float32
-	LocalViewAngles2 []float32
-}
-
-type CmdInfoFlags int
-
-const (
-	ECmdInfoFlagsNone        = 0
-	ECmdInfoFlagsUseOrigin2  = 1
-	ECmdInfoFlagsUserAngles2 = 1 << 1
-	ECmdInfoFlagsNoInterp    = 1 << 2
-)
-
-func (cmdInfoFlags CmdInfoFlags) String() string {
-	switch cmdInfoFlags {
-	case ECmdInfoFlagsNone:
-		return "None"
-	case ECmdInfoFlagsUseOrigin2:
-		return "UseOrigin2"
-	case ECmdInfoFlagsUserAngles2:
-		return "UserAngles2"
-	case ECmdInfoFlagsNoInterp:
-		return "NoInterp"
-	default:
-		return fmt.Sprintf("%d", int(cmdInfoFlags))
-	}
-}
-
-func ParseCmdInfo(reader *bitreader.Reader) CmdInfo {
-	cmdInfo := CmdInfo{
-		Flags:            CmdInfoFlags(reader.TryReadUInt32()).String(),
-		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()},
-	}
-	writer.AppendLine("\tFlags: %s", cmdInfo.Flags)
-	writer.AppendLine("\tView Origin: %v", cmdInfo.ViewOrigin)
-	writer.AppendLine("\tView Angles: %v", cmdInfo.ViewAngles)
-	writer.AppendLine("\tLocal View Angles: %v", cmdInfo.LocalViewAngles)
-	writer.AppendLine("\tView Origin 2: %v", cmdInfo.ViewOrigin2)
-	writer.AppendLine("\tView Angles 2: %v", cmdInfo.ViewAngles2)
-	writer.AppendLine("\tLocal View Angles 2: %v", cmdInfo.LocalViewAngles2)
-	writer.AppendLine("")
-	return cmdInfo
-}
diff --git a/pkg/classes/consoleCmd.go b/pkg/classes/consoleCmd.go
new file mode 100644
index 0000000..75a56eb
--- /dev/null
+++ b/pkg/classes/consoleCmd.go
@@ -0,0 +1,19 @@
+package classes
+
+import (
+	"strings"
+
+	"github.com/pektezol/bitreader"
+	"github.com/pektezol/demoparser/pkg/writer"
+)
+
+type ConsoleCmd struct {
+	Size int32
+	Data string
+}
+
+func (consoleCmd *ConsoleCmd) ParseConsoleCmd(reader *bitreader.Reader) {
+	consoleCmd.Size = reader.TryReadSInt32()
+	consoleCmd.Data = reader.TryReadStringLength(uint64(consoleCmd.Size))
+	writer.AppendLine("\t%s", strings.TrimSpace(consoleCmd.Data))
+}
diff --git a/pkg/classes/customData.go b/pkg/classes/customData.go
new file mode 100644
index 0000000..2dadde4
--- /dev/null
+++ b/pkg/classes/customData.go
@@ -0,0 +1,30 @@
+package classes
+
+import (
+	"github.com/pektezol/bitreader"
+	"github.com/pektezol/demoparser/pkg/writer"
+)
+
+type CustomData struct {
+	Type int32
+	Size int32
+	Data string
+}
+
+func (customData *CustomData) ParseCustomData(reader *bitreader.Reader, tickNumber int32, packetType uint8) {
+	customData.Type = reader.TryReadSInt32()
+	customData.Size = reader.TryReadSInt32()
+	if customData.Type != 0 || customData.Size == 8 {
+		// Not SAR data
+		writer.AppendLine("[%d] %s (%d):", tickNumber, "CUSTOMDATA", packetType)
+		customData.Data = string(reader.TryReadBytesToSlice(uint64(customData.Size)))
+		writer.AppendLine("\t%s", customData.Data)
+		return
+	}
+	// SAR data
+	writer.AppendLine("[%d] %s (%d):", tickNumber, "SARDATA", packetType)
+	sarData := SarData{}
+	data := reader.TryReadBytesToSlice(uint64(customData.Size))
+	sarReader := bitreader.NewReaderFromBytes(data, true)
+	sarData.ParseSarData(sarReader)
+}
diff --git a/pkg/classes/dataTables.go b/pkg/classes/dataTables.go
new file mode 100644
index 0000000..27ab9e4
--- /dev/null
+++ b/pkg/classes/dataTables.go
@@ -0,0 +1,245 @@
+package classes
+
+import (
+	"fmt"
+
+	"github.com/pektezol/bitreader"
+	"github.com/pektezol/demoparser/pkg/writer"
+)
+
+type DataTables struct {
+	Size            int32
+	SendTable       []SendTable
+	ServerClassInfo []ServerClassInfo
+}
+
+type SendTable struct {
+	NeedsDecoder bool
+	NetTableName string
+	NumOfProps   int16
+	Props        []prop
+}
+
+type ServerClassInfo struct {
+	ClassId       uint16
+	ClassName     string
+	DataTableName string
+}
+
+type prop struct {
+	SendPropType  sendPropType
+	SendPropName  string
+	SendPropFlags uint32
+	Priority      uint8
+	ExcludeDtName string
+	LowValue      float32
+	HighValue     float32
+	NumBits       int32
+	NumElements   int32
+}
+
+func (dataTables *DataTables) ParseDataTables(reader *bitreader.Reader) {
+	dataTables.Size = int32(reader.TryReadSInt32())
+	dataTableReader := bitreader.NewReaderFromBytes(reader.TryReadBytesToSlice(uint64(dataTables.Size)), true)
+	count := 0
+	for dataTableReader.TryReadBool() {
+		count++
+		dataTables.SendTable = append(dataTables.SendTable, ParseSendTable(dataTableReader))
+	}
+	writer.AppendLine("\t%d Send Tables:", count)
+	writer.AppendOutputFromTemp()
+	numOfClasses := dataTableReader.TryReadBits(16)
+	for count = 0; count < int(numOfClasses); count++ {
+		dataTables.ServerClassInfo = append(dataTables.ServerClassInfo, ParseServerClassInfo(dataTableReader, count, int(numOfClasses)))
+	}
+	writer.AppendLine("\t%d Classes:", count)
+	writer.AppendOutputFromTemp()
+}
+
+func ParseSendTable(reader *bitreader.Reader) SendTable {
+	sendTable := SendTable{
+		NeedsDecoder: reader.TryReadBool(),
+		NetTableName: reader.TryReadString(),
+		NumOfProps:   int16(reader.TryReadBits(10)),
+	}
+	if sendTable.NumOfProps < 0 {
+		return sendTable
+	}
+	writer.TempAppendLine("\t\t%s (%d Props):", sendTable.NetTableName, sendTable.NumOfProps)
+	for count := 0; count < int(sendTable.NumOfProps); count++ {
+		propType := int8(reader.TryReadBits(5))
+		if propType >= int8(7) {
+			return sendTable
+		}
+		prop := prop{
+			SendPropType:  sendPropType(propType),
+			SendPropName:  reader.TryReadString(),
+			SendPropFlags: uint32(reader.TryReadBits(19)),
+			Priority:      reader.TryReadUInt8(),
+		}
+		writer.TempAppend("\t\t\t%s\t", prop.SendPropType)
+		if propType == int8(ESendPropTypeDataTable) || checkBit(prop.SendPropFlags, 6) {
+			prop.ExcludeDtName = reader.TryReadString()
+			writer.TempAppend(":\t%s\t", prop.ExcludeDtName)
+		} else {
+			switch propType {
+			case int8(ESendPropTypeString), int8(ESendPropTypeInt), int8(ESendPropTypeFloat), int8(ESendPropTypeVector3), int8(ESendPropTypeVector2):
+				prop.LowValue = reader.TryReadFloat32()
+				prop.HighValue = reader.TryReadFloat32()
+				prop.NumBits = int32(reader.TryReadBits(7))
+				writer.TempAppend("Low: %f\tHigh: %f\t%d bits\t", prop.LowValue, prop.HighValue, prop.NumBits)
+			case int8(ESendPropTypeArray):
+				prop.NumElements = int32(reader.TryReadBits(10))
+				writer.TempAppend("Elements: %d\t", prop.NumElements)
+			default:
+				writer.TempAppend("Unknown Prop Type: %v\t", propType)
+				return sendTable
+			}
+		}
+		writer.TempAppend("Flags: %v\tPriority: %d\n", prop.GetFlags(), prop.Priority)
+		sendTable.Props = append(sendTable.Props, prop)
+	}
+	return sendTable
+}
+
+func ParseServerClassInfo(reader *bitreader.Reader, count int, numOfClasses int) ServerClassInfo {
+	serverClassInfo := ServerClassInfo{
+		ClassId:       reader.TryReadUInt16(),
+		ClassName:     reader.TryReadString(),
+		DataTableName: reader.TryReadString(),
+	}
+	writer.TempAppendLine("\t\t\t[%d] %s (%s)", serverClassInfo.ClassId, serverClassInfo.ClassName, serverClassInfo.DataTableName)
+	return serverClassInfo
+}
+
+// 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
+// }
+
+func checkBit(val uint32, bit int) bool {
+	return (val & (uint32(1) << bit)) != 0
+}
+
+type sendPropType int
+
+const (
+	ESendPropTypeInt sendPropType = iota
+	ESendPropTypeFloat
+	ESendPropTypeVector3
+	ESendPropTypeVector2
+	ESendPropTypeString
+	ESendPropTypeArray
+	ESendPropTypeDataTable
+)
+
+const (
+	ESendPropFlagUnsigned       string = "Unsigned"
+	ESendPropFlagCoord          string = "Coord"
+	ESendPropFlagNoScale        string = "NoScale"
+	ESendPropFlagRoundDown      string = "RoundDown"
+	ESendPropFlagRoundUp        string = "RoundUp"
+	ESendPropFlagNormal         string = "Normal"
+	ESendPropFlagExclude        string = "Exclude"
+	ESendPropFlagXyze           string = "Xyze"
+	ESendPropFlagInsideArray    string = "InsideArray"
+	ESendPropFlagProxyAlwaysYes string = "ProxyAlwaysYes"
+	ESendPropFlagIsVectorElem   string = "IsVectorElem"
+	ESendPropFlagCollapsible    string = "Collapsible"
+	ESendPropFlagCoordMp        string = "CoordMp"
+	ESendPropFlagCoordMpLp      string = "CoordMpLp"
+	ESendPropFlagCoordMpInt     string = "CoordMpInt"
+	ESendPropFlagCellCoord      string = "CellCoord"
+	ESendPropFlagCellCoordLp    string = "CellCoordLp"
+	ESendPropFlagCellCoordInt   string = "CellCoordInt"
+	ESendPropFlagChangesOften   string = "ChangesOften"
+)
+
+func (prop prop) GetFlags() []string {
+	flags := []string{}
+	if checkBit(prop.SendPropFlags, 0) {
+		flags = append(flags, ESendPropFlagUnsigned)
+	}
+	if checkBit(prop.SendPropFlags, 1) {
+		flags = append(flags, ESendPropFlagCoord)
+	}
+	if checkBit(prop.SendPropFlags, 2) {
+		flags = append(flags, ESendPropFlagNoScale)
+	}
+	if checkBit(prop.SendPropFlags, 3) {
+		flags = append(flags, ESendPropFlagRoundDown)
+	}
+	if checkBit(prop.SendPropFlags, 4) {
+		flags = append(flags, ESendPropFlagRoundUp)
+	}
+	if checkBit(prop.SendPropFlags, 5) {
+		flags = append(flags, ESendPropFlagNormal)
+	}
+	if checkBit(prop.SendPropFlags, 6) {
+		flags = append(flags, ESendPropFlagExclude)
+	}
+	if checkBit(prop.SendPropFlags, 7) {
+		flags = append(flags, ESendPropFlagXyze)
+	}
+	if checkBit(prop.SendPropFlags, 8) {
+		flags = append(flags, ESendPropFlagInsideArray)
+	}
+	if checkBit(prop.SendPropFlags, 9) {
+		flags = append(flags, ESendPropFlagProxyAlwaysYes)
+	}
+	if checkBit(prop.SendPropFlags, 10) {
+		flags = append(flags, ESendPropFlagIsVectorElem)
+	}
+	if checkBit(prop.SendPropFlags, 11) {
+		flags = append(flags, ESendPropFlagCollapsible)
+	}
+	if checkBit(prop.SendPropFlags, 12) {
+		flags = append(flags, ESendPropFlagCoordMp)
+	}
+	if checkBit(prop.SendPropFlags, 13) {
+		flags = append(flags, ESendPropFlagCoordMpLp)
+	}
+	if checkBit(prop.SendPropFlags, 14) {
+		flags = append(flags, ESendPropFlagCoordMpInt)
+	}
+	if checkBit(prop.SendPropFlags, 15) {
+		flags = append(flags, ESendPropFlagCellCoord)
+	}
+	if checkBit(prop.SendPropFlags, 16) {
+		flags = append(flags, ESendPropFlagCellCoordLp)
+	}
+	if checkBit(prop.SendPropFlags, 17) {
+		flags = append(flags, ESendPropFlagCellCoordInt)
+	}
+	if checkBit(prop.SendPropFlags, 18) {
+		flags = append(flags, ESendPropFlagChangesOften)
+	}
+	return flags
+}
+
+func (sendPropType sendPropType) String() string {
+	switch sendPropType {
+	case ESendPropTypeInt:
+		return "Int"
+	case ESendPropTypeFloat:
+		return "Float"
+	case ESendPropTypeVector3:
+		return "Vector3"
+	case ESendPropTypeVector2:
+		return "Vector2"
+	case ESendPropTypeString:
+		return "String"
+	case ESendPropTypeArray:
+		return "Array"
+	case ESendPropTypeDataTable:
+		return "DataTable"
+	default:
+		return fmt.Sprintf("%d", int(sendPropType))
+	}
+}
diff --git a/pkg/classes/packet.go b/pkg/classes/packet.go
new file mode 100644
index 0000000..0bba102
--- /dev/null
+++ b/pkg/classes/packet.go
@@ -0,0 +1,90 @@
+package classes
+
+import (
+	"fmt"
+
+	"github.com/pektezol/bitreader"
+	"github.com/pektezol/demoparser/pkg/messages"
+	"github.com/pektezol/demoparser/pkg/writer"
+)
+
+const MSSC int = 2
+
+type Packet struct {
+	PacketInfo  []CmdInfo
+	InSequence  uint32
+	OutSequence uint32
+	Size        uint32
+	Data        []any
+}
+
+type CmdInfo struct {
+	Flags            uint32
+	ViewOrigin       []float32
+	ViewAngles       []float32
+	LocalViewAngles  []float32
+	ViewOrigin2      []float32
+	ViewAngles2      []float32
+	LocalViewAngles2 []float32
+}
+
+func (packet *Packet) ParsePacket(reader *bitreader.Reader) {
+	for count := 0; count < MSSC; count++ {
+		packet.ParseCmdInfo(reader)
+	}
+	packet.InSequence = reader.TryReadUInt32()
+	packet.OutSequence = reader.TryReadUInt32()
+	packet.Size = reader.TryReadUInt32()
+	packetReader := bitreader.NewReaderFromBytes(reader.TryReadBytesToSlice(uint64(packet.Size)), true)
+	for {
+		messageType, err := packetReader.ReadBits(6)
+		if err != nil {
+			break
+		}
+		packet.Data = append(packet.Data, messages.ParseMessages(messageType, packetReader))
+	}
+}
+
+func (packet *Packet) ParseCmdInfo(reader *bitreader.Reader) {
+	packet.PacketInfo = append(packet.PacketInfo, CmdInfo{
+		Flags:            reader.TryReadUInt32(),
+		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()},
+	})
+	writer.AppendLine("\tFlags: %s", CmdInfoFlags(packet.PacketInfo[len(packet.PacketInfo)-1].Flags).String())
+	writer.AppendLine("\tView Origin: %v", packet.PacketInfo[len(packet.PacketInfo)-1].ViewOrigin)
+	writer.AppendLine("\tView Angles: %v", packet.PacketInfo[len(packet.PacketInfo)-1].ViewAngles)
+	writer.AppendLine("\tLocal View Angles: %v", packet.PacketInfo[len(packet.PacketInfo)-1].LocalViewAngles)
+	writer.AppendLine("\tView Origin 2: %v", packet.PacketInfo[len(packet.PacketInfo)-1].ViewOrigin2)
+	writer.AppendLine("\tView Angles 2: %v", packet.PacketInfo[len(packet.PacketInfo)-1].ViewAngles2)
+	writer.AppendLine("\tLocal View Angles 2: %v", packet.PacketInfo[len(packet.PacketInfo)-1].LocalViewAngles2)
+	writer.AppendLine("")
+}
+
+type CmdInfoFlags int
+
+const (
+	ECmdInfoFlagsNone        = 0
+	ECmdInfoFlagsUseOrigin2  = 1
+	ECmdInfoFlagsUserAngles2 = 1 << 1
+	ECmdInfoFlagsNoInterp    = 1 << 2
+)
+
+func (cmdInfoFlags CmdInfoFlags) String() string {
+	switch cmdInfoFlags {
+	case ECmdInfoFlagsNone:
+		return "None"
+	case ECmdInfoFlagsUseOrigin2:
+		return "UseOrigin2"
+	case ECmdInfoFlagsUserAngles2:
+		return "UserAngles2"
+	case ECmdInfoFlagsNoInterp:
+		return "NoInterp"
+	default:
+		return fmt.Sprintf("%d", int(cmdInfoFlags))
+	}
+}
diff --git a/pkg/classes/sendTable.go b/pkg/classes/sendTable.go
deleted file mode 100644
index 927d967..0000000
--- a/pkg/classes/sendTable.go
+++ /dev/null
@@ -1,194 +0,0 @@
-package classes
-
-import (
-	"fmt"
-
-	"github.com/pektezol/bitreader"
-	"github.com/pektezol/demoparser/pkg/writer"
-)
-
-type SendTable struct {
-	NeedsDecoder bool
-	NetTableName string
-	NumOfProps   int16
-	Props        []prop
-}
-
-type prop struct {
-	SendPropType  sendPropType
-	SendPropName  string
-	SendPropFlags uint32
-	Priority      uint8
-	ExcludeDtName string
-	LowValue      float32
-	HighValue     float32
-	NumBits       int32
-	NumElements   int32
-}
-
-type sendPropType int
-
-const (
-	ESendPropTypeInt sendPropType = iota
-	ESendPropTypeFloat
-	ESendPropTypeVector3
-	ESendPropTypeVector2
-	ESendPropTypeString
-	ESendPropTypeArray
-	ESendPropTypeDataTable
-)
-
-const (
-	ESendPropFlagUnsigned       string = "Unsigned"
-	ESendPropFlagCoord          string = "Coord"
-	ESendPropFlagNoScale        string = "NoScale"
-	ESendPropFlagRoundDown      string = "RoundDown"
-	ESendPropFlagRoundUp        string = "RoundUp"
-	ESendPropFlagNormal         string = "Normal"
-	ESendPropFlagExclude        string = "Exclude"
-	ESendPropFlagXyze           string = "Xyze"
-	ESendPropFlagInsideArray    string = "InsideArray"
-	ESendPropFlagProxyAlwaysYes string = "ProxyAlwaysYes"
-	ESendPropFlagIsVectorElem   string = "IsVectorElem"
-	ESendPropFlagCollapsible    string = "Collapsible"
-	ESendPropFlagCoordMp        string = "CoordMp"
-	ESendPropFlagCoordMpLp      string = "CoordMpLp"
-	ESendPropFlagCoordMpInt     string = "CoordMpInt"
-	ESendPropFlagCellCoord      string = "CellCoord"
-	ESendPropFlagCellCoordLp    string = "CellCoordLp"
-	ESendPropFlagCellCoordInt   string = "CellCoordInt"
-	ESendPropFlagChangesOften   string = "ChangesOften"
-)
-
-func (prop prop) GetFlags() []string {
-	flags := []string{}
-	if checkBit(prop.SendPropFlags, 0) {
-		flags = append(flags, ESendPropFlagUnsigned)
-	}
-	if checkBit(prop.SendPropFlags, 1) {
-		flags = append(flags, ESendPropFlagCoord)
-	}
-	if checkBit(prop.SendPropFlags, 2) {
-		flags = append(flags, ESendPropFlagNoScale)
-	}
-	if checkBit(prop.SendPropFlags, 3) {
-		flags = append(flags, ESendPropFlagRoundDown)
-	}
-	if checkBit(prop.SendPropFlags, 4) {
-		flags = append(flags, ESendPropFlagRoundUp)
-	}
-	if checkBit(prop.SendPropFlags, 5) {
-		flags = append(flags, ESendPropFlagNormal)
-	}
-	if checkBit(prop.SendPropFlags, 6) {
-		flags = append(flags, ESendPropFlagExclude)
-	}
-	if checkBit(prop.SendPropFlags, 7) {
-		flags = append(flags, ESendPropFlagXyze)
-	}
-	if checkBit(prop.SendPropFlags, 8) {
-		flags = append(flags, ESendPropFlagInsideArray)
-	}
-	if checkBit(prop.SendPropFlags, 9) {
-		flags = append(flags, ESendPropFlagProxyAlwaysYes)
-	}
-	if checkBit(prop.SendPropFlags, 10) {
-		flags = append(flags, ESendPropFlagIsVectorElem)
-	}
-	if checkBit(prop.SendPropFlags, 11) {
-		flags = append(flags, ESendPropFlagCollapsible)
-	}
-	if checkBit(prop.SendPropFlags, 12) {
-		flags = append(flags, ESendPropFlagCoordMp)
-	}
-	if checkBit(prop.SendPropFlags, 13) {
-		flags = append(flags, ESendPropFlagCoordMpLp)
-	}
-	if checkBit(prop.SendPropFlags, 14) {
-		flags = append(flags, ESendPropFlagCoordMpInt)
-	}
-	if checkBit(prop.SendPropFlags, 15) {
-		flags = append(flags, ESendPropFlagCellCoord)
-	}
-	if checkBit(prop.SendPropFlags, 16) {
-		flags = append(flags, ESendPropFlagCellCoordLp)
-	}
-	if checkBit(prop.SendPropFlags, 17) {
-		flags = append(flags, ESendPropFlagCellCoordInt)
-	}
-	if checkBit(prop.SendPropFlags, 18) {
-		flags = append(flags, ESendPropFlagChangesOften)
-	}
-	return flags
-}
-
-func (sendPropType sendPropType) String() string {
-	switch sendPropType {
-	case ESendPropTypeInt:
-		return "Int"
-	case ESendPropTypeFloat:
-		return "Float"
-	case ESendPropTypeVector3:
-		return "Vector3"
-	case ESendPropTypeVector2:
-		return "Vector2"
-	case ESendPropTypeString:
-		return "String"
-	case ESendPropTypeArray:
-		return "Array"
-	case ESendPropTypeDataTable:
-		return "DataTable"
-	default:
-		return fmt.Sprintf("%d", int(sendPropType))
-	}
-}
-
-func ParseSendTable(reader *bitreader.Reader) SendTable {
-	sendTable := SendTable{
-		NeedsDecoder: reader.TryReadBool(),
-		NetTableName: reader.TryReadString(),
-		NumOfProps:   int16(reader.TryReadBits(10)),
-	}
-	if sendTable.NumOfProps < 0 {
-		return sendTable
-	}
-	writer.TempAppendLine("\t\t%s (%d Props):", sendTable.NetTableName, sendTable.NumOfProps)
-	for count := 0; count < int(sendTable.NumOfProps); count++ {
-		propType := int8(reader.TryReadBits(5))
-		if propType >= int8(7) {
-			return sendTable
-		}
-		prop := prop{
-			SendPropType:  sendPropType(propType),
-			SendPropName:  reader.TryReadString(),
-			SendPropFlags: uint32(reader.TryReadBits(19)),
-			Priority:      reader.TryReadUInt8(),
-		}
-		writer.TempAppend("\t\t\t%s\t", prop.SendPropType)
-		if propType == int8(ESendPropTypeDataTable) || checkBit(prop.SendPropFlags, 6) {
-			prop.ExcludeDtName = reader.TryReadString()
-			writer.TempAppend(":\t%s\t", prop.ExcludeDtName)
-		} else {
-			switch propType {
-			case int8(ESendPropTypeString), int8(ESendPropTypeInt), int8(ESendPropTypeFloat), int8(ESendPropTypeVector3), int8(ESendPropTypeVector2):
-				prop.LowValue = reader.TryReadFloat32()
-				prop.HighValue = reader.TryReadFloat32()
-				prop.NumBits = int32(reader.TryReadBits(7))
-				writer.TempAppend("Low: %f\tHigh: %f\t%d bits\t", prop.LowValue, prop.HighValue, prop.NumBits)
-			case int8(ESendPropTypeArray):
-				prop.NumElements = int32(reader.TryReadBits(10))
-				writer.TempAppend("Elements: %d\t", prop.NumElements)
-			default:
-				writer.TempAppend("Unknown Prop Type: %v\t", propType)
-				return sendTable
-			}
-		}
-		writer.TempAppend("Flags: %v\tPriority: %d\n", prop.GetFlags(), prop.Priority)
-		sendTable.Props = append(sendTable.Props, prop)
-	}
-	return sendTable
-}
-
-func checkBit(val uint32, bit int) bool {
-	return (val & (uint32(1) << bit)) != 0
-}
diff --git a/pkg/classes/serverClassInfo.go b/pkg/classes/serverClassInfo.go
deleted file mode 100644
index c0d2a2a..0000000
--- a/pkg/classes/serverClassInfo.go
+++ /dev/null
@@ -1,33 +0,0 @@
-package classes
-
-import (
-	"github.com/pektezol/bitreader"
-	"github.com/pektezol/demoparser/pkg/writer"
-)
-
-type ServerClassInfo struct {
-	ClassId       uint16
-	ClassName     string
-	DataTableName string
-}
-
-func ParseServerClassInfo(reader *bitreader.Reader, count int, numOfClasses int) ServerClassInfo {
-	serverClassInfo := ServerClassInfo{
-		ClassId:       reader.TryReadUInt16(),
-		ClassName:     reader.TryReadString(),
-		DataTableName: reader.TryReadString(),
-	}
-	writer.TempAppendLine("\t\t\t[%d] %s (%s)", serverClassInfo.ClassId, serverClassInfo.ClassName, serverClassInfo.DataTableName)
-	return serverClassInfo
-}
-
-// 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/signOn.go b/pkg/classes/signOn.go
new file mode 100644
index 0000000..fad696c
--- /dev/null
+++ b/pkg/classes/signOn.go
@@ -0,0 +1,52 @@
+package classes
+
+import (
+	"github.com/pektezol/bitreader"
+	"github.com/pektezol/demoparser/pkg/messages"
+	"github.com/pektezol/demoparser/pkg/writer"
+)
+
+type SignOn struct {
+	PacketInfo  []CmdInfo
+	InSequence  uint32
+	OutSequence uint32
+	Size        uint32
+	Data        []any
+}
+
+func (signOn *SignOn) ParseSignOn(reader *bitreader.Reader) {
+	for count := 0; count < MSSC; count++ {
+		signOn.ParseCmdInfo(reader)
+	}
+	signOn.InSequence = reader.TryReadUInt32()
+	signOn.OutSequence = reader.TryReadUInt32()
+	signOn.Size = reader.TryReadUInt32()
+	packetReader := bitreader.NewReaderFromBytes(reader.TryReadBytesToSlice(uint64(signOn.Size)), true)
+	for {
+		messageType, err := packetReader.ReadBits(6)
+		if err != nil {
+			break
+		}
+		signOn.Data = append(signOn.Data, messages.ParseMessages(messageType, packetReader))
+	}
+}
+
+func (signOn *SignOn) ParseCmdInfo(reader *bitreader.Reader) {
+	signOn.PacketInfo = append(signOn.PacketInfo, CmdInfo{
+		Flags:            reader.TryReadUInt32(),
+		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()},
+	})
+	writer.AppendLine("\tFlags: %s", CmdInfoFlags(signOn.PacketInfo[len(signOn.PacketInfo)-1].Flags).String())
+	writer.AppendLine("\tView Origin: %v", signOn.PacketInfo[len(signOn.PacketInfo)-1].ViewOrigin)
+	writer.AppendLine("\tView Angles: %v", signOn.PacketInfo[len(signOn.PacketInfo)-1].ViewAngles)
+	writer.AppendLine("\tLocal View Angles: %v", signOn.PacketInfo[len(signOn.PacketInfo)-1].LocalViewAngles)
+	writer.AppendLine("\tView Origin 2: %v", signOn.PacketInfo[len(signOn.PacketInfo)-1].ViewOrigin2)
+	writer.AppendLine("\tView Angles 2: %v", signOn.PacketInfo[len(signOn.PacketInfo)-1].ViewAngles2)
+	writer.AppendLine("\tLocal View Angles 2: %v", signOn.PacketInfo[len(signOn.PacketInfo)-1].LocalViewAngles2)
+	writer.AppendLine("")
+}
diff --git a/pkg/classes/stop.go b/pkg/classes/stop.go
new file mode 100644
index 0000000..753be19
--- /dev/null
+++ b/pkg/classes/stop.go
@@ -0,0 +1,17 @@
+package classes
+
+import (
+	"github.com/pektezol/bitreader"
+	"github.com/pektezol/demoparser/pkg/writer"
+)
+
+type Stop struct {
+	RemainingData []byte
+}
+
+func (stop *Stop) ParseStop(reader *bitreader.Reader) {
+	if reader.TryReadBool() {
+		stop.RemainingData = reader.TryReadBitsToSlice(uint64(reader.TryReadRemainingBits()))
+		writer.AppendLine("\tRemaining Data: %v", stop.RemainingData)
+	}
+}
diff --git a/pkg/classes/stringTable.go b/pkg/classes/stringTable.go
deleted file mode 100644
index 44d8a73..0000000
--- a/pkg/classes/stringTable.go
+++ /dev/null
@@ -1,93 +0,0 @@
-package classes
-
-import (
-	"github.com/pektezol/bitreader"
-	"github.com/pektezol/demoparser/pkg/writer"
-)
-
-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.Reader) []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.Reader) {
-	stringTable.Name = reader.TryReadString()
-	entryCount := reader.TryReadBits(16)
-	writer.AppendLine("\tTable Name: %s", stringTable.Name)
-	stringTable.TableEntries = make([]StringTableEntry, entryCount)
-
-	for i := 0; i < int(entryCount); i++ {
-		var entry StringTableEntry
-		entry.Parse(reader)
-		stringTable.TableEntries[i] = entry
-	}
-	if entryCount != 0 {
-		writer.AppendLine("\t\t%d Table Entries:", entryCount)
-		writer.AppendOutputFromTemp()
-	} else {
-		writer.AppendLine("\t\tNo Table Entries")
-	}
-	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
-		}
-		writer.AppendLine("\t\t%d Classes:", classCount)
-		writer.AppendOutputFromTemp()
-	} else {
-		writer.AppendLine("\t\tNo Class Entries")
-	}
-}
-
-func (stringTableEntry *StringTableEntry) Parse(reader *bitreader.Reader) {
-	stringTableEntry.Name = reader.TryReadString()
-	if reader.TryReadBool() {
-		byteLen, err := reader.ReadBits(16)
-		if err != nil {
-			return
-		}
-		dataBsr := reader.TryReadBytesToSlice(byteLen)
-		_ = bitreader.NewReaderFromBytes(dataBsr, true) // TODO: Parse StringTableEntry
-		// stringTableEntry.EntryData.ParseStream(entryReader)
-	}
-}
-
-func (stringTableClass *StringTableClass) Parse(reader *bitreader.Reader) {
-	stringTableClass.Name = reader.TryReadString()
-	writer.TempAppendLine("\t\t\tName: %s", stringTableClass.Name)
-	if reader.TryReadBool() {
-		dataLen := reader.TryReadBits(16)
-		stringTableClass.Data = reader.TryReadStringLength(dataLen)
-		writer.TempAppendLine("\t\t\tData: %s", stringTableClass.Data)
-	}
-}
diff --git a/pkg/classes/stringTables.go b/pkg/classes/stringTables.go
new file mode 100644
index 0000000..01939b2
--- /dev/null
+++ b/pkg/classes/stringTables.go
@@ -0,0 +1,100 @@
+package classes
+
+import (
+	"github.com/pektezol/bitreader"
+	"github.com/pektezol/demoparser/pkg/writer"
+)
+
+type StringTables struct {
+	Size int32
+	Data []StringTable
+}
+
+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 (stringTables *StringTables) ParseStringTables(reader *bitreader.Reader) {
+	stringTables.Size = reader.TryReadSInt32()
+	stringTableReader := bitreader.NewReaderFromBytes(reader.TryReadBytesToSlice(uint64(stringTables.Size)), true)
+	tableCount := stringTableReader.TryReadBits(8)
+	tables := make([]StringTable, tableCount)
+	for i := 0; i < int(tableCount); i++ {
+		var table StringTable
+		table.ParseStream(stringTableReader)
+		tables[i] = table
+	}
+	stringTables.Data = tables
+}
+
+func (stringTable *StringTable) ParseStream(reader *bitreader.Reader) {
+	stringTable.Name = reader.TryReadString()
+	entryCount := reader.TryReadBits(16)
+	writer.AppendLine("\tTable Name: %s", stringTable.Name)
+	stringTable.TableEntries = make([]StringTableEntry, entryCount)
+
+	for i := 0; i < int(entryCount); i++ {
+		var entry StringTableEntry
+		entry.Parse(reader)
+		stringTable.TableEntries[i] = entry
+	}
+	if entryCount != 0 {
+		writer.AppendLine("\t\t%d Table Entries:", entryCount)
+		writer.AppendOutputFromTemp()
+	} else {
+		writer.AppendLine("\t\tNo Table Entries")
+	}
+	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
+		}
+		writer.AppendLine("\t\t%d Classes:", classCount)
+		writer.AppendOutputFromTemp()
+	} else {
+		writer.AppendLine("\t\tNo Class Entries")
+	}
+}
+
+func (stringTableEntry *StringTableEntry) Parse(reader *bitreader.Reader) {
+	stringTableEntry.Name = reader.TryReadString()
+	if reader.TryReadBool() {
+		byteLen, err := reader.ReadBits(16)
+		if err != nil {
+			return
+		}
+		dataBsr := reader.TryReadBytesToSlice(byteLen)
+		_ = bitreader.NewReaderFromBytes(dataBsr, true) // TODO: Parse StringTableEntry
+		// stringTableEntry.EntryData.ParseStream(entryReader)
+	}
+}
+
+func (stringTableClass *StringTableClass) Parse(reader *bitreader.Reader) {
+	stringTableClass.Name = reader.TryReadString()
+	writer.TempAppendLine("\t\t\tName: %s", stringTableClass.Name)
+	if reader.TryReadBool() {
+		dataLen := reader.TryReadBits(16)
+		stringTableClass.Data = reader.TryReadStringLength(dataLen)
+		writer.TempAppendLine("\t\t\tData: %s", stringTableClass.Data)
+	}
+}
diff --git a/pkg/classes/syncTick.go b/pkg/classes/syncTick.go
new file mode 100644
index 0000000..2f9df3e
--- /dev/null
+++ b/pkg/classes/syncTick.go
@@ -0,0 +1,5 @@
+package classes
+
+type SyncTick struct{}
+
+func (syncTick *SyncTick) ParseSyncTick() {}
diff --git a/pkg/classes/userCmd.go b/pkg/classes/userCmd.go
new file mode 100644
index 0000000..24969f1
--- /dev/null
+++ b/pkg/classes/userCmd.go
@@ -0,0 +1,231 @@
+package classes
+
+import (
+	"github.com/pektezol/bitreader"
+	"github.com/pektezol/demoparser/pkg/writer"
+)
+
+type UserCmd struct {
+	Cmd  uint32
+	Size uint32
+	Data UserCmdInfo
+}
+
+type UserCmdInfo struct {
+	CommandNumber uint32
+	TickCount     uint32
+	ViewAnglesX   float32
+	ViewAnglesY   float32
+	ViewAnglesZ   float32
+	ForwardMove   float32
+	SideMove      float32
+	UpMove        float32
+	Buttons       uint32
+	Impulse       uint8
+	WeaponSelect  uint16
+	WeaponSubType uint8
+	MouseDx       uint16
+	MouseDy       uint16
+}
+
+func (userCmd *UserCmd) ParseUserCmd(reader *bitreader.Reader) {
+	userCmd.Cmd = reader.TryReadUInt32()
+	userCmd.Size = reader.TryReadUInt32()
+	userCmdReader := bitreader.NewReaderFromBytes(reader.TryReadBytesToSlice(uint64(userCmd.Size)), true)
+	userCmd.ParseUserCmdInfo(userCmdReader)
+}
+
+func (userCmd *UserCmd) ParseUserCmdInfo(reader *bitreader.Reader) {
+	if reader.TryReadBool() {
+		userCmd.Data.CommandNumber = reader.TryReadUInt32()
+	}
+	if reader.TryReadBool() {
+		userCmd.Data.TickCount = reader.TryReadUInt32()
+	}
+	if reader.TryReadBool() {
+		userCmd.Data.ViewAnglesX = reader.TryReadFloat32()
+	}
+	if reader.TryReadBool() {
+		userCmd.Data.ViewAnglesY = reader.TryReadFloat32()
+	}
+	if reader.TryReadBool() {
+		userCmd.Data.ViewAnglesZ = reader.TryReadFloat32()
+	}
+	if reader.TryReadBool() {
+		userCmd.Data.ForwardMove = reader.TryReadFloat32()
+	}
+	if reader.TryReadBool() {
+		userCmd.Data.SideMove = reader.TryReadFloat32()
+	}
+	if reader.TryReadBool() {
+		userCmd.Data.UpMove = reader.TryReadFloat32()
+	}
+	if reader.TryReadBool() {
+		userCmd.Data.Buttons = reader.TryReadUInt32()
+	}
+	if reader.TryReadBool() {
+		userCmd.Data.Impulse = reader.TryReadUInt8()
+	}
+	if reader.TryReadBool() {
+		userCmd.Data.WeaponSelect = uint16(reader.TryReadBits(11))
+		if reader.TryReadBool() {
+			userCmd.Data.WeaponSubType = uint8(reader.TryReadBits(6))
+		}
+	}
+	if reader.TryReadBool() {
+		userCmd.Data.MouseDx = reader.TryReadUInt16()
+	}
+	if reader.TryReadBool() {
+		userCmd.Data.MouseDy = reader.TryReadUInt16()
+	}
+	writer.AppendLine("\tCommand Number: %v", userCmd.Data.CommandNumber)
+	writer.AppendLine("\tTick Count: %v", userCmd.Data.TickCount)
+	writer.AppendLine("\tView Angles: %v", []float32{userCmd.Data.ViewAnglesX, userCmd.Data.ViewAnglesY, userCmd.Data.ViewAnglesZ})
+	writer.AppendLine("\tMovement: %v", []float32{userCmd.Data.ForwardMove, userCmd.Data.SideMove, userCmd.Data.UpMove})
+	writer.AppendLine("\tButtons: %v", Buttons(userCmd.Data.Buttons).GetButtons())
+	writer.AppendLine("\tImpulse: %v", userCmd.Data.Impulse)
+	writer.AppendLine("\tWeapon, Subtype: %v, %v", userCmd.Data.WeaponSelect, userCmd.Data.WeaponSubType)
+	writer.AppendLine("\tMouse Dx, Mouse Dy: %v, %v", userCmd.Data.MouseDx, userCmd.Data.MouseDy)
+}
+
+func (button Buttons) GetButtons() []string {
+	flags := []string{}
+	if button == 0 {
+		flags = append(flags, EButtonsNone)
+	}
+	if checkBit(uint32(button), 0) {
+		flags = append(flags, EButtonsAttack)
+	}
+	if checkBit(uint32(button), 1) {
+		flags = append(flags, EButtonsJump)
+	}
+	if checkBit(uint32(button), 2) {
+		flags = append(flags, EButtonsDuck)
+	}
+	if checkBit(uint32(button), 3) {
+		flags = append(flags, EButtonsForward)
+	}
+	if checkBit(uint32(button), 4) {
+		flags = append(flags, EButtonsBack)
+	}
+	if checkBit(uint32(button), 5) {
+		flags = append(flags, EButtonsUse)
+	}
+	if checkBit(uint32(button), 6) {
+		flags = append(flags, EButtonsCancel)
+	}
+	if checkBit(uint32(button), 7) {
+		flags = append(flags, EButtonsLeft)
+	}
+	if checkBit(uint32(button), 8) {
+		flags = append(flags, EButtonsRight)
+	}
+	if checkBit(uint32(button), 9) {
+		flags = append(flags, EButtonsMoveLeft)
+	}
+	if checkBit(uint32(button), 10) {
+		flags = append(flags, EButtonsMoveRight)
+	}
+	if checkBit(uint32(button), 11) {
+		flags = append(flags, EButtonsAttack2)
+	}
+	if checkBit(uint32(button), 12) {
+		flags = append(flags, EButtonsRun)
+	}
+	if checkBit(uint32(button), 13) {
+		flags = append(flags, EButtonsReload)
+	}
+	if checkBit(uint32(button), 14) {
+		flags = append(flags, EButtonsAlt1)
+	}
+	if checkBit(uint32(button), 15) {
+		flags = append(flags, EButtonsAlt2)
+	}
+	if checkBit(uint32(button), 16) {
+		flags = append(flags, EButtonsScore)
+	}
+	if checkBit(uint32(button), 17) {
+		flags = append(flags, EButtonsSpeed)
+	}
+	if checkBit(uint32(button), 18) {
+		flags = append(flags, EButtonsWalk)
+	}
+	if checkBit(uint32(button), 19) {
+		flags = append(flags, EButtonsZoom)
+	}
+	if checkBit(uint32(button), 20) {
+		flags = append(flags, EButtonsWeapon1)
+	}
+	if checkBit(uint32(button), 21) {
+		flags = append(flags, EButtonsWeapon2)
+	}
+	if checkBit(uint32(button), 22) {
+		flags = append(flags, EButtonsBullRush)
+	}
+	if checkBit(uint32(button), 23) {
+		flags = append(flags, EButtonsGrenade1)
+	}
+	if checkBit(uint32(button), 24) {
+		flags = append(flags, EButtonsGrenade2)
+	}
+	if checkBit(uint32(button), 25) {
+		flags = append(flags, EButtonsLookSpin)
+	}
+	if checkBit(uint32(button), 26) {
+		flags = append(flags, EButtonsCurrentAbility)
+	}
+	if checkBit(uint32(button), 27) {
+		flags = append(flags, EButtonsPreviousAbility)
+	}
+	if checkBit(uint32(button), 28) {
+		flags = append(flags, EButtonsAbility1)
+	}
+	if checkBit(uint32(button), 29) {
+		flags = append(flags, EButtonsAbility2)
+	}
+	if checkBit(uint32(button), 30) {
+		flags = append(flags, EButtonsAbility3)
+	}
+	if checkBit(uint32(button), 31) {
+		flags = append(flags, EButtonsAbility4)
+	}
+	return flags
+}
+
+type Buttons int
+
+const (
+	EButtonsNone            string = "None"
+	EButtonsAttack          string = "Attack"
+	EButtonsJump            string = "Jump"
+	EButtonsDuck            string = "Duck"
+	EButtonsForward         string = "Forward"
+	EButtonsBack            string = "Back"
+	EButtonsUse             string = "Use"
+	EButtonsCancel          string = "Cancel"
+	EButtonsLeft            string = "Left"
+	EButtonsRight           string = "Right"
+	EButtonsMoveLeft        string = "MoveLeft"
+	EButtonsMoveRight       string = "MoveRight"
+	EButtonsAttack2         string = "Attack2"
+	EButtonsRun             string = "Run"
+	EButtonsReload          string = "Reload"
+	EButtonsAlt1            string = "Alt1"
+	EButtonsAlt2            string = "Alt2"
+	EButtonsScore           string = "Score"
+	EButtonsSpeed           string = "Speed"
+	EButtonsWalk            string = "Walk"
+	EButtonsZoom            string = "Zoom"
+	EButtonsWeapon1         string = "Weapon1"
+	EButtonsWeapon2         string = "Weapon2"
+	EButtonsBullRush        string = "BullRush"
+	EButtonsGrenade1        string = "Grenade1"
+	EButtonsGrenade2        string = "Grenade2"
+	EButtonsLookSpin        string = "LookSpin"
+	EButtonsCurrentAbility  string = "CurrentAbility"
+	EButtonsPreviousAbility string = "PreviousAbility"
+	EButtonsAbility1        string = "Ability1"
+	EButtonsAbility2        string = "Ability2"
+	EButtonsAbility3        string = "Ability3"
+	EButtonsAbility4        string = "Ability4"
+)
diff --git a/pkg/classes/userCmdInfo.go b/pkg/classes/userCmdInfo.go
deleted file mode 100644
index f1bb613..0000000
--- a/pkg/classes/userCmdInfo.go
+++ /dev/null
@@ -1,87 +0,0 @@
-package classes
-
-import (
-	"bytes"
-
-	"github.com/pektezol/bitreader"
-	"github.com/pektezol/demoparser/pkg/writer"
-)
-
-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.NewReader(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))
-	}
-	writer.AppendLine("\tCommand Number: %v", userCmdInfo.CommandNumber)
-	writer.AppendLine("\tTick Count: %v", userCmdInfo.TickCount)
-	writer.AppendLine("\tView Angles X: %v", userCmdInfo.ViewAnglesX)
-	writer.AppendLine("\tView Angles Y: %v", userCmdInfo.ViewAnglesY)
-	writer.AppendLine("\tView Angles Z: %v", userCmdInfo.ViewAnglesZ)
-	writer.AppendLine("\tForward Move: %v", userCmdInfo.ForwardMove)
-	writer.AppendLine("\tSide Move: %v", userCmdInfo.SideMove)
-	writer.AppendLine("\tUp Move: %v", userCmdInfo.UpMove)
-	writer.AppendLine("\tButtons: %v", userCmdInfo.Buttons)
-	writer.AppendLine("\tImpulse: %v", userCmdInfo.Impulse)
-	writer.AppendLine("\tWeapon Select: %v", userCmdInfo.WeaponSelect)
-	writer.AppendLine("\tWeapon Sub Type: %v", userCmdInfo.WeaponSubType)
-	writer.AppendLine("\tMouse Dx: %v", userCmdInfo.MouseDx)
-	writer.AppendLine("\tMouse Dy: %v", userCmdInfo.MouseDy)
-	return userCmdInfo
-}
diff --git a/pkg/messages/messages.go b/pkg/messages/messages.go
index efa9460..5cc781d 100644
--- a/pkg/messages/messages.go
+++ b/pkg/messages/messages.go
@@ -8,7 +8,7 @@ import (
 	"github.com/pektezol/demoparser/pkg/writer"
 )
 
-func ParseMessages(messageType int, reader *bitreader.Reader) any {
+func ParseMessages(messageType uint64, reader *bitreader.Reader) any {
 	var messageData any
 	switch messageType {
 	case 0:
diff --git a/pkg/packets/packets.go b/pkg/packets/packets.go
index 33350d5..b1d6a40 100644
--- a/pkg/packets/packets.go
+++ b/pkg/packets/packets.go
@@ -3,7 +3,6 @@ package packets
 import (
 	"github.com/pektezol/bitreader"
 	"github.com/pektezol/demoparser/pkg/classes"
-	"github.com/pektezol/demoparser/pkg/messages"
 	"github.com/pektezol/demoparser/pkg/writer"
 )
 
@@ -11,130 +10,49 @@ 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{}
 		writer.AppendLine("[%d] %s (%d):", tickNumber, "SIGNON", packetType)
-		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
+		signOn := classes.SignOn{}
+		signOn.ParseSignOn(reader)
 	case 2: // Packet
-		packet := Packet{}
 		writer.AppendLine("[%d] %s (%d):", tickNumber, "PACKET", packetType)
-		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
+		packet := classes.Packet{}
+		packet.ParsePacket(reader)
 	case 3: // SyncTick
-		syncTick := SyncTick{}
 		writer.AppendLine("[%d] %s (%d):", tickNumber, "SYNCTICK", packetType)
-		packetData = syncTick
+		syncTick := classes.SyncTick{}
+		syncTick.ParseSyncTick()
 	case 4: // ConsoleCmd
-		consoleCmd := ConsoleCmd{}
 		writer.AppendLine("[%d] %s (%d):", tickNumber, "CONSOLECMD", packetType)
-		consoleCmd.Size = reader.TryReadSInt32()
-		consoleCmd.Data = reader.TryReadStringLength(uint64(consoleCmd.Size))
-		writer.AppendLine("\t%s", consoleCmd.Data)
-		packetData = consoleCmd
-	case 5: // UserCmd TODO: usercmdinfo refactor
-		userCmd := UserCmd{}
+		consoleCmd := classes.ConsoleCmd{}
+		consoleCmd.ParseConsoleCmd(reader)
+	case 5: // UserCmd
 		writer.AppendLine("[%d] %s (%d):", tickNumber, "USERCMD", packetType)
-		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{}
+		userCmd := classes.UserCmd{}
+		userCmd.ParseUserCmd(reader)
+	case 6: // DataTables
 		writer.AppendLine("[%d] %s (%d):", tickNumber, "DATATABLES", packetType)
-		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))
-		}
-		writer.AppendLine("\t%d Send Tables:", count)
-		writer.AppendOutputFromTemp()
-		numOfClasses := dataTableReader.TryReadBits(16)
-		for count = 0; count < int(numOfClasses); count++ {
-			dataTables.ServerClassInfo = append(dataTables.ServerClassInfo, classes.ParseServerClassInfo(dataTableReader, count, int(numOfClasses)))
-		}
-		writer.AppendLine("\t%d Classes:", count)
-		writer.AppendOutputFromTemp()
-		packetData = dataTables
+		dataTables := classes.DataTables{}
+		dataTables.ParseDataTables(reader)
 	case 7: // Stop
-		stop := Stop{}
 		writer.AppendLine("[%d] %s (%d):", tickNumber, "STOP", packetType)
-		if reader.TryReadBool() {
-			stop.RemainingData = reader.TryReadBitsToSlice(uint64(reader.TryReadRemainingBits()))
-			writer.AppendLine("\tRemaining Data: %v", stop.RemainingData)
-		}
-		packetData = stop
+		stop := classes.Stop{}
+		stop.ParseStop(reader)
 	case 8: // CustomData TODO: not sar data
-		customData := CustomData{}
-		customData.Type = reader.TryReadSInt32()
-		customData.Size = reader.TryReadSInt32()
-		if customData.Type != 0 || customData.Size == 8 {
-			// Not SAR data
-			writer.AppendLine("[%d] %s (%d):", tickNumber, "CUSTOMDATA", packetType)
-			customData.Data = string(reader.TryReadBytesToSlice(uint64(customData.Size)))
-			writer.AppendLine("\t%s", customData.Data)
-			packetData = customData
-			break
-		}
-		// SAR data
-		sarData := classes.SarData{}
-		writer.AppendLine("[%d] %s (%d):", tickNumber, "SARDATA", packetType)
-		data := reader.TryReadBytesToSlice(uint64(customData.Size))
-		sarReader := bitreader.NewReaderFromBytes(data, true)
-		sarData.ParseSarData(sarReader)
-		packetData = sarData
+		customData := classes.CustomData{}
+		customData.ParseCustomData(reader, tickNumber, packetType)
 	case 9: // StringTables TODO: parsing string table data
-		stringTables := StringTables{}
 		writer.AppendLine("[%d] %s (%d):", tickNumber, "STRINGTABLES", packetType)
-		stringTables.Size = reader.TryReadSInt32()
-		data := reader.TryReadBytesToSlice(uint64(stringTables.Size))
-		stringTableReader := bitreader.NewReaderFromBytes(data, true)
-		stringTables.Data = classes.ParseStringTables(stringTableReader)
-		packetData = stringTables
-	default: // invalid
+		stringTables := classes.StringTables{}
+		stringTables.ParseStringTables(reader)
+	default: // Invalid
 		writer.AppendLine("[%d] %s (%d):", tickNumber, "INVALID", packetType)
 		panic("invalid packet type")
 	}
@@ -142,6 +60,5 @@ func ParsePackets(reader *bitreader.Reader) PacketMessageInfo {
 		PacketType: packetType,
 		TickNumber: tickNumber,
 		SlotNumber: slotNumber,
-		Data:       packetData,
 	}
 }
diff --git a/pkg/packets/types.go b/pkg/packets/types.go
deleted file mode 100644
index a2fb78f..0000000
--- a/pkg/packets/types.go
+++ /dev/null
@@ -1,53 +0,0 @@
-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 {
-	Type int32
-	Size int32
-	Data string
-}
-
-type StringTables struct {
-	Size int32
-	Data []classes.StringTable
-}
-- 
cgit v1.2.3