diff --git a/src/openrct2-ui/windows/InstallTrack.cpp b/src/openrct2-ui/windows/InstallTrack.cpp
index def17b0a04..91546046e7 100644
--- a/src/openrct2-ui/windows/InstallTrack.cpp
+++ b/src/openrct2-ui/windows/InstallTrack.cpp
@@ -198,17 +198,17 @@ static Widget window_install_track_widgets[] = {
             {
                 auto ft = Formatter();
 
-                const auto* objectEntry = ObjectManagerLoadObject(&td->vehicleObject.Entry);
+                const auto* objectEntry = ObjectManagerLoadObject(&td->trackAndVehicle.vehicleObject.Entry);
                 if (objectEntry != nullptr)
                 {
                     auto groupIndex = ObjectManagerGetLoadedObjectEntryIndex(objectEntry);
-                    auto rideName = GetRideNaming(td->type, *GetRideEntryByIndex(groupIndex));
+                    auto rideName = GetRideNaming(td->trackAndVehicle.rtdIndex, *GetRideEntryByIndex(groupIndex));
                     ft.Add<StringId>(rideName.Name);
                 }
                 else
                 {
                     // Fall back on the technical track name if the vehicle object cannot be loaded
-                    ft.Add<StringId>(GetRideTypeDescriptor(td->type).Naming.Name);
+                    ft.Add<StringId>(GetRideTypeDescriptor(td->trackAndVehicle.rtdIndex).Naming.Name);
                 }
 
                 DrawTextBasic(dpi, screenPos, STR_TRACK_DESIGN_TYPE, ft);
@@ -238,10 +238,10 @@ static Widget window_install_track_widgets[] = {
                 screenPos.y += kListRowHeight + 4;
             }
 
-            const auto& rtd = GetRideTypeDescriptor(td->type);
+            const auto& rtd = GetRideTypeDescriptor(td->trackAndVehicle.rtdIndex);
             if (!rtd.HasFlag(RIDE_TYPE_FLAG_IS_MAZE))
             {
-                if (td->type == RIDE_TYPE_MINI_GOLF)
+                if (td->trackAndVehicle.rtdIndex == RIDE_TYPE_MINI_GOLF)
                 {
                     // Holes
                     uint16_t holes = td->statistics.holes & 0x1F;
@@ -278,7 +278,7 @@ static Widget window_install_track_widgets[] = {
                 screenPos.y += kListRowHeight;
             }
 
-            if (GetRideTypeDescriptor(td->type).HasFlag(RIDE_TYPE_FLAG_HAS_G_FORCES))
+            if (GetRideTypeDescriptor(td->trackAndVehicle.rtdIndex).HasFlag(RIDE_TYPE_FLAG_HAS_G_FORCES))
             {
                 // Maximum positive vertical Gs
                 {
@@ -315,7 +315,7 @@ static Widget window_install_track_widgets[] = {
                 }
             }
 
-            if (GetRideTypeDescriptor(td->type).HasFlag(RIDE_TYPE_FLAG_HAS_DROPS))
+            if (GetRideTypeDescriptor(td->trackAndVehicle.rtdIndex).HasFlag(RIDE_TYPE_FLAG_HAS_DROPS))
             {
                 // Drops
                 uint16_t drops = td->statistics.drops & 0x3F;
@@ -329,7 +329,7 @@ static Widget window_install_track_widgets[] = {
                 screenPos.y += kListRowHeight;
             }
 
-            if (td->type != RIDE_TYPE_MINI_GOLF)
+            if (td->trackAndVehicle.rtdIndex != RIDE_TYPE_MINI_GOLF)
             {
                 uint16_t inversions = td->statistics.inversions & 0x1F;
                 if (inversions != 0)
@@ -417,12 +417,12 @@ static Widget window_install_track_widgets[] = {
         }
 
         ObjectManagerUnloadAllObjects();
-        if (trackDesign->type == RIDE_TYPE_NULL)
+        if (trackDesign->trackAndVehicle.rtdIndex == RIDE_TYPE_NULL)
         {
             LOG_ERROR("Failed to load track (ride type null): %s", path);
             return nullptr;
         }
-        if (ObjectManagerLoadObject(&trackDesign->vehicleObject.Entry) == nullptr)
+        if (ObjectManagerLoadObject(&trackDesign->trackAndVehicle.vehicleObject.Entry) == nullptr)
         {
             LOG_ERROR("Failed to load track (vehicle load fail): %s", path);
             return nullptr;
diff --git a/src/openrct2-ui/windows/TrackDesignPlace.cpp b/src/openrct2-ui/windows/TrackDesignPlace.cpp
index e858232f84..3dd61d347b 100644
--- a/src/openrct2-ui/windows/TrackDesignPlace.cpp
+++ b/src/openrct2-ui/windows/TrackDesignPlace.cpp
@@ -366,7 +366,7 @@ static Widget _trackPlaceWidgets[] = {
                     origin.y -= ((max.y + min.y) >> 6) * COORDS_XY_STEP;
                 }
 
-                const auto& rtd = GetRideTypeDescriptor(td->type);
+                const auto& rtd = GetRideTypeDescriptor(td->trackAndVehicle.rtdIndex);
                 if (rtd.HasFlag(RIDE_TYPE_FLAG_IS_MAZE))
                 {
                     DrawMiniPreviewMaze(td, pass, origin, min, max);
diff --git a/src/openrct2-ui/windows/TrackList.cpp b/src/openrct2-ui/windows/TrackList.cpp
index 3410ab1df5..9c9e75b9f2 100644
--- a/src/openrct2-ui/windows/TrackList.cpp
+++ b/src/openrct2-ui/windows/TrackList.cpp
@@ -559,12 +559,12 @@ static Widget _trackListWidgets[] = {
             screenPos.y += kListRowHeight + 4;
 
             // Information for tracked rides.
-            if (GetRideTypeDescriptor(_loadedTrackDesign->type).HasFlag(RIDE_TYPE_FLAG_HAS_TRACK))
+            if (GetRideTypeDescriptor(_loadedTrackDesign->trackAndVehicle.rtdIndex).HasFlag(RIDE_TYPE_FLAG_HAS_TRACK))
             {
-                const auto& rtd = GetRideTypeDescriptor(_loadedTrackDesign->type);
+                const auto& rtd = GetRideTypeDescriptor(_loadedTrackDesign->trackAndVehicle.rtdIndex);
                 if (!rtd.HasFlag(RIDE_TYPE_FLAG_IS_MAZE))
                 {
-                    if (_loadedTrackDesign->type == RIDE_TYPE_MINI_GOLF)
+                    if (_loadedTrackDesign->trackAndVehicle.rtdIndex == RIDE_TYPE_MINI_GOLF)
                     {
                         // Holes
                         ft = Formatter();
@@ -595,7 +595,7 @@ static Widget _trackListWidgets[] = {
                     screenPos.y += kListRowHeight;
                 }
 
-                if (GetRideTypeDescriptor(_loadedTrackDesign->type).HasFlag(RIDE_TYPE_FLAG_HAS_G_FORCES))
+                if (GetRideTypeDescriptor(_loadedTrackDesign->trackAndVehicle.rtdIndex).HasFlag(RIDE_TYPE_FLAG_HAS_G_FORCES))
                 {
                     // Maximum positive vertical Gs
                     ft = Formatter();
@@ -625,7 +625,7 @@ static Widget _trackListWidgets[] = {
                     }
                 }
 
-                if (GetRideTypeDescriptor(_loadedTrackDesign->type).HasFlag(RIDE_TYPE_FLAG_HAS_DROPS))
+                if (GetRideTypeDescriptor(_loadedTrackDesign->trackAndVehicle.rtdIndex).HasFlag(RIDE_TYPE_FLAG_HAS_DROPS))
                 {
                     // Drops
                     ft = Formatter();
@@ -640,7 +640,7 @@ static Widget _trackListWidgets[] = {
                     screenPos.y += kListRowHeight;
                 }
 
-                if (_loadedTrackDesign->type != RIDE_TYPE_MINI_GOLF)
+                if (_loadedTrackDesign->trackAndVehicle.rtdIndex != RIDE_TYPE_MINI_GOLF)
                 {
                     uint16_t inversions = _loadedTrackDesign->statistics.inversions & 0x1F;
                     if (inversions != 0)
diff --git a/src/openrct2/actions/TrackDesignAction.cpp b/src/openrct2/actions/TrackDesignAction.cpp
index 29f000332a..9dea4ad772 100644
--- a/src/openrct2/actions/TrackDesignAction.cpp
+++ b/src/openrct2/actions/TrackDesignAction.cpp
@@ -66,7 +66,7 @@ GameActions::Result TrackDesignAction::Query() const
 
     auto& gameState = GetGameState();
     auto& objManager = GetContext()->GetObjectManager();
-    auto entryIndex = objManager.GetLoadedObjectEntryIndex(_td.vehicleObject);
+    auto entryIndex = objManager.GetLoadedObjectEntryIndex(_td.trackAndVehicle.vehicleObject);
     if (entryIndex == OBJECT_ENTRY_INDEX_NULL)
     {
         // Force a fallback if the entry is not invented yet a track design of it is selected,
@@ -78,7 +78,7 @@ GameActions::Result TrackDesignAction::Query() const
     }
 
     // Colours do not matter as will be overwritten
-    auto rideCreateAction = RideCreateAction(_td.type, entryIndex, 0, 0, gameState.LastEntranceStyle);
+    auto rideCreateAction = RideCreateAction(_td.trackAndVehicle.rtdIndex, entryIndex, 0, 0, gameState.LastEntranceStyle);
     rideCreateAction.SetFlags(GetFlags());
     auto r = GameActions::ExecuteNested(&rideCreateAction);
     if (r.Error != GameActions::Status::Ok)
@@ -140,7 +140,7 @@ GameActions::Result TrackDesignAction::Execute() const
 
     auto& gameState = GetGameState();
     auto& objManager = GetContext()->GetObjectManager();
-    auto entryIndex = objManager.GetLoadedObjectEntryIndex(_td.vehicleObject);
+    auto entryIndex = objManager.GetLoadedObjectEntryIndex(_td.trackAndVehicle.vehicleObject);
     if (entryIndex != OBJECT_ENTRY_INDEX_NULL)
     {
         // Force a fallback if the entry is not invented yet a track design using it is selected.
@@ -152,7 +152,7 @@ GameActions::Result TrackDesignAction::Execute() const
     }
 
     // Colours do not matter as will be overwritten
-    auto rideCreateAction = RideCreateAction(_td.type, entryIndex, 0, 0, gameState.LastEntranceStyle);
+    auto rideCreateAction = RideCreateAction(_td.trackAndVehicle.rtdIndex, entryIndex, 0, 0, gameState.LastEntranceStyle);
     rideCreateAction.SetFlags(GetFlags());
     auto r = GameActions::ExecuteNested(&rideCreateAction);
     if (r.Error != GameActions::Status::Ok)
@@ -226,10 +226,10 @@ GameActions::Result TrackDesignAction::Execute() const
 
     SetOperatingSettingNested(
         ride->id, RideSetSetting::Mode, static_cast<uint8_t>(_td.operation.rideMode), GAME_COMMAND_FLAG_APPLY);
-    auto rideSetVehicleAction2 = RideSetVehicleAction(ride->id, RideSetVehicleType::NumTrains, _td.numberOfTrains);
+    auto rideSetVehicleAction2 = RideSetVehicleAction(ride->id, RideSetVehicleType::NumTrains, _td.trackAndVehicle.numberOfTrains);
     GameActions::ExecuteNested(&rideSetVehicleAction2);
 
-    auto rideSetVehicleAction3 = RideSetVehicleAction(ride->id, RideSetVehicleType::NumCarsPerTrain, _td.numberOfCarsPerTrain);
+    auto rideSetVehicleAction3 = RideSetVehicleAction(ride->id, RideSetVehicleType::NumCarsPerTrain, _td.trackAndVehicle.numberOfCarsPerTrain);
     GameActions::ExecuteNested(&rideSetVehicleAction3);
 
     SetOperatingSettingNested(ride->id, RideSetSetting::Departure, _td.operation.departFlags, GAME_COMMAND_FLAG_APPLY);
diff --git a/src/openrct2/rct1/T4Importer.cpp b/src/openrct2/rct1/T4Importer.cpp
index 70fb6eafd7..38813903d0 100644
--- a/src/openrct2/rct1/T4Importer.cpp
+++ b/src/openrct2/rct1/T4Importer.cpp
@@ -125,7 +125,7 @@ namespace RCT1
 
         std::unique_ptr<TrackDesign> ImportTD4Base(std::unique_ptr<TrackDesign> td, TD4& td4Base)
         {
-            td->type = RCT1::GetRideType(td4Base.Type, td4Base.VehicleType);
+            td->trackAndVehicle.rtdIndex = RCT1::GetRideType(td4Base.Type, td4Base.VehicleType);
 
             // All TD4s that use powered launch use the type that doesn't pass the station.
             td->operation.rideMode = static_cast<RideMode>(td4Base.Mode);
@@ -144,7 +144,7 @@ namespace RCT1
                 vehicleObject = RCT1::GetVehicleObject(td4Base.VehicleType);
             }
             assert(!vehicleObject.empty());
-            td->vehicleObject = ObjectEntryDescriptor(vehicleObject);
+            td->trackAndVehicle.vehicleObject = ObjectEntryDescriptor(vehicleObject);
             td->appearance.vehicleColourSettings = static_cast<VehicleColourSettings>(td4Base.VersionAndColourScheme & 0x3);
 
             // Vehicle colours
@@ -200,12 +200,12 @@ namespace RCT1
 
             td->appearance.stationObjectIdentifier = GetStationIdentifierFromStyle(RCT12_STATION_STYLE_PLAIN);
             td->operation.departFlags = td4Base.DepartFlags;
-            td->numberOfTrains = td4Base.NumberOfTrains;
-            td->numberOfCarsPerTrain = td4Base.NumberOfCarsPerTrain;
+            td->trackAndVehicle.numberOfTrains = td4Base.NumberOfTrains;
+            td->trackAndVehicle.numberOfCarsPerTrain = td4Base.NumberOfCarsPerTrain;
             td->operation.minWaitingTime = td4Base.MinWaitingTime;
             td->operation.maxWaitingTime = td4Base.MaxWaitingTime;
             td->operation.operationSetting = std::min(
-                td4Base.OperationSetting, GetRideTypeDescriptor(td->type).OperatingSettings.MaxValue);
+                td4Base.OperationSetting, GetRideTypeDescriptor(td->trackAndVehicle.rtdIndex).OperatingSettings.MaxValue);
             td->statistics.maxSpeed = td4Base.MaxSpeed;
             td->statistics.averageSpeed = td4Base.AverageSpeed;
             td->statistics.rideLength = td4Base.RideLength;
@@ -213,7 +213,7 @@ namespace RCT1
             td->statistics.maxNegativeVerticalG = td4Base.MaxNegativeVerticalG;
             td->statistics.maxLateralG = td4Base.MaxLateralG;
 
-            if (td->type == RIDE_TYPE_MINI_GOLF)
+            if (td->trackAndVehicle.rtdIndex == RIDE_TYPE_MINI_GOLF)
             {
                 td->statistics.holes = td4Base.NumHoles;
             }
@@ -232,9 +232,9 @@ namespace RCT1
             td->operation.liftHillSpeed = 5;
             td->operation.numCircuits = 0;
             td->operation.operationSetting = std::min(
-                td->operation.operationSetting, GetRideTypeDescriptor(td->type).OperatingSettings.MaxValue);
+                td->operation.operationSetting, GetRideTypeDescriptor(td->trackAndVehicle.rtdIndex).OperatingSettings.MaxValue);
 
-            const auto& rtd = GetRideTypeDescriptor(td->type);
+            const auto& rtd = GetRideTypeDescriptor(td->trackAndVehicle.rtdIndex);
             if (rtd.HasFlag(RIDE_TYPE_FLAG_IS_MAZE))
             {
                 TD46MazeElement t4MazeElement{};
@@ -256,7 +256,7 @@ namespace RCT1
                     _stream.SetPosition(_stream.GetPosition() - 1);
                     _stream.Read(&t4TrackElement, sizeof(TD46TrackElement));
                     TrackDesignTrackElement trackElement{};
-                    trackElement.type = RCT1TrackTypeToOpenRCT2(t4TrackElement.Type, td->type);
+                    trackElement.type = RCT1TrackTypeToOpenRCT2(t4TrackElement.Type, td->trackAndVehicle.rtdIndex);
                     ConvertFromTD46Flags(trackElement, t4TrackElement.Flags);
                     td->trackElements.push_back(trackElement);
                 }
diff --git a/src/openrct2/rct2/T6Exporter.cpp b/src/openrct2/rct2/T6Exporter.cpp
index 27bc4b5611..8656810e35 100644
--- a/src/openrct2/rct2/T6Exporter.cpp
+++ b/src/openrct2/rct2/T6Exporter.cpp
@@ -52,7 +52,7 @@ namespace RCT2
     bool T6Exporter::SaveTrack(OpenRCT2::IStream* stream)
     {
         OpenRCT2::MemoryStream tempStream;
-        tempStream.WriteValue<uint8_t>(OpenRCT2RideTypeToRCT2RideType(_trackDesign->type));
+        tempStream.WriteValue<uint8_t>(OpenRCT2RideTypeToRCT2RideType(_trackDesign->trackAndVehicle.rtdIndex));
         tempStream.WriteValue<uint8_t>(0);
         tempStream.WriteValue<uint32_t>(0);
         tempStream.WriteValue<uint8_t>(static_cast<uint8_t>(_trackDesign->operation.rideMode));
@@ -67,8 +67,8 @@ namespace RCT2
         tempStream.WriteValue<uint8_t>(entranceStyle);
         tempStream.WriteValue<uint8_t>(_trackDesign->statistics.totalAirTime);
         tempStream.WriteValue<uint8_t>(_trackDesign->operation.departFlags);
-        tempStream.WriteValue<uint8_t>(_trackDesign->numberOfTrains);
-        tempStream.WriteValue<uint8_t>(_trackDesign->numberOfCarsPerTrain);
+        tempStream.WriteValue<uint8_t>(_trackDesign->trackAndVehicle.numberOfTrains);
+        tempStream.WriteValue<uint8_t>(_trackDesign->trackAndVehicle.numberOfCarsPerTrain);
         tempStream.WriteValue<uint8_t>(_trackDesign->operation.minWaitingTime);
         tempStream.WriteValue<uint8_t>(_trackDesign->operation.maxWaitingTime);
         tempStream.WriteValue<uint8_t>(_trackDesign->operation.operationSetting);
@@ -78,8 +78,8 @@ namespace RCT2
         tempStream.WriteValue<uint8_t>(_trackDesign->statistics.maxPositiveVerticalG);
         tempStream.WriteValue<int8_t>(_trackDesign->statistics.maxNegativeVerticalG);
         tempStream.WriteValue<uint8_t>(_trackDesign->statistics.maxLateralG);
-        tempStream.WriteValue<uint8_t>(
-            _trackDesign->type == RIDE_TYPE_MINI_GOLF ? _trackDesign->statistics.holes : _trackDesign->statistics.inversions);
+        // inversions double as hole count for mini golf
+        tempStream.WriteValue<uint8_t>(_trackDesign->statistics.inversions);
         tempStream.WriteValue<uint8_t>(_trackDesign->statistics.drops);
         tempStream.WriteValue<uint8_t>(_trackDesign->statistics.highestDropHeight);
         tempStream.WriteValue<uint8_t>(_trackDesign->statistics.ratings.excitement / kTD46RatingsMultiplier);
@@ -99,7 +99,7 @@ namespace RCT2
             tempStream.WriteValue<uint8_t>(_trackDesign->appearance.trackColours[i].supports);
         }
         tempStream.WriteValue<uint32_t>(0);
-        tempStream.Write(&_trackDesign->vehicleObject.Entry, sizeof(RCTObjectEntry));
+        tempStream.Write(&_trackDesign->trackAndVehicle.vehicleObject.Entry, sizeof(RCTObjectEntry));
         tempStream.WriteValue<uint8_t>(_trackDesign->statistics.spaceRequired.x);
         tempStream.WriteValue<uint8_t>(_trackDesign->statistics.spaceRequired.y);
         for (auto i = 0; i < RCT2::Limits::kMaxVehicleColours; i++)
@@ -108,7 +108,7 @@ namespace RCT2
         }
         tempStream.WriteValue<uint8_t>(_trackDesign->operation.liftHillSpeed | (_trackDesign->operation.numCircuits << 5));
 
-        const auto& rtd = GetRideTypeDescriptor(_trackDesign->type);
+        const auto& rtd = GetRideTypeDescriptor(_trackDesign->trackAndVehicle.rtdIndex);
         if (rtd.HasFlag(RIDE_TYPE_FLAG_IS_MAZE))
         {
             for (const auto& mazeElement : _trackDesign->mazeElements)
diff --git a/src/openrct2/rct2/T6Importer.cpp b/src/openrct2/rct2/T6Importer.cpp
index 853f591037..35278b80cd 100644
--- a/src/openrct2/rct2/T6Importer.cpp
+++ b/src/openrct2/rct2/T6Importer.cpp
@@ -71,7 +71,7 @@ namespace RCT2
             // Rework td6 so that it is just the fields
             _stream.Read(&td6, 0xA3);
 
-            td->type = td6.Type; // 0x00
+            td->trackAndVehicle.rtdIndex = td6.Type; // 0x00
 
             td->operation.rideMode = static_cast<RideMode>(td6.RideMode);
             td->appearance.vehicleColourSettings = static_cast<VehicleColourSettings>(td6.VersionAndColourScheme & 0x3);
@@ -84,8 +84,8 @@ namespace RCT2
             td->appearance.stationObjectIdentifier = GetStationIdentifierFromStyle(td6.EntranceStyle);
             td->statistics.totalAirTime = td6.TotalAirTime;
             td->operation.departFlags = td6.DepartFlags;
-            td->numberOfTrains = td6.NumberOfTrains;
-            td->numberOfCarsPerTrain = td6.NumberOfCarsPerTrain;
+            td->trackAndVehicle.numberOfTrains = td6.NumberOfTrains;
+            td->trackAndVehicle.numberOfCarsPerTrain = td6.NumberOfCarsPerTrain;
             td->operation.minWaitingTime = td6.MinWaitingTime;
             td->operation.maxWaitingTime = td6.MaxWaitingTime;
             td->operation.operationSetting = td6.OperationSetting;
@@ -96,7 +96,7 @@ namespace RCT2
             td->statistics.maxNegativeVerticalG = td6.MaxNegativeVerticalG;
             td->statistics.maxLateralG = td6.MaxLateralG;
 
-            if (td->type == RIDE_TYPE_MINI_GOLF)
+            if (td->trackAndVehicle.rtdIndex == RIDE_TYPE_MINI_GOLF)
             {
                 td->statistics.holes = td6.Holes;
             }
@@ -117,7 +117,7 @@ namespace RCT2
                 td->appearance.trackColours[i].additional = td6.TrackRailColour[i];
                 td->appearance.trackColours[i].supports = td6.TrackSupportColour[i];
             }
-            td->vehicleObject = ObjectEntryDescriptor(td6.VehicleObject);
+            td->trackAndVehicle.vehicleObject = ObjectEntryDescriptor(td6.VehicleObject);
             td->statistics.spaceRequired = { td6.SpaceRequiredX, td6.SpaceRequiredY };
             td->operation.liftHillSpeed = td6.LiftHillSpeedNumCircuits & 0b00011111;
             td->operation.numCircuits = td6.LiftHillSpeedNumCircuits >> 5;
@@ -130,9 +130,9 @@ namespace RCT2
             }
 
             td->operation.operationSetting = std::min(
-                td->operation.operationSetting, GetRideTypeDescriptor(td->type).OperatingSettings.MaxValue);
+                td->operation.operationSetting, GetRideTypeDescriptor(td->trackAndVehicle.rtdIndex).OperatingSettings.MaxValue);
 
-            const auto& rtd = GetRideTypeDescriptor(td->type);
+            const auto& rtd = GetRideTypeDescriptor(td->trackAndVehicle.rtdIndex);
             if (rtd.HasFlag(RIDE_TYPE_FLAG_IS_MAZE))
             {
                 TD46MazeElement t6MazeElement{};
@@ -155,7 +155,7 @@ namespace RCT2
                     _stream.Read(&t6TrackElement, sizeof(TD46TrackElement));
                     TrackDesignTrackElement trackElement{};
 
-                    track_type_t trackType = RCT2TrackTypeToOpenRCT2(t6TrackElement.Type, td->type, true);
+                    track_type_t trackType = RCT2TrackTypeToOpenRCT2(t6TrackElement.Type, td->trackAndVehicle.rtdIndex, true);
                     if (trackType == TrackElemType::InvertedUp90ToFlatQuarterLoopAlias)
                     {
                         trackType = TrackElemType::MultiDimInvertedUp90ToFlatQuarterLoop;
@@ -207,17 +207,17 @@ namespace RCT2
 
         void UpdateRideType(std::unique_ptr<TrackDesign>& td)
         {
-            if (RCT2RideTypeNeedsConversion(td->type))
+            if (RCT2RideTypeNeedsConversion(td->trackAndVehicle.rtdIndex))
             {
                 std::scoped_lock<std::mutex> lock(_objectLookupMutex);
-                auto rawObject = ObjectRepositoryLoadObject(&td->vehicleObject.Entry);
+                auto rawObject = ObjectRepositoryLoadObject(&td->trackAndVehicle.vehicleObject.Entry);
                 if (rawObject != nullptr)
                 {
                     const auto* rideEntry = static_cast<const RideObjectEntry*>(
                         static_cast<RideObject*>(rawObject.get())->GetLegacyData());
                     if (rideEntry != nullptr)
                     {
-                        td->type = RCT2RideTypeToOpenRCT2RideType(td->type, *rideEntry);
+                        td->trackAndVehicle.rtdIndex = RCT2RideTypeToOpenRCT2RideType(td->trackAndVehicle.rtdIndex, *rideEntry);
                     }
                     rawObject->Unload();
                 }
diff --git a/src/openrct2/ride/TrackDesign.cpp b/src/openrct2/ride/TrackDesign.cpp
index ef0dce9a93..9750cdd6b5 100644
--- a/src/openrct2/ride/TrackDesign.cpp
+++ b/src/openrct2/ride/TrackDesign.cpp
@@ -109,7 +109,7 @@ static u8string_view TrackDesignGetStationObjectIdentifier(const Ride& ride)
 
 ResultWithMessage TrackDesign::CreateTrackDesign(TrackDesignState& tds, const Ride& ride)
 {
-    type = ride.type;
+    trackAndVehicle.rtdIndex = ride.type;
 
     auto object = ObjectEntryGetObject(ObjectType::Ride, ride.subtype);
     if (object != nullptr)
@@ -120,7 +120,7 @@ ResultWithMessage TrackDesign::CreateTrackDesign(TrackDesignState& tds, const Ri
         {
             return { false, STR_VEHICLE_UNSUPPORTED_TD6 };
         }
-        vehicleObject = ObjectEntryDescriptor(entry);
+        trackAndVehicle.vehicleObject = ObjectEntryDescriptor(entry);
     }
 
     operation.rideMode = ride.mode;
@@ -137,8 +137,8 @@ ResultWithMessage TrackDesign::CreateTrackDesign(TrackDesignState& tds, const Ri
     }
 
     operation.departFlags = ride.depart_flags;
-    numberOfTrains = ride.NumTrains;
-    numberOfCarsPerTrain = ride.num_cars_per_train;
+    trackAndVehicle.numberOfTrains = ride.NumTrains;
+    trackAndVehicle.numberOfCarsPerTrain = ride.num_cars_per_train;
     operation.minWaitingTime = ride.min_waiting_time;
     operation.maxWaitingTime = ride.max_waiting_time;
     operation.operationSetting = ride.operation_option;
@@ -168,7 +168,7 @@ ResultWithMessage TrackDesign::CreateTrackDesign(TrackDesignState& tds, const Ri
     statistics.ratings = ride.ratings;
     statistics.upkeepCost = ride.upkeep_cost;
 
-    const auto& rtd = GetRideTypeDescriptor(type);
+    const auto& rtd = GetRideTypeDescriptor(trackAndVehicle.rtdIndex);
 
     if (rtd.DesignCreateMode == TrackDesignCreateMode::Maze)
     {
@@ -556,7 +556,7 @@ void TrackDesign::Serialise(DataSerialiser& stream)
         // See sub actions for this information if required.
         return;
     }
-    stream << DS_TAG(type);
+    stream << DS_TAG(trackAndVehicle.rtdIndex);
     stream << DS_TAG(gameStateData.cost);
     stream << DS_TAG(operation.rideMode);
     stream << DS_TAG(gameStateData.flags);
@@ -565,8 +565,8 @@ void TrackDesign::Serialise(DataSerialiser& stream)
     stream << DS_TAG(appearance.stationObjectIdentifier);
     stream << DS_TAG(statistics.totalAirTime);
     stream << DS_TAG(operation.departFlags);
-    stream << DS_TAG(numberOfTrains);
-    stream << DS_TAG(numberOfCarsPerTrain);
+    stream << DS_TAG(trackAndVehicle.numberOfTrains);
+    stream << DS_TAG(trackAndVehicle.numberOfCarsPerTrain);
     stream << DS_TAG(operation.minWaitingTime);
     stream << DS_TAG(operation.maxWaitingTime);
     stream << DS_TAG(operation.operationSetting);
@@ -583,7 +583,7 @@ void TrackDesign::Serialise(DataSerialiser& stream)
     stream << DS_TAG(statistics.ratings);
     stream << DS_TAG(statistics.upkeepCost);
     stream << DS_TAG(appearance.trackColours);
-    stream << DS_TAG(vehicleObject);
+    stream << DS_TAG(trackAndVehicle.vehicleObject);
     stream << DS_TAG(statistics.spaceRequired.x);
     stream << DS_TAG(statistics.spaceRequired.y);
     stream << DS_TAG(operation.liftHillSpeed);
@@ -623,9 +623,9 @@ static void TrackDesignLoadSceneryObjects(TrackDesign* td)
     objectManager.UnloadAllTransient();
 
     // Load ride object
-    if (td->vehicleObject.HasValue())
+    if (td->trackAndVehicle.vehicleObject.HasValue())
     {
-        objectManager.LoadObject(td->vehicleObject);
+        objectManager.LoadObject(td->trackAndVehicle.vehicleObject);
     }
 
     // Load scenery objects
@@ -907,7 +907,7 @@ static void TrackDesignMirrorMaze(TrackDesign* td)
  */
 void TrackDesignMirror(TrackDesign* td)
 {
-    const auto& rtd = GetRideTypeDescriptor(td->type);
+    const auto& rtd = GetRideTypeDescriptor(td->trackAndVehicle.rtdIndex);
     if (rtd.HasFlag(RIDE_TYPE_FLAG_IS_MAZE))
     {
         TrackDesignMirrorMaze(td);
@@ -1766,7 +1766,7 @@ static GameActions::Result TrackDesignPlaceVirtual(
     _currentTrackPieceDirection = coords.direction;
 
     GameActions::Result trackPlaceRes;
-    const auto& rtd = GetRideTypeDescriptor(td->type);
+    const auto& rtd = GetRideTypeDescriptor(td->trackAndVehicle.rtdIndex);
     if (rtd.HasFlag(RIDE_TYPE_FLAG_IS_MAZE))
     {
         trackPlaceRes = TrackDesignPlaceMaze(tds, *td, coords, ride);
@@ -1878,11 +1878,11 @@ static bool TrackDesignPlacePreview(
 
     auto& gameState = GetGameState();
     auto& objManager = GetContext()->GetObjectManager();
-    auto entry_index = objManager.GetLoadedObjectEntryIndex(td->vehicleObject);
+    auto entry_index = objManager.GetLoadedObjectEntryIndex(td->trackAndVehicle.vehicleObject);
 
     RideId rideIndex;
     uint8_t rideCreateFlags = GAME_COMMAND_FLAG_APPLY | GAME_COMMAND_FLAG_ALLOW_DURING_PAUSED | GAME_COMMAND_FLAG_NO_SPEND;
-    if (TrackDesignCreateRide(td->type, entry_index, rideCreateFlags, &rideIndex) == kMoney64Undefined)
+    if (TrackDesignCreateRide(td->trackAndVehicle.rtdIndex, entry_index, rideCreateFlags, &rideIndex) == kMoney64Undefined)
     {
         return false;
     }
@@ -1906,7 +1906,7 @@ static bool TrackDesignPlacePreview(
 
     // Flat rides need their vehicle colours loaded for display
     // in the preview window
-    if (!GetRideTypeDescriptor(td->type).HasFlag(RIDE_TYPE_FLAG_HAS_TRACK))
+    if (!GetRideTypeDescriptor(td->trackAndVehicle.rtdIndex).HasFlag(RIDE_TYPE_FLAG_HAS_TRACK))
     {
         for (size_t i = 0; i < std::size(ride->vehicle_colours); i++)
         {
@@ -2087,7 +2087,7 @@ void TrackDesignDrawPreview(TrackDesign* td, uint8_t* pixels)
 
     // Special case for flat rides - Z-axis info is irrelevant
     // and must be zeroed out lest the preview be off-centre
-    if (!GetRideTypeDescriptor(td->type).HasFlag(RIDE_TYPE_FLAG_HAS_TRACK))
+    if (!GetRideTypeDescriptor(td->trackAndVehicle.rtdIndex).HasFlag(RIDE_TYPE_FLAG_HAS_TRACK))
     {
         centre.z = 0;
         size_z = 0;
diff --git a/src/openrct2/ride/TrackDesign.h b/src/openrct2/ride/TrackDesign.h
index e79adb36e7..5d72334548 100644
--- a/src/openrct2/ride/TrackDesign.h
+++ b/src/openrct2/ride/TrackDesign.h
@@ -138,6 +138,14 @@ enum class TrackDesignGameStateFlag
     VehicleUnavailable,
 };
 
+struct TrackDesignTrackAndVehicleSettings
+{
+    ride_type_t rtdIndex{};
+    ObjectEntryDescriptor vehicleObject{};
+    uint8_t numberOfTrains{};
+    uint8_t numberOfCarsPerTrain{};
+};
+
 struct TrackDesignOperatingSettings
 {
     RideMode rideMode{};
@@ -195,11 +203,7 @@ struct TrackDesignGameStateData
 
 struct TrackDesign
 {
-    uint8_t type;
-    uint8_t numberOfTrains;
-    uint8_t numberOfCarsPerTrain;
-    ObjectEntryDescriptor vehicleObject;
-
+    TrackDesignTrackAndVehicleSettings trackAndVehicle{};
     TrackDesignOperatingSettings operation{};
     TrackDesignAppearanceSettings appearance{};
     TrackDesignStatistics statistics{};
diff --git a/src/openrct2/ride/TrackDesignRepository.cpp b/src/openrct2/ride/TrackDesignRepository.cpp
index e1429aad48..29b5ac0ced 100644
--- a/src/openrct2/ride/TrackDesignRepository.cpp
+++ b/src/openrct2/ride/TrackDesignRepository.cpp
@@ -79,8 +79,8 @@ public:
             TrackRepositoryItem item;
             item.Name = GetNameFromTrackPath(path);
             item.Path = path;
-            item.RideType = td->type;
-            item.ObjectEntry = std::string(td->vehicleObject.Entry.name, 8);
+            item.RideType = td->trackAndVehicle.rtdIndex;
+            item.ObjectEntry = std::string(td->trackAndVehicle.vehicleObject.Entry.name, 8);
             item.Flags = 0;
             if (IsTrackReadOnly(path))
             {