1 files changed, 78 insertions, 32 deletions

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
 }