bump the SDK versions

Reviewed-on: #3

.gitignore

@@ -1,2 +1,4 @@
 *.bin
 *.work*
+*.pprof
+*.log

README.md

@@ -12,16 +12,22 @@ without having to be playing the game while doing it (fans are noisy).
 
 # Usage
 To start replaying:
-`BeamNGMockOg replay [--loop] -a 127.0.0.1 -p 4443 -i sunburstManual.bin`
+`telemetrymockserver beamng replay [--loop] -a 127.0.0.1 -p 4443 -i sunburstManual.bin`
 - `loop` allows the replay functionality to keep replaying the same data file
 
+
 To start recording:
-`BeamNGMockOg record -a 127.0.0.1 -p 4443 -o sunburstDCT.bin`
+`BeamNGMockOg beamng record -a 127.0.0.1 -p 4443 -o sunburstDCT.bin`
 
 ## Development
 Use `tcpdump` to listen to the socket and check if data is coming through:
 `tcpdump -i any udp port <port> -X`
 
+### TODO:
+- [ ] Create the auto completion file and add it to `$FPATH`
+- [ ] Create a shortcut so we don't have to type out `telemetrymockserver` everytime
+
+
 ### Benchmark
 Run with:
 `go test ./mockserver -bench=BenchmarkReplayAsync -benchmem -benchtime=1x -memprofile=mem.pprof`
@@ -33,16 +39,10 @@ Analyze the output with:
 or
 `go tool pprof -http=:8080 mem.pprof`
 
-#### Previous results:
-goos: linux
-goarch: amd64
-pkg: github.com/ESilva15/BeamNGMockOg/mockserver
-cpu: AMD Ryzen 5 5600G with Radeon Graphics
-BenchmarkReplayAsync-12    	      1	109433574741 ns/op	4533008 B/op	  66059 allocs/op
-PASS
-ok  	github.com/ESilva15/BeamNGMockOg/mockserver	109.438s
 
-#### Current results
+#### Previous results:
+Note: this were made before introducing the real time visualizer
+```
 goos: linux
 goarch: amd64
 pkg: github.com/ESilva15/BeamNGMockOg/mockserver
@@ -50,3 +50,16 @@ cpu: AMD Ryzen 5 5600G with Radeon Graphics
 BenchmarkReplayAsync-12    	      1	109433931841 ns/op	 356088 B/op	  13272 allocs/op
 PASS
 ok  	github.com/ESilva15/BeamNGMockOg/mockserver	109.440s
+```
+
+
+#### Current results
+```
+goos: linux
+goarch: amd64
+pkg: github.com/ESilva15/BeamNGMockOg/mockserver
+cpu: AMD Ryzen 7 5800X3D 8-Core Processor
+BenchmarkReplayAsync-16    	      1	109433890158 ns/op	1673128 B/op	 112986 allocs/op
+PASS
+ok  	github.com/ESilva15/BeamNGMockOg/mockserver	109.439s
+```

cmd/beamng.go

@@ -0,0 +1,94 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+	"log/slog"
+
+	beamng "github.com/ESilva15/TelemetryMockserver/internal/mockservers/beamng"
+
+	"github.com/spf13/cobra"
+)
+
+// beamNGCmd is the parent command for the BeamNG agent actions
+var beamNGCmd = &cobra.Command{
+	Use:   "beamng",
+	Short: "BeamNG telemetry utilities",
+	Args:  nil,
+}
+
+var beamNGRecordCMD = &cobra.Command{
+	Use:   "record",
+	Short: "record -o <path-to-output-file>",
+	Long: `record will store the data from the given UDP server to the 
+	filepath given by -o`,
+	Args: nil,
+	Run:  recordAction,
+}
+
+var beamNGReplayCMD = &cobra.Command{
+	Use:   "replay",
+	Short: "replay -i <path-to-input-file>",
+	Long:  "replay will replay the data on the given filepath on a UDP server",
+	Args:  nil,
+	Run:   replayAction,
+}
+
+func recordAction(cmd *cobra.Command, args []string) {
+	outputFile, _ := cmd.Flags().GetString("output")
+	address, _ := cmd.Flags().GetString("address")
+	port, _ := cmd.Flags().GetInt("port")
+
+	recorder, err := beamng.NewRecorder(outputFile, address, port)
+	if err != nil {
+		panic(fmt.Sprintf("failed to create new BeamNG recorder: %+v", err))
+	}
+	defer recorder.Close()
+
+	// NOTE: is this doing anything at all??
+	ctx := context.Background()
+	if err := recorder.Record(ctx); err != nil {
+		fmt.Printf("Something went wrong while recording the file: %v", err)
+	}
+}
+
+func replayAction(cmd *cobra.Command, args []string) {
+	inputFile, _ := cmd.Flags().GetString("input")
+	address, _ := cmd.Flags().GetString("address")
+	port, _ := cmd.Flags().GetInt("port")
+	loop, _ := cmd.Flags().GetBool("loop")
+
+	replayer, err := beamng.NewReplayer(address, port, inputFile)
+	if err != nil {
+		slog.Error("Something went wrong setting up the player", "err", err)
+		return
+	}
+
+	// NOTE: is this doing anything at all??
+	ctx := context.Background()
+	err = replayer.Replay(ctx, loop)
+	if err != nil {
+		slog.Error("Something went wrong while playing the file", "err", err)
+		return
+	}
+}
+
+func init() {
+	// Beamng commnad flags
+	beamNGCmd.PersistentFlags().StringP("address", "a", "127.0.0.1", "Address for the UDP server")
+	beamNGCmd.MarkFlagRequired("address")
+	beamNGCmd.PersistentFlags().IntP("port", "p", 4444, "Port for the UDP server")
+	beamNGCmd.MarkFlagRequired("port")
+
+	// Record command flags
+	beamNGRecordCMD.Flags().StringP("output", "o", "output.bin", "output file for recording")
+	beamNGRecordCMD.MarkFlagRequired("output")
+
+	// Replay command flags
+	beamNGReplayCMD.Flags().BoolP("loop", "l", false, "whether to loop the recording")
+	beamNGReplayCMD.Flags().StringP("input", "i", "input.bin", "input file for reading")
+	beamNGReplayCMD.MarkFlagRequired("input")
+
+	rootCmd.AddCommand(beamNGCmd)
+	beamNGCmd.AddCommand(beamNGRecordCMD, beamNGReplayCMD)
+}

