this might work, let's see

Author: sparkoo

telemetry.go

@@ -52,7 +52,6 @@ type accTelemetry struct {
 	udpConnection *net.UDPConn
 
 	realtimeCarUpdate *RealtimeCarUpdate
-	realtimeUpdate    *RealtimeUpdate
 }
 
 type accDataHolder[T AccGraphic | AccPhysics | AccStatic] struct {
@@ -158,16 +157,11 @@ func (t *accTelemetry) PhysicsPointer() *AccPhysics {
 	return nil
 }
 
-// reads from UDP
-// returns current state of RealtimeUpdate
-// by it's async nature, it's just best effort these data are latest and correct
-func (t *accTelemetry) RealtimeUpdate() *RealtimeUpdate {
-	return t.realtimeUpdate
-}
-
 // reads from UDP
 // returns current state of RealtimeCarUpdate
 // by it's async nature, it's just best effort these data are latest and correct
+// it returns pointer to same struct so it will change over time. It's up to the client to handle this and be careful.
+// it can even be in the middle of updating the struct.
 func (t *accTelemetry) RealtimeCarUpdate() *RealtimeCarUpdate {
 	return t.realtimeCarUpdate
 }

telemetry_udp.go

@@ -68,8 +68,11 @@ func (telemetry *accTelemetry) connect() error {
 		}
 	} else {
 		fmt.Println("UDP Connected")
-		telemetry.realtimeCarUpdate = &RealtimeCarUpdate{}
-		telemetry.realtimeUpdate = &RealtimeUpdate{}
+		telemetry.realtimeCarUpdate = &RealtimeCarUpdate{
+			BestSessionLap: &LapInfo{Splits: [8]int32{}},
+			LastLap:        &LapInfo{Splits: [8]int32{}},
+			CurrentLap:     &LapInfo{Splits: [8]int32{}},
+		}
 	}
 
 	connectionResult, err := readConnectionResult(bytes.NewBuffer(inBuffer))
@@ -125,19 +128,6 @@ func (telemetry *accTelemetry) createConnectMessage() ([]byte, error) {
 	return outBuffer.Bytes(), nil
 }
 
-func writeString(buffer *bytes.Buffer, str string) error {
-	lengthBytes := make([]byte, 2)
-	binary.LittleEndian.PutUint16(lengthBytes, uint16(len(str)))
-
-	var writeErr error
-	_, writeErr = buffer.Write(lengthBytes)
-	_, writeErr = buffer.Write([]byte(str))
-	if writeErr != nil {
-		return fmt.Errorf("failed to write string '%s' to byte buffer: %w", str, writeErr)
-	}
-	return nil
-}
-
 // response format:
 // 1 byte - message type
 // 4 bytes - int32 connectionId
@@ -157,17 +147,10 @@ func readConnectionResult(payload *bytes.Buffer) (*connectionResult, error) {
 	}
 
 	// read connectionId
-	connectionIdBytes := make([]byte, 4)
-	_, err = payload.Read(connectionIdBytes)
+	connectionId, err := readInt32(payload)
 	if err != nil {
 		return nil, fmt.Errorf("failed to read connectionId: %w", err)
 	}
-
-	var connectionId int32
-	err = binary.Read(bytes.NewReader(connectionIdBytes), binary.LittleEndian, &connectionId)
-	if err != nil {
-		return nil, fmt.Errorf("failed to convert connectionId: %w", err)
-	}
 	result.connectionId = connectionId
 
 	// read success
