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)

---
 pkg/packets/packets.go | 125 +++++++++----------------------------------------
 1 file changed, 21 insertions(+), 104 deletions(-)

(limited to 'pkg/packets/packets.go')

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,
 	}
 }
-- 
cgit v1.2.3