cmd/cmd.go

@@ -9,8 +9,8 @@ import (
 
 // rootCmd represents the base command when called without any subcommands
 var rootCmd = &cobra.Command{
-	Use:   "bngmock",
+	Use:   "telemetrymockserver",
-	Short: "CLI for a BeamNG OG mockserver",
+	Short: "CLI for mocking and recording data from different sources. Primarily for simracing",
 	Long:  ``,
 }
 

cmd/iracing.go

@@ -0,0 +1,54 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/ESilva15/TelemetryMockserver/internal/mockservers/iracing"
+	"github.com/spf13/cobra"
+)
+
+// beamNGCmd is the parent command for the BeamNG agent actions
+var iracingCmd = &cobra.Command{
+	Use:   "iracing",
+	Short: "iRacing telemetry utility",
+	Args:  nil,
+}
+
+var iracingReplayCMD = &cobra.Command{
+	Use:   "replay",
+	Short: "replay -i <input-file> -o <output-memory-map-file>",
+	Long:  "replays the <input-file> in the <output-memory-map-file>",
+	Args:  nil,
+	Run:   iracingReplayAction,
+}
+
+func iracingReplayAction(cmd *cobra.Command, args []string) {
+	// We need to get the path of the ibt.file
+	// outputFile, _ := cmd.Flags().GetString("output")
+	// inputFile, _ := cmd.Flags().GetString("input")
+
+	replayer, err := iracing.NewReplayer("", "")
+	if err != nil {
+		fmt.Printf("Something went wrong setting up the player: %+v", err)
+		return
+	}
+
+	// NOTE: is this doing anything at all??
+	ctx := context.Background()
+	if err := replayer.Replay(ctx, false); err != nil {
+		fmt.Printf("Something went wrong while playing the file: %v", err)
+	}
+}
+
+func init() {
+	rootCmd.AddCommand(iracingCmd)
+
+	iracingCmd.AddCommand(iracingReplayCMD)
+
+	// iracingReplayCMD flags
+	iracingReplayCMD.Flags().StringP("input", "i", "input.ibt", "input file")
+	// iracingReplayCMD.MarkFlagRequired("input")
+	iracingReplayCMD.Flags().StringP("output", "o", "memmap.file", "output memory mapped file")
+	// iracingReplayCMD.MarkFlagRequired("output")
+}

cmd/record.go

@@ -1,44 +0,0 @@
-package cmd
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/ESilva15/BeamNGMockOg/mockserver"
-
-	"github.com/spf13/cobra"
-)
-
-func recordAction(cmd *cobra.Command, args []string) {
-	outputFile, _ := cmd.Flags().GetString("output")
-	address, _ := cmd.Flags().GetString("address")
-	port, _ := cmd.Flags().GetInt("port")
-
-	recorder, err := mockserver.NewRecorder(outputFile, address, port)
-	if err != nil {
-		panic(fmt.Sprintf("failed to create new BeamNG recorder: %+v", err))
-	}
-	defer recorder.Close()
-
-	// NOTE: is this doing anything at all??
-	ctx := context.Background()
-	if err := recorder.Record(ctx); err != nil {
-		fmt.Printf("Something went wrong while recording the file: %v", err)
-	}
-}
-
-// shelf
-var recordCmd = &cobra.Command{
-	Use:   "record",
-	Short: "record -o <path-to-bin-file>",
-	Long: `record will store the data from the given UDP server to the 
-	filepath given by -i`,
-	Args: nil,
-	Run:  recordAction,
-}
-
-func init() {
-	rootCmd.AddCommand(recordCmd)
-
-	recordCmd.PersistentFlags().StringP("output", "o", "output.bin", "output file for recording")
-}

cmd/replay.go

@@ -1,45 +0,0 @@
-package cmd
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/ESilva15/BeamNGMockOg/mockserver"
-
-	"github.com/spf13/cobra"
-)
-
-func replayAction(cmd *cobra.Command, args []string) {
-	inputFile, _ := cmd.Flags().GetString("input")
-	address, _ := cmd.Flags().GetString("address")
-	port, _ := cmd.Flags().GetInt("port")
-	loop, _ := cmd.Flags().GetBool("loop")
-
-	replayer, err := mockserver.NewReplayer(address, port, inputFile)
-	if err != nil {
-		fmt.Printf("Something went wrong setting up the player: %+v", err)
-		return
-	}
-
-	// NOTE: is this doing anything at all??
-	ctx := context.Background()
-	if err := replayer.Replay(ctx, loop); err != nil {
-		fmt.Printf("Something went wrong while playing the file: %v", err)
-	}
-}
-
-// shelf
-var replayCmd = &cobra.Command{
-	Use:   "replay",
-	Short: "replay -i <path-to-bin-file>",
-	Long:  `replay will replay the data on the given filepath on a UDP server`,
-	Args:  nil,
-	Run:   replayAction,
-}
-
-func init() {
-	rootCmd.AddCommand(replayCmd)
-
-	replayCmd.PersistentFlags().StringP("input", "i", "nofile.bin", "input file for serving")
-	replayCmd.PersistentFlags().BoolP("loop", "l", false, "loop replay after finishing")
-}

constants/constants.go

@@ -0,0 +1,3 @@
+package constants
+
+const ProgramName = "TelemetryMockserver"

go.mod

