enable multithreading with goroutines (#20)

1 files changed, 64 insertions, 64 deletions

diff --git a/pkg/classes/stringTables.go b/pkg/classes/stringTables.go
index 7848b1c..6e1510c 100644
--- a/pkg/classes/stringTables.go
+++ b/pkg/classes/stringTables.go
@@ -5,58 +5,58 @@ import (
         "strings"
 
         "github.com/pektezol/bitreader"
-        "github.com/pektezol/sdp.go/pkg/writer"
+        "github.com/pektezol/sdp.go/pkg/types"
 )
 
 type StringTables struct {
-        Size int32
-        Data []StringTable
+        Size int32         `json:"size"`
+        Data []StringTable `json:"data"`
 }
 
 type StringTable struct {
-        Name         string
-        TableEntries []StringTableEntry
-        Classes      []StringTableClass
+        Name         string             `json:"name"`
+        TableEntries []StringTableEntry `json:"table_entries"`
+        Classes      []StringTableClass `json:"classes"`
 }
 
 type StringTableClass struct {
-        Name string
-        Data string
+        Name string `json:"name"`
+        Data string `json:"data"`
 }
 type StringTableEntry struct {
-        Name      string
-        EntryData any
+        Name      string `json:"name"`
+        EntryData any    `json:"entry_data"`
 }
 
-func (stringTables *StringTables) ParseStringTables(reader *bitreader.Reader) {
+func (stringTables *StringTables) ParseStringTables(reader *bitreader.Reader, demo *types.Demo) {
         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)
+                table.ParseStream(stringTableReader, demo)
                 tables[i] = table
         }
         stringTables.Data = tables
 }
 
