diff --git a/constants.go b/constants.go index 67fbde3..e434477 100644 --- a/constants.go +++ b/constants.go @@ -1,5 +1,10 @@ package goirsdk +import ( + "log" + "strconv" +) + type Msg struct { Cmd int P1 int32 @@ -113,20 +118,22 @@ const ( ) // Camera positions -const ( -// CamNose -) - -// Some other constants that I need to get trough -// // bit fields - type bitfieldValue struct { Value int Name string } -// EngineWarnings const +// EngineWarnings - Start +// TODO: wtf var ( + irsdk_WaterTempWarning int64 = 0x00000001 + irsdk_FuelPressureWarning int64 = 0x00000002 + irsdk_OilPressureWarning int64 = 0x00000004 + irsdk_EngineStalled int64 = 0x00000008 + irsdk_PitSpeedLimiter int64 = 0x00000010 + irsdk_RevLimiterActive int64 = 0x00000020 + irsdk_AbsActive int64 = 0x00000100 + // DEPRECATE THESE ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓ irsdkWaterTempWarning = bitfieldValue{0x01, "irsdk_waterTempWarning"} irsdkFuelPressureWarning = bitfieldValue{0x02, "irsdk_fueldPressureWarning"} irsdkOilPressureWarning = bitfieldValue{0x04, "irsdk_oilPressureWarning"} @@ -141,134 +148,563 @@ var ( } ) -// enum irsdk_EngineWarnings -// { -// irsdk_waterTempWarning = 0x01, -// irsdk_fuelPressureWarning = 0x02, -// irsdk_oilPressureWarning = 0x04, -// irsdk_engineStalled = 0x08, -// irsdk_pitSpeedLimiter = 0x10, -// irsdk_revLimiterActive = 0x20, -// }; -// -// // global flags -// enum irsdk_Flags -// { -// // global flags -// irsdk_checkered = 0x00000001, -// irsdk_white = 0x00000002, -// irsdk_green = 0x00000004, -// irsdk_yellow = 0x00000008, -// irsdk_red = 0x00000010, -// irsdk_blue = 0x00000020, -// irsdk_debris = 0x00000040, -// irsdk_crossed = 0x00000080, -// irsdk_yellowWaving = 0x00000100, -// irsdk_oneLapToGreen = 0x00000200, -// irsdk_greenHeld = 0x00000400, -// irsdk_tenToGo = 0x00000800, -// irsdk_fiveToGo = 0x00001000, -// irsdk_randomWaving = 0x00002000, -// irsdk_caution = 0x00004000, -// irsdk_cautionWaving = 0x00008000, -// -// // drivers black flags -// irsdk_black = 0x00010000, -// irsdk_disqualify = 0x00020000, -// irsdk_servicible = 0x00040000, // car is allowed service (not a flag) -// irsdk_furled = 0x00080000, -// irsdk_repair = 0x00100000, -// -// // start lights -// irsdk_startHidden = 0x10000000, -// irsdk_startReady = 0x20000000, -// irsdk_startSet = 0x40000000, -// irsdk_startGo = 0x80000000, -// }; -// -// -// // status -// enum irsdk_TrkLoc -// { -// irsdk_NotInWorld = -1, -// irsdk_OffTrack, -// irsdk_InPitStall, -// irsdk_AproachingPits, -// irsdk_OnTrack -// }; -// -// enum irsdk_TrkSurf -// { -// irsdk_SurfaceNotInWorld = -1, -// irsdk_UndefinedMaterial = 0, -// -// irsdk_Asphalt1Material, -// irsdk_Asphalt2Material, -// irsdk_Asphalt3Material, -// irsdk_Asphalt4Material, -// irsdk_Concrete1Material, -// irsdk_Concrete2Material, -// irsdk_RacingDirt1Material, -// irsdk_RacingDirt2Material, -// irsdk_Paint1Material, -// irsdk_Paint2Material, -// irsdk_Rumble1Material, -// irsdk_Rumble2Material, -// irsdk_Rumble3Material, -// irsdk_Rumble4Material, -// -// irsdk_Grass1Material, -// irsdk_Grass2Material, -// irsdk_Grass3Material, -// irsdk_Grass4Material, -// irsdk_Dirt1Material, -// irsdk_Dirt2Material, -// irsdk_Dirt3Material, -// irsdk_Dirt4Material, -// irsdk_SandMaterial, -// irsdk_Gravel1Material, -// irsdk_Gravel2Material, -// irsdk_GrasscreteMaterial, -// irsdk_AstroturfMaterial, -// }; -// -// enum irsdk_SessionState -// { -// irsdk_StateInvalid, -// irsdk_StateGetInCar, -// irsdk_StateWarmup, -// irsdk_StateParadeLaps, -// irsdk_StateRacing, -// irsdk_StateCheckered, -// irsdk_StateCoolDown -// }; -// -// enum irsdk_CameraState -// { -// irsdk_IsSessionScreen = 0x0001, // the camera tool can only be activated if viewing the session screen (out of car) -// irsdk_IsScenicActive = 0x0002, // the scenic camera is active (no focus car) -// -// //these can be changed with a broadcast message -// irsdk_CamToolActive = 0x0004, -// irsdk_UIHidden = 0x0008, -// irsdk_UseAutoShotSelection = 0x0010, -// irsdk_UseTemporaryEdits = 0x0020, -// irsdk_UseKeyAcceleration = 0x0040, -// irsdk_UseKey10xAcceleration = 0x0080, -// irsdk_UseMouseAimMode = 0x0100 -// }; -// -// enum irsdk_PitSvFlags -// { -// irsdk_LFTireChange = 0x0001, -// irsdk_RFTireChange = 0x0002, -// irsdk_LRTireChange = 0x0004, -// irsdk_RRTireChange = 0x0008, -// -// irsdk_FuelFill = 0x0010, -// irsdk_WindshieldTearoff = 0x0020, -// irsdk_FastRepair = 0x0040 -// }; +func (i *IBT) WaterTempWarning() bool { + val, ok := i.Vars.Vars["EngineWarnings"] + if !ok { + log.Fatal("no EngineWarnings") + } -//---- -// + bitfield, err := strconv.ParseInt(val.Value.(string), 0, 64) + if err != nil { + log.Fatal("unable to get EngineWarnings: " + err.Error()) + } + + return bitfield&irsdk_WaterTempWarning != 0 +} + +func (i *IBT) FuelPressureWarning() bool { + val, ok := i.Vars.Vars["EngineWarnings"] + if !ok { + log.Fatal("no EngineWarnings") + } + + bitfield, err := strconv.ParseInt(val.Value.(string), 0, 64) + if err != nil { + log.Fatal("unable to get EngineWarnings: " + err.Error()) + } + + return bitfield&irsdk_FuelPressureWarning != 0 +} + +func (i *IBT) OilPressureWarning() bool { + val, ok := i.Vars.Vars["EngineWarnings"] + if !ok { + log.Fatal("no EngineWarnings") + } + + bitfield, err := strconv.ParseInt(val.Value.(string), 0, 64) + if err != nil { + log.Fatal("unable to get EngineWarnings: " + err.Error()) + } + + return bitfield&irsdk_OilPressureWarning != 0 +} + +func (i *IBT) EngineStalled() bool { + val, ok := i.Vars.Vars["EngineWarnings"] + if !ok { + log.Fatal("no EngineWarnings") + } + + bitfield, err := strconv.ParseInt(val.Value.(string), 0, 64) + if err != nil { + log.Fatal("unable to get EngineWarnings: " + err.Error()) + } + + return bitfield&irsdk_EngineStalled != 0 +} + +func (i *IBT) PitSpeedLimiter() bool { + val, ok := i.Vars.Vars["EngineWarnings"] + if !ok { + log.Fatal("no EngineWarnings") + } + + bitfield, err := strconv.ParseInt(val.Value.(string), 0, 64) + if err != nil { + log.Fatal("unable to get EngineWarnings: " + err.Error()) + } + + return bitfield&irsdk_PitSpeedLimiter != 0 +} + +func (i *IBT) RevLimiterActive() bool { + val, ok := i.Vars.Vars["EngineWarnings"] + if !ok { + log.Fatal("no EngineWarnings") + } + + bitfield, err := strconv.ParseInt(val.Value.(string), 0, 64) + if err != nil { + log.Fatal("unable to get EngineWarnings: " + err.Error()) + } + + return bitfield&irsdk_RevLimiterActive != 0 +} + +func (i *IBT) AbsActive() bool { + val, ok := i.Vars.Vars["EngineWarnings"] + if !ok { + log.Fatal("no EngineWarnings") + } + + bitfield, err := strconv.ParseInt(val.Value.(string), 0, 64) + if err != nil { + log.Fatal("unable to get EngineWarnings: " + err.Error()) + } + + return bitfield&irsdk_AbsActive != 0 +} + +// EngineWarnings - END + +// SessionState const +const ( + irsdk_StateInvalid = 0x00 + irsdk_StateGetInCar = 0x01 + irsdk_StateWarmup = 0x02 + irsdk_StateParadeLaps = 0x03 + irsdk_StateRacing = 0x04 + irsdk_StateCheckered = 0x05 + irsdk_StateCoolDown = 0x06 +) + +func SessionStateToString(state int) string { + switch state { + case irsdk_StateInvalid: + return "StateInvalid" + case irsdk_StateGetInCar: + return "StateGetInCar" + case irsdk_StateWarmup: + return "StateWarmup" + case irsdk_StateParadeLaps: + return "StateParadeLaps" + case irsdk_StateRacing: + return "StateRacing" + case irsdk_StateCheckered: + return "StateCheckered" + case irsdk_StateCoolDown: + return "StateCoolDown" + default: + return "UknownSessionState" + } +} + +// TrkLoc const +const ( + irsdk_NotInWorld = -1 + irsdk_OffTrack = 0 + irsdk_InPitStall = 1 + irsdk_AproachingPits = 2 + irsdk_OnTrack = 3 +) + +func TrkLocToString(trkloc int) string { + switch trkloc { + case irsdk_NotInWorld: + return "NotInWorld" + case irsdk_OffTrack: + return "OffTrack" + case irsdk_InPitStall: + return "InPitStall" + case irsdk_AproachingPits: + return "AproachingPits" + case irsdk_OnTrack: + return "OnTrack" + default: + return "UknownTrackLocation" + } +} + +// Flags +const ( + irsdk_checkered = 0x00000001 + irsdk_white = 0x00000002 + irsdk_green = 0x00000004 + irsdk_yellow = 0x00000008 + irsdk_red = 0x00000010 + irsdk_blue = 0x00000020 + irsdk_debris = 0x00000040 + irsdk_crossed = 0x00000080 + irsdk_yellowWaving = 0x00000100 + irsdk_oneLapToGreen = 0x00000200 + irsdk_greenHeld = 0x00000400 + irsdk_tenToGo = 0x00000800 + irsdk_fiveToGo = 0x00001000 + irsdk_randomWaving = 0x00002000 + irsdk_caution = 0x00004000 + irsdk_cautionWaving = 0x00008000 + + // drivers black flags + irsdk_black = 0x00010000 + irsdk_disqualify = 0x00020000 + irsdk_servicible = 0x00040000 // car is allowed service (not a flag) + irsdk_furled = 0x00080000 + irsdk_repair = 0x00100000 + + // start lights + irsdk_startHidden = 0x10000000 + irsdk_startReady = 0x20000000 + irsdk_startSet = 0x40000000 + irsdk_startGo = 0x80000000 +) + +func FlagToString(flag int) string { + switch flag { + case irsdk_checkered: + return "irsdk_checkered" + case irsdk_white: + return "irsdk_white" + case irsdk_green: + return "irsdk_green" + case irsdk_yellow: + return "irsdk_yellow" + case irsdk_red: + return "irsdk_red" + case irsdk_blue: + return "irsdk_blue" + case irsdk_debris: + return "irsdk_debris" + case irsdk_crossed: + return "irsdk_crossed" + case irsdk_yellowWaving: + return "irsdk_yellowWaving" + case irsdk_oneLapToGreen: + return "irsdk_oneLapToGreen" + case irsdk_greenHeld: + return "irsdk_greenHeld" + case irsdk_tenToGo: + return "irsdk_tenToGo" + case irsdk_fiveToGo: + return "irsdk_fiveToGo" + case irsdk_randomWaving: + return "irsdk_randomWaving" + case irsdk_caution: + return "irsdk_caution" + case irsdk_cautionWaving: + return "irsdk_cautionWaving" + case irsdk_black: + return "irsdk_black" + case irsdk_disqualify: + return "irsdk_disqualify" + case irsdk_servicible: + return "irsdk_servicible" + case irsdk_furled: + return "irsdk_furled" + case irsdk_repair: + return "irsdk_repair" + case irsdk_startHidden: + return "irsdk_startHidden" + case irsdk_startReady: + return "irsdk_startReady" + case irsdk_startSet: + return "irsdk_startSet" + case irsdk_startGo: + return "irsdk_startGo" + default: + return "UknownFlag" + } +} + +// enum irsdk_TrkSurf +const ( + irsdk_SurfaceNotInWorld = iota - 1 + irsdk_UndefinedMaterial + irsdk_Asphalt1Material + irsdk_Asphalt2Material + irsdk_Asphalt3Material + irsdk_Asphalt4Material + irsdk_Concrete1Material + irsdk_Concrete2Material + irsdk_RacingDirt1Material + irsdk_RacingDirt2Material + irsdk_Paint1Material + irsdk_Paint2Material + irsdk_Rumble1Material + irsdk_Rumble2Material + irsdk_Rumble3Material + irsdk_Rumble4Material + irsdk_Grass1Material + irsdk_Grass2Material + irsdk_Grass3Material + irsdk_Grass4Material + irsdk_Dirt1Material + irsdk_Dirt2Material + irsdk_Dirt3Material + irsdk_Dirt4Material + irsdk_SandMaterial + irsdk_Gravel1Material + irsdk_Gravel2Material + irsdk_GrasscreteMaterial + irsdk_AstroturfMaterial +) + +func TrkSurfToString(surface int) string { + switch surface { + case irsdk_SurfaceNotInWorld: + return "SurfaceNotInWorld" + case irsdk_UndefinedMaterial: + return "UndefinedMaterial" + case irsdk_Asphalt1Material: + return "Asphalt1Material" + case irsdk_Asphalt2Material: + return "Asphalt2Material" + case irsdk_Asphalt3Material: + return "Asphalt3Material" + case irsdk_Asphalt4Material: + return "Asphalt4Material" + case irsdk_Concrete1Material: + return "Concrete1Material" + case irsdk_Concrete2Material: + return "Concrete2Material" + case irsdk_RacingDirt1Material: + return "RacingDirt1Material" + case irsdk_RacingDirt2Material: + return "RacingDirt2Material" + case irsdk_Paint1Material: + return "Paint1Material" + case irsdk_Paint2Material: + return "Paint2Material" + case irsdk_Rumble1Material: + return "Rumble1Material" + case irsdk_Rumble2Material: + return "Rumble2Material" + case irsdk_Rumble3Material: + return "Rumble3Material" + case irsdk_Rumble4Material: + return "Rumble4Material" + case irsdk_Grass1Material: + return "Grass1Material" + case irsdk_Grass2Material: + return "Grass2Material" + case irsdk_Grass3Material: + return "Grass3Material" + case irsdk_Grass4Material: + return "Grass4Material" + case irsdk_Dirt1Material: + return "Dirt1Material" + case irsdk_Dirt2Material: + return "Dirt2Material" + case irsdk_Dirt3Material: + return "Dirt3Material" + case irsdk_Dirt4Material: + return "Dirt4Material" + case irsdk_SandMaterial: + return "SandMaterial" + case irsdk_Gravel1Material: + return "Gravel1Material" + case irsdk_Gravel2Material: + return "Gravel2Material" + case irsdk_GrasscreteMaterial: + return "GrasscreteMaterial" + case irsdk_AstroturfMaterial: + return "AstroturfMaterial" + default: + return "UknownTrackSurface" + } +} + +// CameraState +const ( + irsdk_IsSessionScreen = 0x0001 // the camera tool can only be activated if viewing the session screen (out of car) + irsdk_IsScenicActive = 0x0002 // the scenic camera is active (no focus car) + // these can be changed with a broadcast message + irsdk_CamToolActive = 0x0004 + irsdk_UIHidden = 0x0008 + irsdk_UseAutoShotSelection = 0x0010 + irsdk_UseTemporaryEdits = 0x0020 + irsdk_UseKeyAcceleration = 0x0040 + irsdk_UseKey10xAcceleration = 0x0080 + irsdk_UseMouseAimMode = 0x0100 +) + +func CameraStateToString(state int) string { + switch state { + case irsdk_IsSessionScreen: + return "IsSessionScreen" + case irsdk_IsScenicActive: + return "IsScenicActive" + case irsdk_CamToolActive: + return "CamToolActive" + case irsdk_UIHidden: + return "UIHidden" + case irsdk_UseAutoShotSelection: + return "UseAutoShotSelection" + case irsdk_UseTemporaryEdits: + return "UseTemporaryEdits" + case irsdk_UseKeyAcceleration: + return "UseKeyAcceleration" + case irsdk_UseKey10xAcceleration: + return "UseKey10xAcceleration" + case irsdk_UseMouseAimMode: + return "UseMouseAimMode" + default: + return "UknownCameraState" + } +} + +// PitSvFlags -- Start +const ( + // Tires + irsdk_LFTireChange = 0x00000001 + irsdk_RFTireChange = 0x00000002 + irsdk_LRTireChange = 0x00000004 + irsdk_RRTireChange = 0x00000008 + // Fuel + irsdk_FuelFill = 0x00000010 + + irsdk_WindshieldTearoff = 0x00000020 + irsdk_FastRepair = 0x00000040 + + // Other pit service request flags + irsdk_ClearTires = 0x00000080 // Uncheck tire change + irsdk_ClearWS = 0x00000100 // Uncheck windshield tearoff + irsdk_ClearFR = 0x00000200 // Uncheck FastRepair + irsdk_ClearFuel = 0x00000400 // Uncheck refuelling +) + +func (i *IBT) LFTireChange() bool { + val, ok := i.Vars.Vars["PitSvFlags"] + if !ok { + log.Fatal("no PitSvFlags") + } + + bitfield, err := strconv.ParseInt(val.Value.(string), 0, 64) + if err != nil { + log.Fatal("unable to get PitSvFlags: " + err.Error()) + } + + return bitfield&irsdk_LFTireChange != 0 +} + +func (i *IBT) RFTireChange() bool { + val, ok := i.Vars.Vars["PitSvFlags"] + if !ok { + log.Fatal("no PitSvFlags") + } + + bitfield, err := strconv.ParseInt(val.Value.(string), 0, 64) + if err != nil { + log.Fatal("unable to get PitSvFlags: " + err.Error()) + } + + return bitfield&irsdk_RFTireChange != 0 +} + +func (i *IBT) LRTireChange() bool { + val, ok := i.Vars.Vars["PitSvFlags"] + if !ok { + log.Fatal("no PitSvFlags") + } + + bitfield, err := strconv.ParseInt(val.Value.(string), 0, 64) + if err != nil { + log.Fatal("unable to get PitSvFlags: " + err.Error()) + } + + return bitfield&irsdk_LRTireChange != 0 +} + +func (i *IBT) RRTireChange() bool { + val, ok := i.Vars.Vars["PitSvFlags"] + if !ok { + log.Fatal("no PitSvFlags") + } + + bitfield, err := strconv.ParseInt(val.Value.(string), 0, 64) + if err != nil { + log.Fatal("unable to get PitSvFlags: " + err.Error()) + } + + return bitfield&irsdk_RRTireChange != 0 +} + +func (i *IBT) FuelFill() bool { + val, ok := i.Vars.Vars["PitSvFlags"] + if !ok { + log.Fatal("no PitSvFlags") + } + + bitfield, err := strconv.ParseInt(val.Value.(string), 0, 64) + if err != nil { + log.Fatal("unable to get PitSvFlags: " + err.Error()) + } + + return bitfield&irsdk_FuelFill != 0 +} + +func (i *IBT) WindshieldTearoff() bool { + val, ok := i.Vars.Vars["PitSvFlags"] + if !ok { + log.Fatal("no PitSvFlags") + } + + bitfield, err := strconv.ParseInt(val.Value.(string), 0, 64) + if err != nil { + log.Fatal("unable to get PitSvFlags: " + err.Error()) + } + + return bitfield&irsdk_WindshieldTearoff != 0 +} + +func (i *IBT) FastRepair() bool { + val, ok := i.Vars.Vars["PitSvFlags"] + if !ok { + log.Fatal("no PitSvFlags") + } + + bitfield, err := strconv.ParseInt(val.Value.(string), 0, 64) + if err != nil { + log.Fatal("unable to get PitSvFlags: " + err.Error()) + } + + return bitfield&irsdk_FastRepair != 0 +} + +func (i *IBT) ClearTires() bool { + val, ok := i.Vars.Vars["PitSvFlags"] + if !ok { + log.Fatal("no PitSvFlags") + } + + bitfield, err := strconv.ParseInt(val.Value.(string), 0, 64) + if err != nil { + log.Fatal("unable to get PitSvFlags: " + err.Error()) + } + + return bitfield&irsdk_ClearTires != 0 +} + +func (i *IBT) ClearWS() bool { + val, ok := i.Vars.Vars["PitSvFlags"] + if !ok { + log.Fatal("no PitSvFlags") + } + + bitfield, err := strconv.ParseInt(val.Value.(string), 0, 64) + if err != nil { + log.Fatal("unable to get PitSvFlags: " + err.Error()) + } + + return bitfield&irsdk_ClearWS != 0 +} + +func (i *IBT) ClearFR() bool { + val, ok := i.Vars.Vars["PitSvFlags"] + if !ok { + log.Fatal("no PitSvFlags") + } + + bitfield, err := strconv.ParseInt(val.Value.(string), 0, 64) + if err != nil { + log.Fatal("unable to get PitSvFlags: " + err.Error()) + } + + return bitfield&irsdk_ClearFR != 0 +} + +func (i *IBT) ClearFuel() bool { + val, ok := i.Vars.Vars["PitSvFlags"] + if !ok { + log.Fatal("no PitSvFlags") + } + + bitfield, err := strconv.ParseInt(val.Value.(string), 0, 64) + if err != nil { + log.Fatal("unable to get PitSvFlags: " + err.Error()) + } + + return bitfield&irsdk_ClearFuel != 0 +} + +// PitSvFlags -- End diff --git a/examples/read_from_ibt_file/read_from_ibt_file.go b/examples/read_from_ibt_file/read_from_ibt_file.go index 5694d65..40f3da7 100644 --- a/examples/read_from_ibt_file/read_from_ibt_file.go +++ b/examples/read_from_ibt_file/read_from_ibt_file.go @@ -16,7 +16,7 @@ func main() { // Instantiate our iRacing SDK instance irsdk, err := goirsdk.Init(goirsdk.Options{ SourceType: goirsdk.IBTFile, - SourcePath: "../../../../testTelemetry/gt3_mustang_bathurst.ibt", + SourcePath: "../../../../testTelemetry/mx5_2016Okayama_full_2024_10_19_22_02_12.ibt", IBTExportType: goirsdk.SharedMemoryFile, IBTExportPath: "./exported.ibt", IBTExport: true, @@ -57,9 +57,35 @@ func main() { gear := int32(irsdk.Vars.Vars["Gear"].Value.(int)) rpm := int32(irsdk.Vars.Vars["RPM"].Value.(float32)) speed := int32(msToKph(irsdk.Vars.Vars["Speed"].Value.(float32))) + sessionState := irsdk.Vars.Vars["SessionState"].Value.(int) + trkloc := irsdk.Vars.Vars["PlayerTrackSurface"].Value.(int) + trksurf := irsdk.Vars.Vars["PlayerTrackSurfaceMaterial"].Value.(int) + pitsvflags := irsdk.Vars.Vars["PitSvFlags"].Value.(string) fmt.Printf("\033[?25l\033[2J\033[H") - fmt.Printf("Gear: %d, RPM: %d, Speed: %d", gear, rpm, speed) + fmt.Printf("Gear: %d, RPM: %d, Speed: %d\n", gear, rpm, speed) + fmt.Printf("SessionState: %s\n", goirsdk.SessionStateToString(sessionState)) + fmt.Printf("TrkLoc: %s\n", goirsdk.TrkLocToString(trkloc)) + fmt.Printf("TrkSurf: %s\n", goirsdk.TrkSurfToString(trksurf)) + fmt.Printf("PitSvFlags: %s\n", pitsvflags) + fmt.Printf(" FL FR\n") + fmt.Printf(" %t %t\n", irsdk.LFTireChange(), irsdk.RFTireChange()) + fmt.Printf("\n") + fmt.Printf(" RL RR\n") + fmt.Printf(" %t %t\n", irsdk.LRTireChange(), irsdk.RRTireChange()) + fmt.Printf(" FuelFill: %t\n", irsdk.FuelFill()) + fmt.Printf(" WindshieldTearoff: %t\n", irsdk.WindshieldTearoff()) + fmt.Printf(" FastRepair: %t\n", irsdk.FastRepair()) + fmt.Printf(" ClearTires: %t\n", irsdk.ClearTires()) + fmt.Printf(" ClearWS: %t\n", irsdk.ClearWS()) + fmt.Printf(" ClearFR: %t\n", irsdk.ClearFR()) + fmt.Printf(" ClearFuel: %t\n", irsdk.ClearFuel()) + + // fmt.Printf("Vars:\n") + // for _, v := range irsdk.ListVariables() { + // fmt.Printf("%+v\n", v.Name) + // } + // os.Exit(0) <-mainLoopTicker.C } diff --git a/irsdk.go b/irsdk.go index 7422bab..11afb98 100644 --- a/irsdk.go +++ b/irsdk.go @@ -44,15 +44,10 @@ type Options struct { // IBT struct will hold the relevant data for a given IBT file type IBT struct { - File Reader // Source of the data - Opts Options - // TODO: IBTExporter should be an interface because we need to support shm too + File Reader // Source of the data + Opts Options IBTExporter Writer - // IBTExport *os.File // If set, it will export the IBT data to the file - // IBTExportPath string // Path for IBT export - // YAMLExport *os.File // If set, it will export the session YAML to the file - // YAMLExportPath string // Path for YAML export - winUtils *mmaputils.IRacingWinUtils // WinUtils gives access to the system utilities + winUtils *mmaputils.IRacingWinUtils // WinUtils gives access to the system utilities // TODO: fragment this struct a little bit, for now I want to actually get // stuff done so its enough to work as is @@ -232,6 +227,10 @@ func Init(opts Options) (*IBT, error) { return &ibt, nil } +func (i *IBT) ListVariables() map[string]Var { + return i.Vars.Vars +} + // Close cleans up our irsdk instance func (i *IBT) Close() { if i.winUtils != nil {