@@ -1,13 +1,17 @@
-module github.com/ESilva15/BeamNGMockOg
+module github.com/ESilva15/TelemetryMockserver
 
 go 1.23.2
 
 require (
-	github.com/ESilva15/gobngsdk v1.1.1
+	github.com/ESilva15/gobngsdk v1.2.0
+	github.com/ESilva15/goirsdk v0.3.8
 	github.com/spf13/cobra v1.10.1
 )
 
 require (
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
 	github.com/spf13/pflag v1.0.9 // indirect
+	golang.org/x/sys v0.29.0 // indirect
+	golang.org/x/text v0.19.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -1,6 +1,10 @@
-github.com/ESilva15/gobngsdk v1.1.1 h1:MyKUjIqG77lYcUY6cnZpnnxPoxS/FdAYwGoi6InXan0=
+github.com/ESilva15/gobngsdk v1.2.0 h1:jX2ByFaIHnjCdPmrj1JiqCoNRLyu4vqIXC7++EUOCK4=
-github.com/ESilva15/gobngsdk v1.1.1/go.mod h1:cKLaZRgM0tGGXDvosaSjHnxeyC5Y6rg7zCLqEUJnOzw=
+github.com/ESilva15/gobngsdk v1.2.0/go.mod h1:cKLaZRgM0tGGXDvosaSjHnxeyC5Y6rg7zCLqEUJnOzw=
+github.com/ESilva15/goirsdk v0.3.8 h1:Eiabg4TqMkJQCImLEqwN93/BAuafbYyTrNXxg/Ck9bQ=
+github.com/ESilva15/goirsdk v0.3.8/go.mod h1:5borQbw+L4fe9b58JFHRHZwrzz0sMVAteuYbRnFOc0Q=
 github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g=
+github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
+github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
 github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
 github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
@@ -8,5 +12,11 @@ github.com/spf13/cobra v1.10.1 h1:lJeBwCfmrnXthfAupyUTzJ/J4Nc1RsHC/mSRU2dll/s=
 github.com/spf13/cobra v1.10.1/go.mod h1:7SmJGaTHFVBY0jW4NXGluQoLvhqFQM+6XSKD+P4XaB0=
 github.com/spf13/pflag v1.0.9 h1:9exaQaMOCwffKiiiYk6/BndUBv+iRViNW+4lEMi0PvY=
 github.com/spf13/pflag v1.0.9/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+golang.org/x/sys v0.29.0 h1:TPYlXGxvx1MGTn2GiZDhnjPA9wZzZeGKHHmKhHYvgaU=
+golang.org/x/sys v0.29.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/text v0.19.0 h1:kTxAhCbGbxhK0IwgSKiMO5awPoDQ0RpfiVYBfK860YM=
+golang.org/x/text v0.19.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

internal/mockservers/beamng/record.go

@@ -0,0 +1,114 @@
+package mockserver
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"log/slog"
+	"os"
+	"sync"
+	"time"
+
+	"github.com/ESilva15/TelemetryMockserver/constants"
+	bngsdk "github.com/ESilva15/gobngsdk"
+)
+
+type recorderViewData struct {
+	TotalBytes int64
+	Og         bngsdk.Outgauge
+}
+
+type Recorder struct {
+	SDK *bngsdk.BeamNGSDK
+	// Views
+	mut         sync.RWMutex
+	viewDataMut sync.RWMutex
+	viewData    recorderViewData
+	viewCh      chan *recorderViewData
+}
+
+func NewRecorder(fp string, address string, port int) (*Recorder, error) {
+	var recorder Recorder
+	var err error
+
+	recorder.SDK, err = bngsdk.NewBngSDK(bngsdk.Options{
+		Logger:           slog.Default().With("SDK", "BeamNG"),
+		SourceType:       bngsdk.UDPData,
+		ImportUDPAddress: address,
+		ImportUDPPort:    port,
+		ExportData:       true,
+		ExportDataType:   bngsdk.BinaryFile,
+		ExportDataPath:   fp,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	recorder.viewData = recorderViewData{}
+	recorder.viewCh = make(chan *recorderViewData, 1)
+
+	return &recorder, nil
+}
+
+func (r *Recorder) Close() {
+	r.SDK.Close()
+}
+
+func (r *Recorder) view(ctx context.Context) {
+	var buf bytes.Buffer
+
+	buf.Grow(2048)
+
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case viewData := <-r.viewCh:
+			buf.Reset()
+			buf.WriteString("\x1b[2J\x1b[H")
+			fmt.Fprintf(&buf, "\x1b]0;%s - Recording ", constants.ProgramName)
+			stringifyRecordingProgress(&buf, viewData.TotalBytes)
+			fmt.Fprintf(&buf, "\x07")
+
+			stringifyRecordingProgress(&buf, viewData.TotalBytes)
+			fmt.Fprintf(&buf, "\n\n")
+
+			r.viewDataMut.RLock()
+			stringifyOutgaugeData(&buf, &viewData.Og)
+			r.viewDataMut.RUnlock()
+
+			_, _ = buf.WriteTo(os.Stdout)
+		}
+	}
+}
+
+// Record records data from the UDP connection created by address and port
+func (r *Recorder) Record(ctx context.Context) error {
+	ticker := time.NewTicker(time.Second / 60)
+	defer ticker.Stop()
+
+	go r.view(ctx)
+
+	for {
+		select {
+		case <-ctx.Done():
+			return nil
+		case <-ticker.C:
+			og, err := r.SDK.Update()
+			if err != nil {
+				return err
+			}
+
+			r.viewData.TotalBytes = r.SDK.GetTotalWritten()
+			r.viewData.Og = *og
+
+			// Send the data to the view
+			select {
+			case r.viewCh <- &r.viewData:
+				// Sent the data
+			default:
+				// Dropped the frame!
+			}
+		}
+	}
+}

internal/mockservers/beamng/replay.go