-func (stringTable *StringTable) ParseStream(reader *bitreader.Reader) {
+func (stringTable *StringTable) ParseStream(reader *bitreader.Reader, demo *types.Demo) {
         stringTable.Name = reader.TryReadString()
         entryCount := reader.TryReadBits(16)
-        writer.AppendLine("\tTable Name: %s", stringTable.Name)
+        demo.Writer.AppendLine("\tTable Name: %s", stringTable.Name)
         stringTable.TableEntries = make([]StringTableEntry, entryCount)
 
         for i := 0; i < int(entryCount); i++ {
                 var entry StringTableEntry
-                entry.Parse(stringTable.Name, reader)
+                entry.Parse(stringTable.Name, reader, demo)
                 stringTable.TableEntries[i] = entry
         }
         if entryCount != 0 {
-                writer.AppendLine("\t\t%d Table Entries:", entryCount)
-                writer.AppendOutputFromTemp()
+                demo.Writer.AppendLine("\t\t%d Table Entries:", entryCount)
+                demo.Writer.AppendOutputFromTemp()
         } else {
-                writer.AppendLine("\t\tNo Table Entries")
+                demo.Writer.AppendLine("\t\tNo Table Entries")
         }
         if reader.TryReadBool() {
                 classCount := reader.TryReadBits(16)
@@ -64,28 +64,28 @@ func (stringTable *StringTable) ParseStream(reader *bitreader.Reader) {
 
                 for i := 0; i < int(classCount); i++ {
                         var class StringTableClass
-                        class.Parse(reader)
+                        class.Parse(reader, demo)
                         stringTable.Classes[i] = class
                 }
-                writer.AppendLine("\t\t%d Classes:", classCount)
-                writer.AppendOutputFromTemp()
+                demo.Writer.AppendLine("\t\t%d Classes:", classCount)
+                demo.Writer.AppendOutputFromTemp()
         } else {
-                writer.AppendLine("\t\tNo Class Entries")
+                demo.Writer.AppendLine("\t\tNo Class Entries")
         }
 }
 
-func (stringTableClass *StringTableClass) Parse(reader *bitreader.Reader) {
+func (stringTableClass *StringTableClass) Parse(reader *bitreader.Reader, demo *types.Demo) {
         stringTableClass.Name = reader.TryReadString()
-        writer.TempAppendLine("\t\t\tName: %s", stringTableClass.Name)
+        demo.Writer.TempAppendLine("\t\t\tName: %s", stringTableClass.Name)
         if reader.TryReadBool() {
                 stringTableClass.Data = reader.TryReadStringLength(uint64(reader.TryReadUInt16()))
-                writer.TempAppendLine("\t\t\tData: %s", stringTableClass.Data)
+                demo.Writer.TempAppendLine("\t\t\tData: %s", stringTableClass.Data)
         }
 }
 
-func (stringTableEntry *StringTableEntry) Parse(tableName string, reader *bitreader.Reader) {
+func (stringTableEntry *StringTableEntry) Parse(tableName string, reader *bitreader.Reader, demo *types.Demo) {
         stringTableEntry.Name = reader.TryReadString()
-        writer.TempAppendLine("\t\t\tName: %s", stringTableEntry.Name)
+        demo.Writer.TempAppendLine("\t\t\tName: %s", stringTableEntry.Name)
         if reader.TryReadBool() {
                 byteLen, err := reader.ReadBits(16)
                 if err != nil {
@@ -94,30 +94,30 @@ func (stringTableEntry *StringTableEntry) Parse(tableName string, reader *bitrea
                 stringTableEntryReader := bitreader.NewReaderFromBytes(reader.TryReadBytesToSlice(byteLen), true)
                 switch tableName {
                 case StringTableUserInfo:
-                        stringTableEntry.ParseUserInfo(stringTableEntryReader)
+                        stringTableEntry.ParseUserInfo(stringTableEntryReader, demo)
                 case StringTableServerQueryInfo:
-                        stringTableEntry.ParseServerQueryInfo(stringTableEntryReader)
+                        stringTableEntry.ParseServerQueryInfo(stringTableEntryReader, demo)
                 case StringTableGameRulesCreation:
-                        stringTableEntry.ParseGamesRulesCreation(stringTableEntryReader)
+                        stringTableEntry.ParseGamesRulesCreation(stringTableEntryReader, demo)
                 case StringTableInfoPanel:
-                        stringTableEntry.ParseInfoPanel(stringTableEntryReader)
+                        stringTableEntry.ParseInfoPanel(stringTableEntryReader, demo)
                 case StringTableLightStyles:
-                        stringTableEntry.ParseLightStyles(stringTableEntryReader)
+                        stringTableEntry.ParseLightStyles(stringTableEntryReader, demo)
                 case StringTableModelPreCache:
-                        stringTableEntry.ParsePrecacheData(stringTableEntryReader)
+                        stringTableEntry.ParsePrecacheData(stringTableEntryReader, demo)
                 case StringTableGenericPreCache:
-                        stringTableEntry.ParsePrecacheData(stringTableEntryReader)
+                        stringTableEntry.ParsePrecacheData(stringTableEntryReader, demo)
                 case StringTableSoundPreCache:
-                        stringTableEntry.ParsePrecacheData(stringTableEntryReader)
+                        stringTableEntry.ParsePrecacheData(stringTableEntryReader, demo)
                 case StringTableDecalPreCache:
-                        stringTableEntry.ParsePrecacheData(stringTableEntryReader)
+                        stringTableEntry.ParsePrecacheData(stringTableEntryReader, demo)
                 default:
-                        stringTableEntry.ParseUnknown(stringTableEntryReader)
+                        stringTableEntry.ParseUnknown(stringTableEntryReader, demo)
                 }
         }
 }
 
-func (stringTableEntry *StringTableEntry) ParseUserInfo(reader *bitreader.Reader) {
+func (stringTableEntry *StringTableEntry) ParseUserInfo(reader *bitreader.Reader, demo *types.Demo) {
         const SignedGuidLen int32 = 32
         const MaxPlayerNameLength int32 = 32
         userInfo := struct {
@@ -147,48 +147,48 @@ func (stringTableEntry *StringTableEntry) ParseUserInfo(reader *bitreader.Reader
         userInfo.FilesDownloaded = reader.TryReadUInt8()
         reader.SkipBytes(3)
         stringTableEntry.EntryData = userInfo
-        writer.TempAppendLine("\t\t\t\tSteam Account ID: %d", uint32((userInfo.SteamID&0xFFFFFFFF00000000)|userInfo.SteamID))
-        writer.TempAppendLine("\t\t\t\tSteam Account Instance: %d", uint32(userInfo.SteamID>>32)&0x000FFFFF)
-        writer.TempAppendLine("\t\t\t\tSteam Account Type: %d", uint32(userInfo.SteamID>>52)&0xF)
-        writer.TempAppendLine("\t\t\t\tSteam Account Universe: %d", uint32(userInfo.SteamID>>56)&0xFF)
-        writer.TempAppendLine("\t\t\t\tName: %s", userInfo.Name)
-        writer.TempAppendLine("\t\t\t\tUser ID: %d", userInfo.UserID)
-        writer.TempAppendLine("\t\t\t\tGUID: %s", userInfo.GUID)
-        writer.TempAppendLine("\t\t\t\tFriends ID: %d", userInfo.FriendsID)
-        writer.TempAppendLine("\t\t\t\tFriends Name: %s", userInfo.FriendsName)
-        writer.TempAppendLine("\t\t\t\tFake Player: %t", userInfo.FakePlayer)
-        writer.TempAppendLine("\t\t\t\tIs Htlv: %t", userInfo.IsHltv)
+        demo.Writer.TempAppendLine("\t\t\t\tSteam Account ID: %d", uint32((userInfo.SteamID&0xFFFFFFFF00000000)|userInfo.SteamID))
+        demo.Writer.TempAppendLine("\t\t\t\tSteam Account Instance: %d", uint32(userInfo.SteamID>>32)&0x000FFFFF)
+        demo.Writer.TempAppendLine("\t\t\t\tSteam Account Type: %d", uint32(userInfo.SteamID>>52)&0xF)
+        demo.Writer.TempAppendLine("\t\t\t\tSteam Account Universe: %d", uint32(userInfo.SteamID>>56)&0xFF)
+        demo.Writer.TempAppendLine("\t\t\t\tName: %s", userInfo.Name)
+        demo.Writer.TempAppendLine("\t\t\t\tUser ID: %d", userInfo.UserID)
+        demo.Writer.TempAppendLine("\t\t\t\tGUID: %s", userInfo.GUID)
+        demo.Writer.TempAppendLine("\t\t\t\tFriends ID: %d", userInfo.FriendsID)
+        demo.Writer.TempAppendLine("\t\t\t\tFriends Name: %s", userInfo.FriendsName)
+        demo.Writer.TempAppendLine("\t\t\t\tFake Player: %t", userInfo.FakePlayer)
+        demo.Writer.TempAppendLine("\t\t\t\tIs Htlv: %t", userInfo.IsHltv)
         if userInfo.CustomFiles != nil {
-                writer.TempAppendLine("\t\t\t\tCustom File CRCs: [logo: 0x%d, sounds: 0x%d, models: 0x%d, txt: 0x%d]", userInfo.CustomFiles[0], userInfo.CustomFiles[1], userInfo.CustomFiles[2], userInfo.CustomFiles[3])
+                demo.Writer.TempAppendLine("\t\t\t\tCustom File CRCs: [logo: 0x%d, sounds: 0x%d, models: 0x%d, txt: 0x%d]", userInfo.CustomFiles[0], userInfo.CustomFiles[1], userInfo.CustomFiles[2], userInfo.CustomFiles[3])
         }
-        writer.TempAppendLine("\t\t\t\tFiles Downloaded: %d", userInfo.FilesDownloaded)
+        demo.Writer.TempAppendLine("\t\t\t\tFiles Downloaded: %d", userInfo.FilesDownloaded)
 }
 
-func (stringTableEntry *StringTableEntry) ParseServerQueryInfo(reader *bitreader.Reader) {
+func (stringTableEntry *StringTableEntry) ParseServerQueryInfo(reader *bitreader.Reader, demo *types.Demo) {
         serverQueryInfo := struct{ Port uint32 }{
                 Port: reader.TryReadUInt32(),
         }
         stringTableEntry.EntryData = serverQueryInfo
-        writer.TempAppendLine("\t\t\t\tPort: %d", serverQueryInfo.Port)
+        demo.Writer.TempAppendLine("\t\t\t\tPort: %d", serverQueryInfo.Port)
 }
 
-func (stringTableEntry *StringTableEntry) ParseGamesRulesCreation(reader *bitreader.Reader) {
+func (stringTableEntry *StringTableEntry) ParseGamesRulesCreation(reader *bitreader.Reader, demo *types.Demo) {
         gamesRulesCreation := struct{ Message string }{
                 Message: reader.TryReadString(),
         }
         stringTableEntry.EntryData = gamesRulesCreation
-        writer.TempAppendLine("\t\t\t\tMessage: %s", gamesRulesCreation.Message)
+        demo.Writer.TempAppendLine("\t\t\t\tMessage: %s", gamesRulesCreation.Message)
 }
 
-func (stringTableEntry *StringTableEntry) ParseInfoPanel(reader *bitreader.Reader) {
+func (stringTableEntry *StringTableEntry) ParseInfoPanel(reader *bitreader.Reader, demo *types.Demo) {
         infoPanel := struct{ Message string }{
                 Message: reader.TryReadString(),
         }
         stringTableEntry.EntryData = infoPanel
-        writer.TempAppendLine("\t\t\t\tMessage: %s", infoPanel.Message)
+        demo.Writer.TempAppendLine("\t\t\t\tMessage: %s", infoPanel.Message)
 }
 
-func (stringTableEntry *StringTableEntry) ParseLightStyles(reader *bitreader.Reader) {
+func (stringTableEntry *StringTableEntry) ParseLightStyles(reader *bitreader.Reader, demo *types.Demo) {
         lightStyles := struct{ Values []byte }{}
         str := reader.TryReadString()
         if len(str) != 0 {
@@ -199,13 +199,13 @@ func (stringTableEntry *StringTableEntry) ParseLightStyles(reader *bitreader.Rea
         }
         stringTableEntry.EntryData = lightStyles
         if lightStyles.Values == nil {
-                writer.TempAppendLine("\t\t\t\t0 Frames (256)")
+                demo.Writer.TempAppendLine("\t\t\t\t0 Frames (256)")
         } else {
-                writer.TempAppendLine("\t\t\t\t%d frames: %v", len(lightStyles.Values), lightStyles.Values)
+                demo.Writer.TempAppendLine("\t\t\t\t%d frames: %v", len(lightStyles.Values), lightStyles.Values)
         }
 }
 
-func (stringTableEntry *StringTableEntry) ParsePrecacheData(reader *bitreader.Reader) {
+func (stringTableEntry *StringTableEntry) ParsePrecacheData(reader *bitreader.Reader, demo *types.Demo) {
         type PrecacheFlag uint16
         const (
                 None           PrecacheFlag = 0
@@ -225,16 +225,16 @@ func (stringTableEntry *StringTableEntry) ParsePrecacheData(reader *bitreader.Re
                 }
                 return flagStrings
         }
-        writer.TempAppendLine("\t\t\t\tFlags: %v", getFlags(PrecacheFlag(precacheData.Flags)))
+        demo.Writer.TempAppendLine("\t\t\t\tFlags: %v", getFlags(PrecacheFlag(precacheData.Flags)))
 }
 
-func (stringTableEntry *StringTableEntry) ParseUnknown(reader *bitreader.Reader) {
+func (stringTableEntry *StringTableEntry) ParseUnknown(reader *bitreader.Reader, demo *types.Demo) {
         unknown := reader.TryReadBitsToSlice(reader.TryReadRemainingBits())
         binaryString := ""
         for _, byteValue := range unknown {
                 binaryString += fmt.Sprintf("%08b ", byteValue)
         }
-        writer.TempAppendLine("\t\t\t\tUnknown: (%s)", strings.TrimSpace(binaryString))
+        demo.Writer.TempAppendLine("\t\t\t\tUnknown: (%s)", strings.TrimSpace(binaryString))
 }
 
 const (