add strings builder, customize ALL outputs (#6)

6 files changed, 253 insertions, 78 deletions

diff --git a/pkg/classes/cmdInfo.go b/pkg/classes/cmdInfo.go
index 545d14b..eccfe99 100644
--- a/pkg/classes/cmdInfo.go
+++ b/pkg/classes/cmdInfo.go
@@ -4,6 +4,7 @@ import (
         "fmt"
 
         "github.com/pektezol/bitreader"
+        "github.com/pektezol/demoparser/pkg/writer"
 )
 
 type CmdInfo struct {
@@ -41,7 +42,7 @@ func (cmdInfoFlags CmdInfoFlags) String() string {
 }
 
 func ParseCmdInfo(reader *bitreader.Reader) CmdInfo {
-        return CmdInfo{
+        cmdInfo := CmdInfo{
                 Flags:            CmdInfoFlags(reader.TryReadUInt32()).String(),
                 ViewOrigin:       []float32{reader.TryReadFloat32(), reader.TryReadFloat32(), reader.TryReadFloat32()},
                 ViewAngles:       []float32{reader.TryReadFloat32(), reader.TryReadFloat32(), reader.TryReadFloat32()},
@@ -50,4 +51,13 @@ func ParseCmdInfo(reader *bitreader.Reader) CmdInfo {
                 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/sarData.go b/pkg/classes/sarData.go
index 35163c3..27e8a64 100644
--- a/pkg/classes/sarData.go
+++ b/pkg/classes/sarData.go
@@ -5,6 +5,7 @@ import (
         "fmt"
 
         "github.com/pektezol/bitreader"
+        "github.com/pektezol/demoparser/pkg/writer"
 )
 
 type SarDataType uint8
@@ -137,12 +138,12 @@ type SarDataSpeedrunTimeSplits struct {
 }
 
 type SarDataTimestamp struct {
-        Year uint16
-        Mon  uint8
-        Day  uint8
-        Hour uint8
-        Min  uint8
-        Sec  uint8
+        Year   uint16
+        Month  uint8
+        Day    uint8
+        Hour   uint8
+        Minute uint8
+        Second uint8
 }
 
 type SarDataFileChecksum struct {
@@ -163,6 +164,7 @@ func (sarData *SarData) ParseSarData(reader *bitreader.Reader) (err error) {
                 len = 9
         }
         dataReader := bitreader.NewReaderFromBytes(reader.TryReadBytesToSlice(len-1), true)
+        writer.AppendLine("\tMessage: %s (%d):", sarData.Type.String(), sarData.Type)
         switch sarData.Type {
         case ESarDataTimescaleCheat:
                 sarData.Data, err = parseTimescaleCheatData(dataReader, len)
@@ -173,6 +175,7 @@ func (sarData *SarData) ParseSarData(reader *bitreader.Reader) (err error) {
                 sarData.Data = parseInitialCVarData(dataReader)
         case ESarDataEntityInputSlot:
                 sarData.Slot = int(dataReader.TryReadBytes(1))
+                writer.AppendLine("\t\tSlot: %d", sarData.Slot)
         case ESarDataEntityInput:
                 sarData.Data = parseEntityInputData(dataReader)
         case ESarDataChecksum:
@@ -198,6 +201,7 @@ func (sarData *SarData) ParseSarData(reader *bitreader.Reader) (err error) {
                 if err != nil {
                         sarData.Data = nil
                 }
+                writer.AppendLine("\t\tSlot: %d", sarData.Slot)
         case ESarDataPause:
                 sarData.Data, err = parsePauseData(dataReader, len)
                 if err != nil {
@@ -239,45 +243,60 @@ func parseTimescaleCheatData(reader *bitreader.Reader, length uint64) (SarDataTi
         if length != 5 {
                 return SarDataTimescaleCheat{}, errors.New("sar data invalid")
         }
-        return SarDataTimescaleCheat{
+        sarDataTimescaleCheat := SarDataTimescaleCheat{
                 Timescale: reader.TryReadFloat32(),
-        }, nil
+        }
+        writer.AppendLine("\t\tTimescale: %f", sarDataTimescaleCheat.Timescale)
+        return sarDataTimescaleCheat, nil
 }
 
 func parseInitialCVarData(reader *bitreader.Reader) SarDataInitialCVar {
-        return SarDataInitialCVar{
+        sarDataInitialCvar := SarDataInitialCVar{
                 CVar: reader.TryReadString(),
                 Val:  reader.TryReadString(),
         }
+        writer.AppendLine("\t\tCvar: \"%s\" = \"%s\"", sarDataInitialCvar.CVar, sarDataInitialCvar.Val)
+        return sarDataInitialCvar
 }
 
 func parseEntityInputData(reader *bitreader.Reader) SarDataEntityInput {
-        return SarDataEntityInput{
+        sarDataEntityInput := SarDataEntityInput{
                 TargetName: reader.TryReadString(),
                 ClassName:  reader.TryReadString(),
                 InputName:  reader.TryReadString(),
                 Parameter:  reader.TryReadString(),
         }
+        writer.AppendLine("\t\tTarget: %s", sarDataEntityInput.TargetName)
+        writer.AppendLine("\t\tClass: %s", sarDataEntityInput.ClassName)
+        writer.AppendLine("\t\tInput: %s", sarDataEntityInput.InputName)
+        writer.AppendLine("\t\tParameter: %s", sarDataEntityInput.Parameter)
+        return sarDataEntityInput
 }
 
 func parseChecksumData(reader *bitreader.Reader, length uint64) (SarDataChecksum, error) {
         if length != 9 {
                 return SarDataChecksum{}, errors.New("sar data invalid")
         }
-        return SarDataChecksum{
+        sarDataChecksum := SarDataChecksum{
                 DemoSum: reader.TryReadUInt32(),
                 SarSum:  reader.TryReadUInt32(),
-        }, nil
+        }
+        writer.AppendLine("\t\tDemo Checksum: %d", sarDataChecksum.DemoSum)
+        writer.AppendLine("\t\tSAR Checksum: %d", sarDataChecksum.SarSum)
+        return sarDataChecksum, nil
 }
 
 func parseChecksumV2Data(reader *bitreader.Reader, length uint64) (SarDataChecksumV2, error) {
         if length != 69 {
                 return SarDataChecksumV2{}, errors.New("sar data invalid")
         }
-        return SarDataChecksumV2{
+        sarDataChecksumV2 := SarDataChecksumV2{
                 SarSum:    reader.TryReadUInt32(),
                 Signature: [64]byte(reader.TryReadBytesToSlice(60)),
-        }, nil
+        }
+        writer.AppendLine("\t\tSAR Checksum: %d", sarDataChecksumV2.SarSum)
+        writer.AppendLine("\t\tSignature: %v", sarDataChecksumV2.Signature)
+        return sarDataChecksumV2, nil
 }
 
 func parsePortalPlacementData(reader *bitreader.Reader, length uint64) (SarDataPortalPlacement, int, error) {
@@ -287,12 +306,17 @@ func parsePortalPlacementData(reader *bitreader.Reader, length uint64) (SarDataP
         slot := int(reader.TryReadBytes(1))
         orange := reader.TryReadBool()
         reader.SkipBits(7)
-        return SarDataPortalPlacement{
+        sarDataPortalPlacement := SarDataPortalPlacement{
                 Orange: orange,
                 X:      reader.TryReadFloat32(),
                 Y:      reader.TryReadFloat32(),
                 Z:      reader.TryReadFloat32(),
-        }, slot, nil
+        }
+        writer.AppendLine("\t\tOrange: %t", orange)
+        writer.AppendLine("\t\tX: %f", sarDataPortalPlacement.X)
+        writer.AppendLine("\t\tY: %f", sarDataPortalPlacement.Y)
+        writer.AppendLine("\t\tZ: %f", sarDataPortalPlacement.Z)
+        return sarDataPortalPlacement, slot, nil
 }
 
 func parseChallengeFlagsCrouchFlyData(reader *bitreader.Reader, length uint64) (int, error) {
@@ -306,29 +330,37 @@ func parsePauseData(reader *bitreader.Reader, length uint64) (SarDataPause, erro
         if length != 5 {
                 return SarDataPause{}, errors.New("sar data invalid")
         }
-        return SarDataPause{
+        sarDataPause := SarDataPause{
                 PauseTicks: reader.TryReadUInt32(),
-        }, nil
+        }
+        writer.AppendLine("\t\tPause Ticks: %d", sarDataPause.PauseTicks)
+        return sarDataPause, nil
 }
 
 func parseWaitRunData(reader *bitreader.Reader, length uint64) (SarDataWaitRun, error) {
         if length < 6 {
                 return SarDataWaitRun{}, errors.New("sar data invalid")
         }
-        return SarDataWaitRun{
+        sarDataWaitRun := SarDataWaitRun{
                 Ticks: int(reader.TryReadUInt32()),
                 Cmd:   reader.TryReadString(),
-        }, nil
+        }
+        writer.AppendLine("\t\tTicks: %d", sarDataWaitRun.Ticks)
+        writer.AppendLine("\t\tCmd: \"%s\"", sarDataWaitRun.Cmd)
+        return sarDataWaitRun, nil
 }
 
 func parseHWaitRunData(reader *bitreader.Reader, length uint64) (SarDataHWaitRun, error) {
         if length < 6 {
                 return SarDataHWaitRun{}, errors.New("sar data invalid")
         }
-        return SarDataHWaitRun{
+        sarDataHWaitRun := SarDataHWaitRun{
                 Ticks: int(reader.TryReadUInt32()),
                 Cmd:   reader.TryReadString(),
-        }, nil
+        }
+        writer.AppendLine("\t\tTicks: %d", sarDataHWaitRun.Ticks)
+        writer.AppendLine("\t\tCmd: \"%s\"", sarDataHWaitRun.Cmd)
+        return sarDataHWaitRun, nil
 }
 
 func parseSpeedrunTimeData(reader *bitreader.Reader, length uint64) (SarDataSpeedrunTime, error) {
@@ -340,10 +372,14 @@ func parseSpeedrunTimeData(reader *bitreader.Reader, length uint64) (SarDataSpee
         for splitCount := 0; splitCount < int(numberOfSplits); splitCount++ {
                 splits[splitCount].Name = reader.TryReadString()
                 splits[splitCount].NSegs = reader.TryReadUInt32()
+                writer.AppendLine("\t\t[%d] Split Name: \"%s\"", splitCount, splits[splitCount].Name)
+                writer.AppendLine("\t\t[%d] Number of Segments: %d", splitCount, splits[splitCount].NSegs)
                 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()
+                        writer.AppendLine("\t\t\t[%d] Segment Name: \"%s\"", segCount, splits[splitCount].Segs[segCount].Name)
+                        writer.AppendLine("\t\t\t[%d] Segment Ticks: %d", segCount, splits[splitCount].Segs[segCount].Ticks)
                 }
         }
         return SarDataSpeedrunTime{
@@ -357,22 +393,32 @@ func parseTimestampData(reader *bitreader.Reader, length uint64) (SarDataTimesta
                 return SarDataTimestamp{}, errors.New("sar data invalid")
         }
         timestamp := reader.TryReadBytesToSlice(7)
-        return SarDataTimestamp{
-                Year: uint16(timestamp[0]) | uint16(timestamp[1])<<8,
-                Mon:  timestamp[2] + 1,
-                Day:  timestamp[3],
-                Hour: timestamp[4],
-                Min:  timestamp[5],
-                Sec:  timestamp[6],
-        }, nil
+        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],
+        }
+        writer.AppendLine("\t\tYear: %d", sarDataTimeStamp.Year)
+        writer.AppendLine("\t\tMonth: %d", sarDataTimeStamp.Month)
+        writer.AppendLine("\t\tDay: %d", sarDataTimeStamp.Day)
+        writer.AppendLine("\t\tHour: %d", sarDataTimeStamp.Hour)
+        writer.AppendLine("\t\tMinute: %d", sarDataTimeStamp.Minute)
+        writer.AppendLine("\t\tSecond: %d", sarDataTimeStamp.Second)
+        return sarDataTimeStamp, nil
 }
 
 func parseFileChecksumData(reader *bitreader.Reader, length uint64) (SarDataFileChecksum, error) {
         if length < 6 {
                 return SarDataFileChecksum{}, errors.New("sar data invalid")
         }
-        return SarDataFileChecksum{
+        sarDataFileChecksum := SarDataFileChecksum{
                 Sum:  reader.TryReadUInt32(),
                 Path: reader.TryReadString(),
-        }, nil
+        }
+        writer.AppendLine("\t\tChecksum: %d", sarDataFileChecksum.Sum)
+        writer.AppendLine("\t\tPath: \"%s\"", sarDataFileChecksum.Path)
+        return sarDataFileChecksum, nil
 }
diff --git a/pkg/classes/sendTable.go b/pkg/classes/sendTable.go
index bc36d75..927d967 100644
--- a/pkg/classes/sendTable.go
+++ b/pkg/classes/sendTable.go
@@ -1,7 +1,10 @@
 package classes
 
 import (
+        "fmt"
+
         "github.com/pektezol/bitreader"
+        "github.com/pektezol/demoparser/pkg/writer"
 )
 
 type SendTable struct {
@@ -12,10 +15,10 @@ type SendTable struct {
 }
 
 type prop struct {
-        SendPropType  int8
+        SendPropType  sendPropType
         SendPropName  string
-        SendPropFlags int32
-        Priority      int8
+        SendPropFlags uint32
+        Priority      uint8
         ExcludeDtName string
         LowValue      float32
         HighValue     float32
@@ -23,84 +26,169 @@ type prop struct {
         NumElements   int32
 }
 
-type sendPropFlag int
+type sendPropType int
 
 const (
-        Unsigned sendPropFlag = iota
-        Coord
-        NoScale
-        RoundDown
-        RoundUp
-        Normal
-        Exclude
-        Xyze
-        InsideArray
-        ProxyAlwaysYes
-        IsVectorElem
-        Collapsible
-        CoordMp
-        CoordMpLp // low precision
-        CoordMpInt
-        CellCoord
-        CellCoordLp
-        CellCoordInt
-        ChangesOften
+        ESendPropTypeInt sendPropType = iota
+        ESendPropTypeFloat
+        ESendPropTypeVector3
+        ESendPropTypeVector2
+        ESendPropTypeString
+        ESendPropTypeArray
+        ESendPropTypeDataTable
 )
 
-type sendPropType int
-
 const (
-        Int sendPropType = iota
-        Float
-        Vector3
-        Vector2
-        String
-        Array
-        DataTable
+        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)),
-                // SendPropType:  int8(reader.TryReadBits(5)),
-                // SendPropName:  reader.TryReadString(),
-                // SendPropFlags: int16(reader.TryReadBits(16)),
         }
         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:  propType,
+                        SendPropType:  sendPropType(propType),
                         SendPropName:  reader.TryReadString(),
-                        SendPropFlags: int32(reader.TryReadBits(19)),
-                        Priority:      int8(reader.TryReadBits(8)),
+                        SendPropFlags: uint32(reader.TryReadBits(19)),
+                        Priority:      reader.TryReadUInt8(),
                 }
-                if propType == int8(DataTable) || CheckBit(int64(prop.SendPropFlags), int(Exclude)) {
+                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(String), int8(Int), int8(Float), int8(Vector3), int8(Vector2):
+                        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(Array):
+                                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 int64, bit int) bool {
-        return (val & (int64(1) << bit)) != 0
+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
index 36bd8b8..c0d2a2a 100644
--- a/pkg/classes/serverClassInfo.go
+++ b/pkg/classes/serverClassInfo.go
@@ -2,6 +2,7 @@ package classes
 
 import (
         "github.com/pektezol/bitreader"
+        "github.com/pektezol/demoparser/pkg/writer"
 )
 
 type ServerClassInfo struct {
@@ -11,11 +12,13 @@ type ServerClassInfo struct {
 }
 
 func ParseServerClassInfo(reader *bitreader.Reader, count int, numOfClasses int) ServerClassInfo {
-        return 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 {
diff --git a/pkg/classes/stringTable.go b/pkg/classes/stringTable.go
index 3983c1f..44d8a73 100644
--- a/pkg/classes/stringTable.go
+++ b/pkg/classes/stringTable.go
@@ -2,6 +2,7 @@ package classes
 
 import (
         "github.com/pektezol/bitreader"
+        "github.com/pektezol/demoparser/pkg/writer"
 )
 
 type StringTable struct {
@@ -38,6 +39,7 @@ func ParseStringTables(reader *bitreader.Reader) []StringTable {
 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++ {
@@ -45,7 +47,12 @@ func (stringTable *StringTable) ParseStream(reader *bitreader.Reader) {
                 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)
@@ -55,6 +62,10 @@ func (stringTable *StringTable) ParseStream(reader *bitreader.Reader) {
                         class.Parse(reader)
                         stringTable.Classes[i] = class
                 }
+                writer.AppendLine("\t\t%d Classes:", classCount)
+                writer.AppendOutputFromTemp()
+        } else {
+                writer.AppendLine("\t\tNo Class Entries")
         }
 }
 
@@ -73,8 +84,10 @@ func (stringTableEntry *StringTableEntry) Parse(reader *bitreader.Reader) {
 
 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/userCmdInfo.go b/pkg/classes/userCmdInfo.go
index 04d76b6..f1bb613 100644
--- a/pkg/classes/userCmdInfo.go
+++ b/pkg/classes/userCmdInfo.go
@@ -4,6 +4,7 @@ import (
         "bytes"
 
         "github.com/pektezol/bitreader"
+        "github.com/pektezol/demoparser/pkg/writer"
 )
 
 type UserCmdInfo struct {
@@ -68,5 +69,19 @@ func ParseUserCmdInfo(data []byte) UserCmdInfo {
         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
 }