@@ -0,0 +1,124 @@
+// Package mockserver is the core of this program and it will have the API
+// to record binary data from the UDP server and then be able to mock it
+package mockserver
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"log/slog"
+	"math"
+	"os"
+	"sync"
+	"time"
+
+	"github.com/ESilva15/TelemetryMockserver/constants"
+	bngsdk "github.com/ESilva15/gobngsdk"
+)
+
+type ViewData struct {
+	Outgauge bngsdk.Outgauge
+	SizeRead int64
+	FileSize int64
+}
+
+// Replayer does the replaying
+// Should we make a "player" struct that can record and replay?
+type Replayer struct {
+	SDK *bngsdk.BeamNGSDK
+
+	// Streams
+	dataViewCh chan ViewData
+
+	// Mut
+	mut sync.RWMutex
+
+	// View
+	viewData ViewData
+}
+
+func NewReplayer(address string, port int, fp string) (*Replayer, error) {
+	sdk, err := bngsdk.NewBngSDK(bngsdk.Options{
+		Logger:           slog.Default().With("SDK", "BeamNG"),
+		SourceType:       bngsdk.BinaryFile,
+		BinSourcePath:    fp,
+		ExportData:       true,
+		ExportDataType:   bngsdk.UDPData,
+		ExportUDPAddress: address,
+		ExportUDPPort:    port,
+		Loop:             true,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	replayer := &Replayer{
+		SDK:        sdk,
+		dataViewCh: make(chan ViewData, 1),
+	}
+
+	return replayer, nil
+}
+
+// renderToTerminal will render the data for the users viewing pleasure
+func (r *Replayer) renderToTerminal(ctx context.Context) {
+	var buf bytes.Buffer
+	buf.Grow(2048)
+
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case data := <-r.dataViewCh:
+			// Reset to the start of the terminal
+			// percent := int(float64(data.SizeRead) / float64(data.FileSize) * 100)
+			percent := int(math.Round((float64(data.SizeRead) / float64(data.FileSize)) * 100))
+
+			buf.Reset()
+			buf.WriteString("\x1b[2J\x1b[H")
+			fmt.Fprintf(&buf, "\x1b]0;%s - Replaying %d%%\x07", constants.ProgramName, percent)
+
+			fmt.Fprintf(&buf, "Replayed: %d%%\n", percent)
+
+			stringifyOutgaugeData(&buf, &data.Outgauge)
+
+			buf.WriteTo(os.Stdout)
+		}
+	}
+}
+
+// Replay replays a given file <fp> in a UDP server <addr>:<port>
+func (r *Replayer) Replay(ctx context.Context, loop bool) error {
+	go r.renderToTerminal(ctx)
+
+	ticker := time.NewTicker(time.Second / 60)
+	defer ticker.Stop()
+	for {
+		select {
+		case <-ctx.Done():
+			return ctx.Err()
+
+		case <-ticker.C:
+			og, err := r.SDK.Update()
+			if err != nil {
+				// TODO: log here
+				slog.Error("an error occurred when updating", "err", err)
+				return err
+			}
+
+			r.mut.Lock()
+			r.viewData.SizeRead = r.SDK.GetTotalRead()
+			r.viewData.FileSize = r.SDK.GetSourceSize()
+			r.viewData.Outgauge = *og
+			r.mut.Unlock()
+
+			// Send the data to the view
+			select {
+			case r.dataViewCh <- r.viewData:
+				// Sent the data
+			default:
+				// Dropped the frame!
+			}
+		}
+	}
+}

internal/mockservers/beamng/views.go

@@ -0,0 +1,89 @@
+package mockserver
+
+import (
+	"bytes"
+	"fmt"
+
+	bngsdk "github.com/ESilva15/gobngsdk"
+)
+
+const (
+	_   = iota
+	KiB = 1 << (10 * iota)
+	MiB
+	GiB
+)
+
+func stringifyRecordingProgress(s *bytes.Buffer, nBytes int64) {
+	if nBytes < KiB {
+		fmt.Fprintf(s, "%d B", nBytes)
+	} else if nBytes < MiB {
+		fmt.Fprintf(s, "%.2f KiB", float64(nBytes)/float64(KiB))
+	} else if nBytes < GiB {
+		fmt.Fprintf(s, "%.2f MiB", float64(nBytes)/float64(MiB))
+	} else {
+		fmt.Fprintf(s, "%.2f GiB", float64(nBytes)/float64(GiB))
+	}
+}
+
+func stringifyOutgaugeData(s *bytes.Buffer, og *bngsdk.Outgauge) {
+	// NOTE: write a string serialization function on the SDK itself
+	fmt.Fprint(s, "Outgauge {\n")
+	fmt.Fprintf(s, "  Time:        %d ms\n", og.Time)
+	fmt.Fprintf(s, "  Car:         %s\n", og.Car)
+	fmt.Fprintf(s, "  Flags:       %b\n", og.Flags)
+	fmt.Fprintf(s, "  Gear:        %d\n", og.Gear)
+	fmt.Fprintf(s, "  Plid:        %d\n", og.Plid)
+	fmt.Fprintf(s, "  Speed:       %f m/s\n", og.Speed)
+	fmt.Fprintf(s, "  RPM:         %f RPM\n", og.RPM)
+	fmt.Fprintf(s, "  Turbo:       %f Bar\n", og.Turbo)
+	fmt.Fprintf(s, "  EngTemp:     %f °C\n", og.EngTemp)
+	fmt.Fprintf(s, "  Fuel:        %f\n", og.Fuel)
+	fmt.Fprintf(s, "  OilPressure: %f Bar\n", og.OilPressure)
+	fmt.Fprintf(s, "  OilTemp:     %f °C\n", og.OilTemp)
+	fmt.Fprintf(s, "  DashLights:  %b\n", og.DashLights)
+	fmt.Fprintf(s, "  ShowLights:  %b\n", og.ShowLights)
+	fmt.Fprintf(s, "  Throttle:    %f\n", og.Throttle)
+	fmt.Fprintf(s, "  Brakes:      %f\n", og.Brake)
+	fmt.Fprintf(s, "  Clutch:      %f\n", og.Clutch)
+	fmt.Fprintf(s, "  Display1:    %s\n", og.Display1)
+	fmt.Fprintf(s, "  Display2:    %s\n", og.Display2)
+	fmt.Fprintf(s, "  ID:          %d\n", og.ID)
+	fmt.Fprint(s, "}\n\n")
+
+	fmt.Fprint(s, "DashLights {\n")
+	fmt.Fprintf(s, "  DL_SHIFT:      %t\n", og.HasShiftLight())
+	fmt.Fprintf(s, "  DL_FULLBEAM:   %t\n", og.HasHighBeamLight())
+	fmt.Fprintf(s, "  DL_HANDBRAKE:  %t\n", og.HasHandbrakeLight())
+	fmt.Fprintf(s, "  DL_PITSPEED:   %t\n", og.HasPitspeed())
+	fmt.Fprintf(s, "  DL_TC:         %t\n", og.HasTractionControlLight())
+	fmt.Fprintf(s, "  DL_SIGNAL_L:   %t\n", og.HasLeftIndicatorLight())
+	fmt.Fprintf(s, "  DL_SIGNAL_R:   %t\n", og.HasRightIndicatorLight())
+	fmt.Fprintf(s, "  DL_SIGNAL_ANY: %t\n", og.HasAnyIndicatorLight())
+	fmt.Fprintf(s, "  DL_OILWARN:    %t\n", og.HasOilLight())
+	fmt.Fprintf(s, "  DL_BATTERY:    %t\n", og.HasBatteryLight())
+	fmt.Fprintf(s, "  DL_ABS:        %t\n", og.HasABSLight())
+	fmt.Fprintf(s, "  DL_SPARE:      %t\n", og.HasSpare())
+	fmt.Fprint(s, "}\n\n")
+
+	fmt.Fprint(s, "ShowLights {\n") // Fixed typo "ShowLigths"
+	fmt.Fprintf(s, "  DL_SHIFT:      %t\n", og.ShiftLight())
+	fmt.Fprintf(s, "  DL_FULLBEAM:   %t\n", og.HighBeam())
+	fmt.Fprintf(s, "  DL_HANDBRAKE:  %t\n", og.Handbrake())
+	fmt.Fprintf(s, "  DL_PITSPEED:   %t\n", og.Pitspeed())
+	fmt.Fprintf(s, "  DL_TC:         %t\n", og.TractionControl())
+	fmt.Fprintf(s, "  DL_SIGNAL_L:   %t\n", og.LeftIndicator())
+	fmt.Fprintf(s, "  DL_SIGNAL_R:   %t\n", og.RightIndicator())
+	fmt.Fprintf(s, "  DL_SIGNAL_ANY: %t\n", og.AnyIndicator())
+	fmt.Fprintf(s, "  DL_OILWARN:    %t\n", og.OilLight())
+	fmt.Fprintf(s, "  DL_BATTERY:    %t\n", og.BatteryLight())
+	fmt.Fprintf(s, "  DL_ABS:        %t\n", og.ABS())
+	fmt.Fprintf(s, "  DL_SPARE:      %t\n", og.Spare())
+	fmt.Fprint(s, "}\n\n")
+
+	fmt.Fprint(s, "Flags {\n")
+	fmt.Fprintf(s, "  OG_TURBO (Has Turbo): %t\n", og.HasTurbo())
+	fmt.Fprintf(s, "  OG_KM (Is Metric):    %t\n", og.PrefersKm())
+	fmt.Fprintf(s, "  OG_BAR (Pressure):    %t\n", og.PrefersBAR())
+	fmt.Fprint(s, "}")
+}