@@ -185,17 +168,12 @@ func readConnectionResult(payload *bytes.Buffer) (*connectionResult, error) {
 	result.readOnly = readonly == 0
 
 	// read error
-	errorLengthBytes := make([]byte, 2)
-	_, err = payload.Read(errorLengthBytes)
-	if err != nil {
-		return nil, fmt.Errorf("failed to read error length: %w", err)
-	}
-	var errorLength uint16
-	err = binary.Read(bytes.NewReader(errorLengthBytes), binary.LittleEndian, &errorLength)
+	errorLength, err := readUint16(payload)
 	if err != nil {
-		return nil, fmt.Errorf("failed to convert errorLength: %w", err)
+		return nil, fmt.Errorf("failed to read error message length: %w", err)
 	}
 
+	//TODO: handle reading error message if this is non zero
 	if errorLength > 0 {
 		result.errorMessage = "some error"
 	}
@@ -210,12 +188,10 @@ func (t *accTelemetry) readMessage(payload []byte) error {
 		return fmt.Errorf("failed to read message type: %w", err)
 	}
 	switch messageType {
-	case REALTIME_UPDATE:
-		updateRealtimeUpdate(buffer, t.realtimeUpdate)
 	case REALTIME_CAR_UPDATE:
 		updateRealtimeCarUpdate(buffer, t.realtimeCarUpdate)
 	default:
-		return fmt.Errorf("received unexpected message type: '%d' => %+v", messageType, payload)
+		return fmt.Errorf("we don't currently support this type of message: '%d' => %+v", messageType, payload)
 	}
 
 	return nil

type_realtimecarupdate.go

@@ -3,8 +3,70 @@ package acctelemetry
 import "bytes"
 
 type RealtimeCarUpdate struct {
+	CarIndex              uint16
+	DriverIndex           uint16
+	DriverCount           byte
+	Gear                  byte
+	WorldPosX             float32
+	WorldPosY             float32
+	Yaw                   float32
+	CarLocation           byte // 0=NONE, 1=TRACK, 2=PITLANE, 3=PITENTRY, 4=PITEXIT
+	Kmh                   uint16
+	Position              uint16
+	CupPosition           uint16
+	TrackPosition         uint16
+	TrackRelativePosition float32
+	Laps                  uint16
+	Delta                 int32
+	BestSessionLap        *LapInfo
+	LastLap               *LapInfo
+	CurrentLap            *LapInfo
+}
+
+type LapInfo struct {
+	LaptimeMs      int32
+	CarIndex       uint16
+	DriverIndex    uint16
+	SplitCount     byte
+	Splits         [8]int32 // let's assume no track will have more than 8 splits (all should have 3...)
+	IsInvalid      byte
+	InValidForBest byte
+	IsOutlap       byte
+	IsInlaop       byte
 }
 
 func updateRealtimeCarUpdate(payload *bytes.Buffer, toUpdate *RealtimeCarUpdate) {
+	toUpdate.CarIndex, _ = readUint16(payload)
+	toUpdate.DriverIndex, _ = readUint16(payload)
+	toUpdate.DriverCount, _ = payload.ReadByte()
+	toUpdate.Gear, _ = payload.ReadByte()
+	toUpdate.WorldPosX, _ = readFloat32(payload)
+	toUpdate.WorldPosY, _ = readFloat32(payload)
+	toUpdate.Yaw, _ = readFloat32(payload)
+	toUpdate.CarLocation, _ = payload.ReadByte()
+	toUpdate.Kmh, _ = readUint16(payload)
+	toUpdate.Position, _ = readUint16(payload)
+	toUpdate.CupPosition, _ = readUint16(payload)
+	toUpdate.TrackPosition, _ = readUint16(payload)
+	toUpdate.TrackRelativePosition, _ = readFloat32(payload)
+	toUpdate.Laps, _ = readUint16(payload)
+	toUpdate.Delta, _ = readInt32(payload)
+	toUpdate.Kmh, _ = readUint16(payload)
+	updateLap(payload, toUpdate.BestSessionLap)
+	updateLap(payload, toUpdate.LastLap)
+	updateLap(payload, toUpdate.CurrentLap)
+}
 
+func updateLap(payload *bytes.Buffer, lap *LapInfo) {
+	lap.LaptimeMs, _ = readInt32(payload)
+	lap.CarIndex, _ = readUint16(payload)
+	lap.DriverIndex, _ = readUint16(payload)
+	lap.SplitCount, _ = payload.ReadByte()
+	for i := 0; i < int(lap.SplitCount); i++ {
+		lap.Splits[i], _ = readInt32(payload)
+	}
+	lap.IsInvalid, _ = payload.ReadByte()
+	lap.InValidForBest, _ = payload.ReadByte()
+	lap.IsOutlap, _ = payload.ReadByte()
+	lap.IsInlaop, _ = payload.ReadByte()
 }

type_realtimeupdate.go

@@ -0,0 +1,65 @@
+package acctelemetry
+
+import (
+	"bytes"
+	"encoding/binary"
+	"fmt"
+)
+
+func writeString(buffer *bytes.Buffer, str string) error {
+	lengthBytes := make([]byte, 2)
+	binary.LittleEndian.PutUint16(lengthBytes, uint16(len(str)))
+
+	var writeErr error
+	_, writeErr = buffer.Write(lengthBytes)
+	_, writeErr = buffer.Write([]byte(str))
+	if writeErr != nil {
+		return fmt.Errorf("failed to write string '%s' to byte buffer: %w", str, writeErr)
+	}
+	return nil
+}
+
+func readInt32(buffer *bytes.Buffer) (int32, error) {
+	readBytes := make([]byte, 4)
+	_, err := buffer.Read(readBytes)
+	if err != nil {
+		return 0, fmt.Errorf("failed to read int32: %w", err)
+	}
+
+	var result int32
+	err = binary.Read(bytes.NewReader(readBytes), binary.LittleEndian, &result)
+	if err != nil {
+		return 0, fmt.Errorf("failed to convert int32: %w", err)
+	}
+	return result, nil
+}
+
+func readUint16(buffer *bytes.Buffer) (uint16, error) {
+	readBytes := make([]byte, 2)
+	_, err := buffer.Read(readBytes)
+	if err != nil {
+		return 0, fmt.Errorf("failed to read uint: %w", err)
+	}
+	var result uint16
+	err = binary.Read(bytes.NewReader(readBytes), binary.LittleEndian, &result)
+	if err != nil {
+		return 0, fmt.Errorf("failed to convert uint: %w", err)
+	}
+
+	return result, nil
+}
+
+func readFloat32(buffer *bytes.Buffer) (float32, error) {
+	readBytes := make([]byte, 4)
+	_, err := buffer.Read(readBytes)
+	if err != nil {
+		return 0, fmt.Errorf("failed to read float32: %w", err)
+	}
+
+	var result float32
+	err = binary.Read(bytes.NewReader(readBytes), binary.LittleEndian, &result)
+	if err != nil {
+		return 0, fmt.Errorf("failed to convert float32: %w", err)
+	}
+	return result, nil
+}