From 2f8c92f261586f68a976efce0cfcdd0401f402e0 Mon Sep 17 00:00:00 2001
From: Arda Serdar Pektezol <1669855+pektezol@users.noreply.github.com>
Date: Mon, 6 Nov 2023 18:37:11 +0300
Subject: dont try to understand it, feel it

---
 pkg/classes/consoleCmd.go   |  15 --
 pkg/classes/customData.go   |  26 ---
 pkg/classes/dataTables.go   | 232 -------------------------
 pkg/classes/packet.go       |  81 ---------
 pkg/classes/sarData.go      | 403 --------------------------------------------
 pkg/classes/signOn.go       |  43 -----
 pkg/classes/stop.go         |  15 --
 pkg/classes/stringTables.go |  86 ----------
 pkg/classes/syncTick.go     |   5 -
 pkg/classes/userCmd.go      | 222 ------------------------
 10 files changed, 1128 deletions(-)
 delete mode 100644 pkg/classes/consoleCmd.go
 delete mode 100644 pkg/classes/customData.go
 delete mode 100644 pkg/classes/dataTables.go
 delete mode 100644 pkg/classes/packet.go
 delete mode 100644 pkg/classes/sarData.go
 delete mode 100644 pkg/classes/signOn.go
 delete mode 100644 pkg/classes/stop.go
 delete mode 100644 pkg/classes/stringTables.go
 delete mode 100644 pkg/classes/syncTick.go
 delete mode 100644 pkg/classes/userCmd.go

(limited to 'pkg/classes')