internal/mockservers/iracing/replay.go

@@ -0,0 +1,94 @@
+package iracing
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"log/slog"
+	"sync"
+	"time"
+
+	"github.com/ESilva15/goirsdk"
+)
+
+type Replayer struct {
+	SDK *goirsdk.IBT
+	// DataSourcePath string
+	// Socket         *UDPTransport
+
+	// Output memory mapped file
+	outputMmap string
+
+	// Streams
+	// dataViewCh chan ViewData
+	// socketCh   chan []byte
+
+	// Mut
+	mut sync.RWMutex
+
+	// View
+	// viewData ViewData
+}
+
+func NewReplayer(input string, output string) (*Replayer, error) {
+	ibt, err := goirsdk.Init(goirsdk.Options{
+		Logger:        slog.Default(),
+		SourceType:    goirsdk.IBTFile,
+		SourcePath:    "../testTelemetry/gt3_mustang_bathurst.ibt",
+		IBTExportType: goirsdk.SharedMemoryFile,
+		IBTExport:     true,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	replayer := &Replayer{
+		SDK: ibt,
+	}
+
+	return replayer, nil
+}
+
+func (r *Replayer) Replay(ctx context.Context, loop bool) error {
+	mainLoopTicker := time.NewTicker(time.Second / 240)
+	defer mainLoopTicker.Stop()
+
+	for {
+		// Update the data that the SDK is holding with the next tick
+		_, err := r.SDK.Update(100 * time.Millisecond)
+		if err != nil {
+			log.Printf("could not update data: %v", err)
+			continue
+		}
+
+		// Vehicle Movement data gathered from the names we can find on the
+		// telemetry_docs.pdf file
+		// - I wish to make this less verbose if possible
+		if _, ok := r.SDK.Vars.Vars["Gear"]; !ok {
+			log.Fatal("Field `Gear` doesn't exist")
+		}
+
+		if _, ok := r.SDK.Vars.Vars["RPM"]; !ok {
+			log.Fatal("Field `RPM` doesn't exist")
+		}
+
+		if _, ok := r.SDK.Vars.Vars["Speed"]; !ok {
+			log.Fatal("Field `Speed` doesn't exist")
+		}
+
+		gear := int32(r.SDK.Vars.Vars["Gear"].Value.(int))
+		rpm := int32(r.SDK.Vars.Vars["RPM"].Value.(float32))
+		speed := int32(r.SDK.Vars.Vars["Speed"].Value.(float32))
+		sessionState := r.SDK.Vars.Vars["SessionState"].Value.(int)
+
+		fmt.Printf("\033[?25l\033[2J\033[H")
+		fmt.Printf("Gear: %d, RPM: %d, Speed: %d\n", gear, rpm, speed)
+		fmt.Printf("\n")
+		fmt.Printf("IsConnected: %t\n", r.SDK.IsConnected())
+		fmt.Printf("  SessionStatusConnected: %t\n", r.SDK.SessionStatusConnected())
+		fmt.Printf("  SessionStatusInvalid:   %t\n", r.SDK.SessionStateInvalid())
+		fmt.Printf("  SessionState:           %d\n", sessionState)
+
+		<-mainLoopTicker.C
+	}
+}

internal/mockservers/mockserver.go

@@ -0,0 +1,10 @@
+// Package mockservers defines the available mockserver for the telemetry data
+package mockservers
+
+import "context"
+
+// Mockserver defines what a mockserver should do
+type Mockserver interface {
+	Replay(context.Context, bool)
+	Record(output string)
+}

main.go

@@ -1,6 +1,32 @@
 package main
 
-import "github.com/ESilva15/BeamNGMockOg/cmd"
+import (
+	"log/slog"
+	"os"
+
+	"github.com/ESilva15/TelemetryMockserver/cmd"
+)
+
+func init() {
+	_ = setupLogger()
+}
+
+func setupLogger() error {
+	output, err := os.OpenFile("./output.log", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0o755)
+	if err != nil {
+		return err
+	}
+
+	logger := slog.New(
+		slog.NewTextHandler(output, &slog.HandlerOptions{
+			Level: slog.LevelDebug,
+		}),
+	)
+
+	slog.SetDefault(logger)
+
+	return nil
+}
 
 func main() {
 	cmd.Execute()

mockserver/reader.go

@@ -1,45 +0,0 @@
-package mockserver
-
-import (
-	"io"
-	"unsafe"
-
-	sdk "github.com/ESilva15/gobngsdk"
-)
-
-type GobReader struct {
-	TotalRead int64
-	File      io.ReadSeeker
-	Buf       []byte
-}
-
-func NewGobReader(r io.ReadSeeker) *GobReader {
-	return &GobReader{
-		TotalRead: 0,
-		File:      r,
-		Buf:       make([]byte, unsafe.Sizeof(sdk.Outgauge{})),
-	}
-}
-
-func (g *GobReader) Reset() error {
-	_, err := g.File.Seek(0, io.SeekStart)
-	if err != nil {
-		return err
-	}
-
-	g.TotalRead = 0
-
-	return nil
-}
-
-func (g *GobReader) Next(buffer []byte) error {
-	_, err := io.ReadFull(g.File, buffer)
-	if err != nil {
-		return err
-	}
-
-	pos, _ := g.File.Seek(0, io.SeekCurrent)
-	g.TotalRead = pos
-
-	return nil
-}

mockserver/record.go

@@ -1,141 +0,0 @@
-package mockserver
-
-import (
-	"context"
-	"encoding/binary"
-	"fmt"
-	"os"
-	"strings"
-	"sync"
-	"time"
-
-	bngsdk "github.com/ESilva15/gobngsdk"
-)
-
-type recorderViewData struct {
-	TotalBytes int
-	SDK        *bngsdk.BeamNGSDK
-}
-
-type Recorder struct {
-	SDK        bngsdk.BeamNGSDK
-	OutputFile *os.File
-	TotalBytes int
-	// Views
-	mut         sync.RWMutex
-	viewDataMut sync.RWMutex
-	viewData    recorderViewData
-	viewCh      chan *recorderViewData
-	recorderCh  chan []byte
-}
-
-func NewRecorder(fp string, address string, port int) (*Recorder, error) {
-	var recorder Recorder
-	var err error
-
-	recorder.SDK, err = bngsdk.Init(address, port)
-	if err != nil {
-		return &Recorder{}, err
-	}
-
-	recorder.OutputFile, err = os.Create(fp)
-	if err != nil {
-		return &Recorder{}, err
-	}
-
-	recorder.viewData = recorderViewData{}
-	recorder.viewCh = make(chan *recorderViewData, 1)
-	recorder.recorderCh = make(chan []byte, 1)
-
-	return &recorder, nil
-}
-
-func (r *Recorder) Close() {
-	r.SDK.Close()
-
-	if r.OutputFile != nil {
-		r.OutputFile.Close()
-	}
-}
-
-func (r *Recorder) record(ctx context.Context) {
-	for {
-		select {
-		case <-ctx.Done():
-			return
-		case data := <-r.recorderCh:
-			r.mut.Lock()
-			err := binary.Write(r.OutputFile, binary.LittleEndian, r.SDK.Data)
-			r.TotalBytes += len(data)
-			r.mut.Unlock()
-
-			if err != nil {
-				// NOTE: find a way of logging this somehow
-			}
-		}
-	}
-}
-
-func (r *Recorder) view(ctx context.Context) {
-	var s strings.Builder
-	var nBytes int
-
-	for {
-		select {
-		case <-ctx.Done():
-			return
-		case viewData := <-r.viewCh:
-			s.Reset()
-			fmt.Fprintf(os.Stdout, "\x1b[2J\x1b[H")
-
-			stringifyRecordingProgress(&s, nBytes)
-			fmt.Fprintf(&s, "\n\n")
-
-			r.viewDataMut.RLock()
-			nBytes = viewData.TotalBytes
-			stringifyOutgaugeData(&s, &r.SDK)
-			r.viewDataMut.RUnlock()
-
-			fmt.Fprint(os.Stdout, s.String())
-		}
-	}
-}
-
-// Record records data from the UDP connection created by address and port
-func (r *Recorder) Record(ctx context.Context) error {
-	ticker := time.NewTicker(time.Second / 60)
-	defer ticker.Stop()
-
-	go r.record(ctx)
-	go r.view(ctx)
-
-	for {
-		select {
-		case <-ctx.Done():
-			return nil
-		case <-ticker.C:
-			err := r.SDK.ReadData()
-			if err != nil {
-				return err
-			}
-
-			r.viewData.TotalBytes = r.TotalBytes
-
-			// Send the data to the view
-			select {
-			case r.viewCh <- &r.viewData:
-				// Sent the data
-			default:
-				// Dropped the frame!
-			}
-
-			// Write the data to the file
-			select {
-			case r.recorderCh <- r.SDK.Buffer:
-				// Sent the data
-			default:
-				// Dropped the frame!
-			}
-		}
-	}
-}

mockserver/replay.go

@@ -1,186 +0,0 @@
-// Package mockserver is the core of this program and it will have the API
-// to record binary data from the UDP server and then be able to mock it
-package mockserver
-
-import (
-	"bytes"
-	"context"
-	"encoding/binary"
-	"fmt"
-	"io"
-	"os"
-	"strings"
-	"sync"
-	"time"
-	"unsafe"
-
-	bngsdk "github.com/ESilva15/gobngsdk"
-)
-
-type ViewData struct {
-	SDK      *bngsdk.BeamNGSDK
-	SizeRead int64
-}
-
-// Replayer does the replaying
-// Should we make a "player" struct that can record and replay?
-type Replayer struct {
-	SDK            bngsdk.BeamNGSDK
-	DataSourcePath string
-	Socket         *UDPTransport
-
-	// Streams
-	dataViewCh chan ViewData
-	socketCh   chan []byte
-
-	// Mut
-	mut sync.RWMutex
-
-	// View
-	viewData ViewData
-}
-
-func NewReplayer(address string, port int, fp string) (*Replayer, error) {
-	udp, err := NewUDPTransport(address, port)
-	if err != nil {
-		return nil, err
-	}
-
-	replayer := &Replayer{
-		DataSourcePath: fp,
-		SDK: bngsdk.BeamNGSDK{
-			Data:   &bngsdk.Outgauge{},
-			Buffer: make([]byte, unsafe.Sizeof(bngsdk.Outgauge{})),
-		},
-		Socket:     udp,
-		viewData:   ViewData{},
-		dataViewCh: make(chan ViewData, 1),
-		socketCh:   make(chan []byte, 1),
-	}
-
-	return replayer, nil
-}
-
-// renderToTerminal will render the data for the users viewing pleasure
-func (r *Replayer) renderToTerminal(ctx context.Context) {
-	fileInfo, err := os.Stat(r.DataSourcePath)
-	if err != nil {
-		// NOTE: learn how to handle this error
-		// return fmt.Errorf("error stating file: %v", err)
-	}
-
-	// NOTE: temporary until I make a better view
-	var s strings.Builder
-	var bytesReader bytes.Reader
-
-	for {
-		select {
-		case <-ctx.Done():
-			return
-		case data := <-r.dataViewCh:
-			// Reset to the start of the terminal
-			s.Reset()
-			fmt.Fprintf(os.Stdout, "\x1b[2J\x1b[H")
-
-			bytesReader.Reset(data.SDK.Buffer)
-			err := binary.Read(&bytesReader, binary.LittleEndian, r.SDK.Data)
-			if err != nil {
-				fmt.Fprintf(&s, "FAILED TO PARSE DATA\nError: %+v", err)
-				fmt.Fprint(os.Stdout, s.String())
-				continue
-			}
-
-			percent := int(float64(data.SizeRead) / float64(fileInfo.Size()) * 100)
-			fmt.Fprintf(&s, "Replayed: %d%%\n", percent)
-
-			stringifyOutgaugeData(&s, data.SDK)
-
-			fmt.Fprint(os.Stdout, s.String())
-		}
-	}
-}
-
-// writeToUDPSocket will write the telemetry data to the UDP socket
-func (r *Replayer) writeToUDPSocket(ctx context.Context) {
-	for {
-		select {
-		case <-ctx.Done():
-			return
-		case data := <-r.socketCh:
-			r.mut.RLock()
-			_, err := r.Socket.Send(data)
-			r.mut.RUnlock()
-			if err != nil {
-				panic(fmt.Sprintf("error writing buffer to socket: %+v", err))
-				continue
-				// NOTE: log the error somewhere maybe
-				// return err
-			}
-		}
-	}
-}
-
-// Replay replays a given file <fp> in a UDP server <addr>:<port>
-func (r *Replayer) Replay(ctx context.Context, loop bool) error {
-	bin, err := os.Open(r.DataSourcePath)
-	if err != nil {
-		return fmt.Errorf("error opening file: %v", err)
-	}
-
-	reader := NewGobReader(bin)
-
-	go r.renderToTerminal(ctx)
-	go r.writeToUDPSocket(ctx)
-
-	ticker := time.NewTicker(time.Second / 60)
-	defer ticker.Stop()
-	for {
-		select {
-		case <-ctx.Done():
-			return ctx.Err()
-
-		case <-ticker.C:
-			r.mut.Lock()
-			err := reader.Next(r.SDK.Buffer)
-			r.mut.Unlock()
-
-			if err == io.EOF {
-				if !loop {
-					return r.Socket.Close()
-				}
-
-				err = reader.Reset()
-				if err != nil {
-					return err
-				}
-
-				continue
-			}
-
-			if err != nil {
-				return err
-			}
-
-			// NOTE: Really like this???
-			r.viewData.SDK = &r.SDK
-			r.viewData.SizeRead = reader.TotalRead
-
-			// Send the data to the view
-			select {
-			case r.dataViewCh <- r.viewData:
-				// Sent the data
-			default:
-				// Dropped the frame!
-			}
-
-			// Send the data to the UDP socket
-			select {
-			case r.socketCh <- r.SDK.Buffer:
-				// Sent the data
-			default:
-				// Dropped the frame!
-			}
-
-		}
-	}
-}

mockserver/server.go

@@ -1,39 +0,0 @@
-package mockserver
-
-import (
-	"fmt"
-	"net"
-)
-
-type Transport interface {
-	Send(data []byte) error
-	Close() error
-}
-
-type UDPTransport struct {
-	Conn *net.UDPConn
-	Addr *net.UDPAddr
-}
-
-func NewUDPTransport(address string, port int) (*UDPTransport, error) {
-	addr, err := net.ResolveUDPAddr("udp", fmt.Sprintf("%s:%d", address, port))
-	if err != nil {
-		return nil, err
-	}
-
-	conn, err := net.ListenUDP("udp", nil)
-	if err != nil {
-		return nil, err
-	}
-
-	return &UDPTransport{Conn: conn, Addr: addr}, nil
-}
-
-// Send will send a byte array of data trough the UDP server
-func (u *UDPTransport) Send(data []byte) (int, error) {
-	return u.Conn.WriteToUDP(data, u.Addr)
-}
-
-func (u *UDPTransport) Close() error {
-	return u.Conn.Close()
-}

mockserver/views.go

@@ -1,89 +0,0 @@
-package mockserver
-
-import (
-	"fmt"
-	"strings"
-
-	bngsdk "github.com/ESilva15/gobngsdk"
-)
-
-const (
-	_   = iota
-	KiB = 1 << (10 * iota)
-	MiB
-	GiB
-)
-
-func stringifyRecordingProgress(s *strings.Builder, nBytes int) {
-	if nBytes < KiB {
-		fmt.Fprintf(s, "%d B", nBytes)
-	} else if nBytes < MiB {
-		fmt.Fprintf(s, "%.2f KiB", float64(nBytes)/float64(KiB))
-	} else if nBytes < GiB {
-		fmt.Fprintf(s, "%.2f MiB", float64(nBytes)/float64(MiB))
-	} else {
-		fmt.Fprintf(s, "%.2f GiB", float64(nBytes)/float64(GiB))
-	}
-}
-
-func stringifyOutgaugeData(s *strings.Builder, sdk *bngsdk.BeamNGSDK) {
-	// NOTE: write a string serialization function on the SDK itself
-	fmt.Fprint(s, "Outgauge {\n")
-	fmt.Fprintf(s, "  Time:        %d ms\n", sdk.Data.Time)
-	fmt.Fprintf(s, "  Car:         %s\n", sdk.Data.Car)
-	fmt.Fprintf(s, "  Flags:       %b\n", sdk.Data.Flags)
-	fmt.Fprintf(s, "  Gear:        %d\n", sdk.Data.Gear)
-	fmt.Fprintf(s, "  Plid:        %d\n", sdk.Data.Plid)
-	fmt.Fprintf(s, "  Speed:       %f m/s\n", sdk.Data.Speed)
-	fmt.Fprintf(s, "  RPM:         %f RPM\n", sdk.Data.RPM)
-	fmt.Fprintf(s, "  Turbo:       %f Bar\n", sdk.Data.Turbo)
-	fmt.Fprintf(s, "  EngTemp:     %f °C\n", sdk.Data.EngTemp)
-	fmt.Fprintf(s, "  Fuel:        %f\n", sdk.Data.Fuel)
-	fmt.Fprintf(s, "  OilPressure: %f Bar\n", sdk.Data.OilPressure)
-	fmt.Fprintf(s, "  OilTemp:     %f °C\n", sdk.Data.OilTemp)
-	fmt.Fprintf(s, "  DashLights:  %b\n", sdk.Data.DashLights)
-	fmt.Fprintf(s, "  ShowLights:  %b\n", sdk.Data.ShowLights)
-	fmt.Fprintf(s, "  Throttle:    %f\n", sdk.Data.Throttle)
-	fmt.Fprintf(s, "  Brakes:      %f\n", sdk.Data.Brake)
-	fmt.Fprintf(s, "  Clutch:      %f\n", sdk.Data.Clutch)
-	fmt.Fprintf(s, "  Display1:    %s\n", sdk.Data.Display1)
-	fmt.Fprintf(s, "  Display2:    %s\n", sdk.Data.Display2)
-	fmt.Fprintf(s, "  ID:          %d\n", sdk.Data.ID)
-	fmt.Fprint(s, "}\n\n")
-
-	fmt.Fprint(s, "DashLights {\n")
-	fmt.Fprintf(s, "  DL_SHIFT:      %t\n", sdk.HasShiftLight())
-	fmt.Fprintf(s, "  DL_FULLBEAM:   %t\n", sdk.HasHighBeamLight())
-	fmt.Fprintf(s, "  DL_HANDBRAKE:  %t\n", sdk.HasHandbrakeLight())
-	fmt.Fprintf(s, "  DL_PITSPEED:   %t\n", sdk.HasPitspeed())
-	fmt.Fprintf(s, "  DL_TC:         %t\n", sdk.HasTractionControlLight())
-	fmt.Fprintf(s, "  DL_SIGNAL_L:   %t\n", sdk.HasLeftIndicatorLight())
-	fmt.Fprintf(s, "  DL_SIGNAL_R:   %t\n", sdk.HasRightIndicatorLight())
-	fmt.Fprintf(s, "  DL_SIGNAL_ANY: %t\n", sdk.HasAnyIndicatorLight())
-	fmt.Fprintf(s, "  DL_OILWARN:    %t\n", sdk.HasOilLight())
-	fmt.Fprintf(s, "  DL_BATTERY:    %t\n", sdk.HasBatteryLight())
-	fmt.Fprintf(s, "  DL_ABS:        %t\n", sdk.HasABSLight())
-	fmt.Fprintf(s, "  DL_SPARE:      %t\n", sdk.Data.DashLights&bngsdk.DL_SPARE != 0)
-	fmt.Fprint(s, "}\n\n")
-
-	fmt.Fprint(s, "ShowLights {\n") // Fixed typo "ShowLigths"
-	fmt.Fprintf(s, "  DL_SHIFT:      %t\n", sdk.ShiftLight())
-	fmt.Fprintf(s, "  DL_FULLBEAM:   %t\n", sdk.HighBeam())
-	fmt.Fprintf(s, "  DL_HANDBRAKE:  %t\n", sdk.Handbrake())
-	fmt.Fprintf(s, "  DL_PITSPEED:   %t\n", sdk.Pitspeed())
-	fmt.Fprintf(s, "  DL_TC:         %t\n", sdk.TractionControl())
-	fmt.Fprintf(s, "  DL_SIGNAL_L:   %t\n", sdk.LeftIndicator())
-	fmt.Fprintf(s, "  DL_SIGNAL_R:   %t\n", sdk.RightIndicator())
-	fmt.Fprintf(s, "  DL_SIGNAL_ANY: %t\n", sdk.AnyIndicator())
-	fmt.Fprintf(s, "  DL_OILWARN:    %t\n", sdk.OilLight())
-	fmt.Fprintf(s, "  DL_BATTERY:    %t\n", sdk.BatteryLight())
-	fmt.Fprintf(s, "  DL_ABS:        %t\n", sdk.ABS())
-	fmt.Fprintf(s, "  DL_SPARE:      %t\n", sdk.Data.ShowLights&bngsdk.DL_SPARE != 0)
-	fmt.Fprint(s, "}\n\n")
-
-	fmt.Fprint(s, "Flags {\n")
-	fmt.Fprintf(s, "  OG_TURBO (Has Turbo): %t\n", sdk.HasTurbo())
-	fmt.Fprintf(s, "  OG_KM (Is Metric):    %t\n", sdk.PrefersKm())
-	fmt.Fprintf(s, "  OG_BAR (Pressure):    %t\n", sdk.PrefersBAR())
-	fmt.Fprint(s, "}")
-}