enable multithreading with goroutines (#20)

2 files changed, 36 insertions, 95 deletions

diff --git a/pkg/packets/headers.go b/pkg/packets/headers.go
index 6c5ab10..bee8ddf 100644
--- a/pkg/packets/headers.go
+++ b/pkg/packets/headers.go
@@ -2,25 +2,11 @@ package packets
 
 import (
         "github.com/pektezol/bitreader"
-        "github.com/pektezol/sdp.go/pkg/writer"
+        "github.com/pektezol/sdp.go/pkg/types"
 )
 
-type Headers struct {
-        DemoFileStamp   string
-        DemoProtocol    int32
-        NetworkProtocol int32
-        ServerName      string
-        ClientName      string
-        MapName         string
-        GameDirectory   string
-        PlaybackTime    float32
-        PlaybackTicks   int32
-        PlaybackFrames  int32
-        SignOnLength    int32
-}
-
-func ParseHeaders(reader *bitreader.Reader) Headers {
-        headers := Headers{
+func ParseHeaders(reader *bitreader.Reader, demo *types.Demo) types.Headers {
+        headers := types.Headers{
                 DemoFileStamp:   reader.TryReadString(),
                 DemoProtocol:    int32(reader.TryReadSInt32()),
                 NetworkProtocol: int32(reader.TryReadSInt32()),
@@ -42,16 +28,16 @@ func ParseHeaders(reader *bitreader.Reader) Headers {
         if headers.NetworkProtocol != 2001 {
                 panic("this parser only supports demos from portal 2")
         }
-        writer.AppendLine("\nDemo File Stamp: %s", headers.DemoFileStamp)
-        writer.AppendLine("Demo Protocol: %d", headers.DemoProtocol)
-        writer.AppendLine("Network Protocol: %d", headers.NetworkProtocol)
-        writer.AppendLine("Server Name: %s", headers.ServerName)
-        writer.AppendLine("Client Name: %s", headers.ClientName)
-        writer.AppendLine("Map Name: %s", headers.MapName)
-        writer.AppendLine("Game Directory: %s", headers.GameDirectory)
-        writer.AppendLine("Playback Time: %f", headers.PlaybackTime)
-        writer.AppendLine("Playback Ticks: %d", headers.PlaybackTicks)
-        writer.AppendLine("Playback Frames: %d", headers.PlaybackFrames)
-        writer.AppendLine("Sign On Length: %d\n", headers.SignOnLength)
+        demo.Writer.AppendLine("\nDemo File Stamp: %s", headers.DemoFileStamp)
+        demo.Writer.AppendLine("Demo Protocol: %d", headers.DemoProtocol)
+        demo.Writer.AppendLine("Network Protocol: %d", headers.NetworkProtocol)
+        demo.Writer.AppendLine("Server Name: %s", headers.ServerName)
+        demo.Writer.AppendLine("Client Name: %s", headers.ClientName)
+        demo.Writer.AppendLine("Map Name: %s", headers.MapName)
+        demo.Writer.AppendLine("Game Directory: %s", headers.GameDirectory)
+        demo.Writer.AppendLine("Playback Time: %f", headers.PlaybackTime)
+        demo.Writer.AppendLine("Playback Ticks: %d", headers.PlaybackTicks)
+        demo.Writer.AppendLine("Playback Frames: %d", headers.PlaybackFrames)
+        demo.Writer.AppendLine("Sign On Length: %d\n", headers.SignOnLength)
         return headers
 }
diff --git a/pkg/packets/packets.go b/pkg/packets/packets.go
index 1bf3f57..6ae8a44 100644
--- a/pkg/packets/packets.go
+++ b/pkg/packets/packets.go
@@ -3,100 +3,55 @@ package packets
 import (
         "github.com/pektezol/bitreader"
         "github.com/pektezol/sdp.go/pkg/classes"
-        "github.com/pektezol/sdp.go/pkg/writer"
+        "github.com/pektezol/sdp.go/pkg/types"
 )
 
-type MessageType uint8
-
-const (
-        SignOn MessageType = iota + 1
-        Packet
-        SyncTick
-        ConsoleCmd
-        UserCmd
-        DataTables
-        Stop
-        CustomData
-        StringTables
-)
-
-type Message struct {
-        PacketType MessageType
-        TickNumber int32
-        SlotNumber uint8
-        Data       any
-}
-
-func ParseMessage(reader *bitreader.Reader) Message {
-        message := Message{
-                PacketType: MessageType(reader.TryReadUInt8()),
+func ParseMessage(reader *bitreader.Reader, demo *types.Demo) types.Message {
+        message := types.Message{
+                PacketType: types.MessageType(reader.TryReadUInt8()),
                 TickNumber: reader.TryReadSInt32(),
                 SlotNumber: reader.TryReadUInt8(),
         }
-        writer.AppendLine("[%d] %s (%d):", message.TickNumber, message.PacketType.String(), message.PacketType)
+        demo.Writer.AppendLine("[%d] %s (%d):", message.TickNumber, message.PacketType.String(), message.PacketType)
         switch message.PacketType {
-        case SignOn:
+        case types.SignOn:
                 signOn := classes.SignOn{}
-                signOn.ParseSignOn(reader)
+                signOn.ParseSignOn(reader, demo)
                 message.Data = signOn
-        case Packet:
+        case types.Packet:
                 packet := classes.Packet{}
-                packet.ParsePacket(reader)
+                packet.ParsePacket(reader, demo)
                 message.Data = packet
-        case SyncTick:
+        case types.SyncTick:
                 syncTick := classes.SyncTick{}
                 syncTick.ParseSyncTick()
                 message.Data = syncTick
-        case ConsoleCmd:
+        case types.ConsoleCmd:
                 consoleCmd := classes.ConsoleCmd{}
-                consoleCmd.ParseConsoleCmd(reader)
+                consoleCmd.ParseConsoleCmd(reader, demo)
                 message.Data = consoleCmd
-        case UserCmd:
+        case types.UserCmd:
                 userCmd := classes.UserCmd{}
-                userCmd.ParseUserCmd(reader)
+                userCmd.ParseUserCmd(reader, demo)
                 message.Data = userCmd
-        case DataTables:
+        case types.DataTables:
                 dataTables := classes.DataTables{}
-                dataTables.ParseDataTables(reader)
+                dataTables.ParseDataTables(reader, demo)
                 message.Data = dataTables
-        case Stop:
+        case types.Stop:
                 stop := classes.Stop{}
-                stop.ParseStop(reader)
+                stop.ParseStop(reader, demo)
                 message.Data = stop
-        case CustomData: // TODO: not sar data
+        case types.CustomData: // TODO: not sar data
                 customData := classes.CustomData{}
-                customData.ParseCustomData(reader, message.TickNumber, uint8(message.PacketType))
+                customData.ParseCustomData(reader, message.TickNumber, uint8(message.PacketType), demo)
                 message.Data = customData
-        case StringTables: // TODO: parsing string table data
+        case types.StringTables: // TODO: parsing string table data
                 stringTables := classes.StringTables{}
-                stringTables.ParseStringTables(reader)
+                stringTables.ParseStringTables(reader, demo)
                 message.Data = stringTables
         default:
                 panic("invalid packet type")
         }
         return message
 }
-
-func (t MessageType) String() string {
-        switch t {
-        case SignOn:
-                return "SIGNON"
-        case Packet:
-                return "PACKET"
-        case SyncTick:
-                return "SYNCTICK"
-        case ConsoleCmd:
-                return "CONSOLECMD"
-        case UserCmd:
-                return "USERCMD"
-        case DataTables:
-                return "DATATABLES"
-        case Stop:
-                return "STOP"
-        case CustomData:
-                return "CUSTOMDATA"
-        case StringTables:
-                return "STRINGTABLES"
-        }
-        return "INVALID"
-}