diff --git a/pkg/classes/consoleCmd.go b/pkg/classes/consoleCmd.go
deleted file mode 100644
index fa9bbd0..0000000
--- a/pkg/classes/consoleCmd.go
+++ /dev/null
@@ -1,15 +0,0 @@
-package classes
-
-import (
-	"github.com/pektezol/bitreader"
-)
-
-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))
-}
diff --git a/pkg/classes/customData.go b/pkg/classes/customData.go
deleted file mode 100644
index 59cb121..0000000
--- a/pkg/classes/customData.go
+++ /dev/null
@@ -1,26 +0,0 @@
-package classes
-
-import (
-	"github.com/pektezol/bitreader"
-)
-
-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
-		customData.Data = string(reader.TryReadBytesToSlice(uint64(customData.Size)))
-		return
-	}
-	// SAR data
-	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
deleted file mode 100644
index c17e5f6..0000000
--- a/pkg/classes/dataTables.go
+++ /dev/null
@@ -1,232 +0,0 @@
-package classes
-
-import (
-	"fmt"
-
-	"github.com/pektezol/bitreader"
-)
-
-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))
-	}
-	numOfClasses := dataTableReader.TryReadBits(16)
-	for count = 0; count < int(numOfClasses); count++ {
-		dataTables.ServerClassInfo = append(dataTables.ServerClassInfo, ParseServerClassInfo(dataTableReader, count, int(numOfClasses)))
-	}
-}
-
-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
-	}
-	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(),
-		}
-		if propType == int8(ESendPropTypeDataTable) || checkBit(prop.SendPropFlags, 6) {
-			prop.ExcludeDtName = reader.TryReadString()
-		} 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))
-			case int8(ESendPropTypeArray):
-				prop.NumElements = int32(reader.TryReadBits(10))
-			default:
-				return sendTable
-			}
-		}
-		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(),
-	}
-	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
deleted file mode 100644
index c608244..0000000
--- a/pkg/classes/packet.go
+++ /dev/null
@@ -1,81 +0,0 @@
-package classes
-
-import (
-	"fmt"
-
-	"github.com/pektezol/bitreader"
-	"github.com/pektezol/demoparser/pkg/messages"
-)
-
-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()},
-	})
-}
-
-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/sarData.go b/pkg/classes/sarData.go
deleted file mode 100644
index 9c61304..0000000
--- a/pkg/classes/sarData.go
+++ /dev/null
@@ -1,403 +0,0 @@
-package classes
-
-import (
-	"errors"
-	"fmt"
-
-	"github.com/pektezol/bitreader"
-)
-
-type SarDataType uint8
-
-const (
-	ESarDataTimescaleCheat  SarDataType = 0x01
-	ESarDataInitialCVar     SarDataType = 0x02
-	ESarDataEntityInput     SarDataType = 0x03
-	ESarDataEntityInputSlot SarDataType = 0x04
-	ESarDataPortalPlacement SarDataType = 0x05
-	ESarDataChallengeFlags  SarDataType = 0x06
-	ESarDataCrouchFly       SarDataType = 0x07
-	ESarDataPause           SarDataType = 0x08
-	ESarDataWaitRun         SarDataType = 0x09
-	ESarDataSpeedrunTime    SarDataType = 0x0A
-	ESarDataTimestamp       SarDataType = 0x0B
-	ESarDataFileChecksum    SarDataType = 0x0C
-	ESarDataHWaitRun        SarDataType = 0x0D
-	ESarDataChecksum        SarDataType = 0xFF
-	ESarDataChecksumV2      SarDataType = 0xFE
-	ESarDataInvalid         SarDataType = iota
-)
-
-func (sarDataType SarDataType) String() string {
-	switch sarDataType {
-	case ESarDataTimescaleCheat:
-		return "SarDataTimescaleCheat"
-	case ESarDataInitialCVar:
-		return "SarDataInitialCVar"
-	case ESarDataEntityInput:
-		return "SarDataEntityInput"
-	case ESarDataEntityInputSlot:
-		return "SarDataEntityInputSlot"
-	case ESarDataPortalPlacement:
-		return "SarDataPortalPlacement"
-	case ESarDataChallengeFlags:
-		return "SarDataChallengeFlags"
-	case ESarDataCrouchFly:
-		return "SarDataCrouchFly"
-	case ESarDataPause:
-		return "SarDataPause"
-	case ESarDataWaitRun:
-		return "SarDataWaitRun"
-	case ESarDataSpeedrunTime:
-		return "SarDataSpeedrunTime"
-	case ESarDataTimestamp:
-		return "SarDataTimestamp"
-	case ESarDataFileChecksum:
-		return "SarDataFileChecksum"
-	case ESarDataHWaitRun:
-		return "SarDataHWaitRun"
-	case ESarDataChecksum:
-		return "SarDataChecksum"
-	case ESarDataChecksumV2:
-		return "SarDataChecksumV2"
-	case ESarDataInvalid:
-		return "SarDataInvalid"
-	default:
-		return fmt.Sprintf("%d", int(sarDataType))
-	}
-}
-
-type SarData struct {
-	Type SarDataType
-	Slot int
-	Data any
-}
-
-type SarDataTimescaleCheat struct {
-	Timescale float32
-}
-
-type SarDataInitialCVar struct {
-	CVar string
-	Val  string
-}
-
-type SarDataChecksum struct {
-	DemoSum uint32
-	SarSum  uint32
-}
-
-type SarDataChecksumV2 struct {
-	SarSum    uint32
-	Signature [64]byte
-}
-
-type SarDataEntityInput struct {
-	TargetName string
-	ClassName  string
-	InputName  string
-	Parameter  string
-}
-
-type SarDataPortalPlacement struct {
-	Orange bool
-	X      float32
-	Y      float32
-	Z      float32
-}
-
-type SarDataPause struct {
-	PauseTicks uint32
-}
-
-type SarDataWaitRun struct {
-	Ticks int
-	Cmd   string
-}
-
-type SarDataHWaitRun struct {
-	Ticks int
-	Cmd   string
-}
-
-type SarDataSpeedrunTime struct {
-	NSplits uint32
-	Splits  []SarDataSpeedrunTimeSplits
-}
-
-type SarDataSpeedrunTimeSegs struct {
-	Name  string
-	Ticks uint32
-}
-
-type SarDataSpeedrunTimeSplits struct {
-	Name  string
-	NSegs uint32
-	Segs  []SarDataSpeedrunTimeSegs
-}
-
-type SarDataTimestamp struct {
-	Year   uint16
-	Month  uint8
-	Day    uint8
-	Hour   uint8
-	Minute uint8
-	Second uint8
-}
-
-type SarDataFileChecksum struct {
-	Sum  uint32
-	Path string
-}
-
-func (sarData *SarData) ParseSarData(reader *bitreader.Reader) (err error) {
-	reader.SkipBytes(8)
-	len := reader.TryReadRemainingBits() / 8
-	if len == 0 {
-		sarData.Type = ESarDataInvalid
-		err = errors.New("sar data invalid")
-		return err
-	}
-	sarData.Type = SarDataType(reader.TryReadBytes(1))
-	if sarData.Type == ESarDataChecksum && len == 5 {
-		len = 9
-	}
-	dataReader := bitreader.NewReaderFromBytes(reader.TryReadBytesToSlice(len-1), true)
-	switch sarData.Type {
-	case ESarDataTimescaleCheat:
-		sarData.Data, err = parseTimescaleCheatData(dataReader, len)
-		if err != nil {
-			sarData.Data = nil
-		}
-	case ESarDataInitialCVar:
-		sarData.Data = parseInitialCVarData(dataReader)
-	case ESarDataEntityInputSlot:
-		sarData.Slot = int(dataReader.TryReadBytes(1))
-	case ESarDataEntityInput:
-		sarData.Data = parseEntityInputData(dataReader)
-	case ESarDataChecksum:
-		sarData.Data, err = parseChecksumData(dataReader, len)
-		if err != nil {
-			sarData.Data = nil
-		}
-	case ESarDataChecksumV2:
-		sarData.Data, err = parseChecksumV2Data(dataReader, len)
-		if err != nil {
-			sarData.Data = nil
-		}
-	case ESarDataPortalPlacement:
-		data, slot, err := parsePortalPlacementData(dataReader, len)
-		if err != nil {
-			sarData.Data = nil
-		} else {
-			sarData.Data = data
-			sarData.Slot = slot
-		}
-	case ESarDataChallengeFlags, ESarDataCrouchFly:
-		sarData.Slot, err = parseChallengeFlagsCrouchFlyData(dataReader, len)
-		if err != nil {
-			sarData.Data = nil
-		}
-
-	case ESarDataPause:
-		sarData.Data, err = parsePauseData(dataReader, len)
-		if err != nil {
-			sarData.Data = nil
-		}
-	case ESarDataWaitRun:
-		sarData.Data, err = parseWaitRunData(dataReader, len)
-		if err != nil {
-			sarData.Data = nil
-		}
-	case ESarDataHWaitRun:
-		sarData.Data, err = parseHWaitRunData(dataReader, len)
-		if err != nil {
-			sarData.Data = nil
-		}
-	case ESarDataSpeedrunTime:
-		sarData.Data, err = parseSpeedrunTimeData(dataReader, len)
-		if err != nil {
-			sarData.Data = nil
-		}
-	case ESarDataTimestamp:
-		sarData.Data, err = parseTimestampData(dataReader, len)
-		if err != nil {
-			sarData.Data = nil
-		}
-	case ESarDataFileChecksum:
-		sarData.Data, err = parseFileChecksumData(dataReader, len)
-		if err != nil {
-			sarData.Data = nil
-		}
-	default:
-		err = errors.New("unsupported SAR data type")
-		return err
-	}
-	return nil
-}
-
-func parseTimescaleCheatData(reader *bitreader.Reader, length uint64) (SarDataTimescaleCheat, error) {
-	if length != 5 {
-		return SarDataTimescaleCheat{}, errors.New("sar data invalid")
-	}
-	sarDataTimescaleCheat := SarDataTimescaleCheat{
-		Timescale: reader.TryReadFloat32(),
-	}
-
-	return sarDataTimescaleCheat, nil
-}
-
-func parseInitialCVarData(reader *bitreader.Reader) SarDataInitialCVar {
-	sarDataInitialCvar := SarDataInitialCVar{
-		CVar: reader.TryReadString(),
-		Val:  reader.TryReadString(),
-	}
-
-	return sarDataInitialCvar
-}
-
-func parseEntityInputData(reader *bitreader.Reader) SarDataEntityInput {
-	sarDataEntityInput := SarDataEntityInput{
-		TargetName: reader.TryReadString(),
-		ClassName:  reader.TryReadString(),
-		InputName:  reader.TryReadString(),
-		Parameter:  reader.TryReadString(),
-	}
-
-	return sarDataEntityInput
-}
-
-func parseChecksumData(reader *bitreader.Reader, length uint64) (SarDataChecksum, error) {
-	if length != 9 {
-		return SarDataChecksum{}, errors.New("sar data invalid")
-	}
-	sarDataChecksum := SarDataChecksum{
-		DemoSum: reader.TryReadUInt32(),
-		SarSum:  reader.TryReadUInt32(),
-	}
-
-	return sarDataChecksum, nil
-}
-
-func parseChecksumV2Data(reader *bitreader.Reader, length uint64) (SarDataChecksumV2, error) {
-	if length != 69 {
-		return SarDataChecksumV2{}, errors.New("sar data invalid")
-	}
-	sarDataChecksumV2 := SarDataChecksumV2{
-		SarSum:    reader.TryReadUInt32(),
-		Signature: [64]byte(reader.TryReadBytesToSlice(60)),
-	}
-
-	return sarDataChecksumV2, nil
-}
-
-func parsePortalPlacementData(reader *bitreader.Reader, length uint64) (SarDataPortalPlacement, int, error) {
-	if length != 15 {
-		return SarDataPortalPlacement{}, 0, errors.New("sar data invalid")
-	}
-	slot := int(reader.TryReadBytes(1))
-	orange := reader.TryReadBool()
-	reader.SkipBits(7)
-	sarDataPortalPlacement := SarDataPortalPlacement{
-		Orange: orange,
-		X:      reader.TryReadFloat32(),
-		Y:      reader.TryReadFloat32(),
-		Z:      reader.TryReadFloat32(),
-	}
-
-	return sarDataPortalPlacement, slot, nil
-}
-
-func parseChallengeFlagsCrouchFlyData(reader *bitreader.Reader, length uint64) (int, error) {
-	if length != 2 {
-		return 0, errors.New("sar data invalid")
-	}
-	return int(reader.TryReadBytes(1)), nil
-}
-
-func parsePauseData(reader *bitreader.Reader, length uint64) (SarDataPause, error) {
-	if length != 5 {
-		return SarDataPause{}, errors.New("sar data invalid")
-	}
-	sarDataPause := SarDataPause{
-		PauseTicks: reader.TryReadUInt32(),
-	}
-
-	return sarDataPause, nil
-}
-
-func parseWaitRunData(reader *bitreader.Reader, length uint64) (SarDataWaitRun, error) {
-	if length < 6 {
-		return SarDataWaitRun{}, errors.New("sar data invalid")
-	}
-	sarDataWaitRun := SarDataWaitRun{
-		Ticks: int(reader.TryReadUInt32()),
-		Cmd:   reader.TryReadString(),
-	}
-
-	return sarDataWaitRun, nil
-}
-
-func parseHWaitRunData(reader *bitreader.Reader, length uint64) (SarDataHWaitRun, error) {
-	if length < 6 {
-		return SarDataHWaitRun{}, errors.New("sar data invalid")
-	}
-	sarDataHWaitRun := SarDataHWaitRun{
-		Ticks: int(reader.TryReadUInt32()),
-		Cmd:   reader.TryReadString(),
-	}
-
-	return sarDataHWaitRun, nil
-}
-
-func parseSpeedrunTimeData(reader *bitreader.Reader, length uint64) (SarDataSpeedrunTime, error) {
-	if length < 5 {
-		return SarDataSpeedrunTime{}, errors.New("sar data invalid")
-	}
-	numberOfSplits := reader.TryReadUInt32()
-	splits := make([]SarDataSpeedrunTimeSplits, numberOfSplits)
-	for splitCount := 0; splitCount < int(numberOfSplits); splitCount++ {
-		splits[splitCount].Name = reader.TryReadString()
-		splits[splitCount].NSegs = reader.TryReadUInt32()
-
-		splits[splitCount].Segs = make([]SarDataSpeedrunTimeSegs, splits[splitCount].NSegs)
-		for segCount := 0; segCount < int(splits[splitCount].NSegs); segCount++ {
-			splits[splitCount].Segs[segCount].Name = reader.TryReadString()
-			splits[splitCount].Segs[segCount].Ticks = reader.TryReadUInt32()
-
-		}
-	}
-	return SarDataSpeedrunTime{
-		NSplits: numberOfSplits,
-		Splits:  splits,
-	}, nil
-}
-
-func parseTimestampData(reader *bitreader.Reader, length uint64) (SarDataTimestamp, error) {
-	if length != 8 {
-		return SarDataTimestamp{}, errors.New("sar data invalid")
-	}
-	timestamp := reader.TryReadBytesToSlice(7)
-	sarDataTimeStamp := SarDataTimestamp{
-		Year:   uint16(timestamp[0]) | uint16(timestamp[1])<<8,
-		Month:  timestamp[2] + 1,
-		Day:    timestamp[3],
-		Hour:   timestamp[4],
-		Minute: timestamp[5],
-		Second: timestamp[6],
-	}
-
-	return sarDataTimeStamp, nil
-}
-
-func parseFileChecksumData(reader *bitreader.Reader, length uint64) (SarDataFileChecksum, error) {
-	if length < 6 {
-		return SarDataFileChecksum{}, errors.New("sar data invalid")
-	}
-	sarDataFileChecksum := SarDataFileChecksum{
-		Sum:  reader.TryReadUInt32(),
-		Path: reader.TryReadString(),
-	}
-
-	return sarDataFileChecksum, nil
-}
diff --git a/pkg/classes/signOn.go b/pkg/classes/signOn.go
deleted file mode 100644
index 5f004c0..0000000
--- a/pkg/classes/signOn.go
+++ /dev/null
@@ -1,43 +0,0 @@
-package classes
-
-import (
-	"github.com/pektezol/bitreader"
-	"github.com/pektezol/demoparser/pkg/messages"
-)
-
-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()},
-	})
-}
diff --git a/pkg/classes/stop.go b/pkg/classes/stop.go
deleted file mode 100644
index 96bc1e4..0000000
--- a/pkg/classes/stop.go
+++ /dev/null
@@ -1,15 +0,0 @@
-package classes
-
-import (
-	"github.com/pektezol/bitreader"
-)
-
-type Stop struct {
-	RemainingData []byte
-}
-
-func (stop *Stop) ParseStop(reader *bitreader.Reader) {
-	if reader.TryReadBool() {
-		stop.RemainingData = reader.TryReadBitsToSlice(uint64(reader.TryReadRemainingBits()))
-	}
-}
diff --git a/pkg/classes/stringTables.go b/pkg/classes/stringTables.go
deleted file mode 100644
index 45954be..0000000
--- a/pkg/classes/stringTables.go
+++ /dev/null
@@ -1,86 +0,0 @@
-package classes
-
-import (
-	"github.com/pektezol/bitreader"
-)
-
-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)
-	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.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()
-	if reader.TryReadBool() {
-		dataLen := reader.TryReadBits(16)
-		stringTableClass.Data = reader.TryReadStringLength(dataLen)
-	}
-}
diff --git a/pkg/classes/syncTick.go b/pkg/classes/syncTick.go
deleted file mode 100644
index 2f9df3e..0000000
--- a/pkg/classes/syncTick.go
+++ /dev/null
@@ -1,5 +0,0 @@
-package classes
-
-type SyncTick struct{}
-
-func (syncTick *SyncTick) ParseSyncTick() {}
diff --git a/pkg/classes/userCmd.go b/pkg/classes/userCmd.go
deleted file mode 100644
index a4bf3d4..0000000
--- a/pkg/classes/userCmd.go
+++ /dev/null
@@ -1,222 +0,0 @@
-package classes
-
-import (
-	"github.com/pektezol/bitreader"
-)
-
-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()
-	}
-}
-
-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"
-)
-- 
cgit v1.2.3