diff --git a/src/openrct2-ui/WindowManager.cpp b/src/openrct2-ui/WindowManager.cpp
index a49ebf164e..4815be66b6 100644
--- a/src/openrct2-ui/WindowManager.cpp
+++ b/src/openrct2-ui/WindowManager.cpp
@@ -190,9 +190,9 @@ public:
             case WD_NEW_CAMPAIGN:
                 return WindowNewCampaignOpen(id);
             case WD_DEMOLISH_RIDE:
-                return WindowRideDemolishPromptOpen(get_ride(RideId::FromUnderlying(id)));
+                return WindowRideDemolishPromptOpen(*get_ride(RideId::FromUnderlying(id)));
             case WD_REFURBISH_RIDE:
-                return WindowRideRefurbishPromptOpen(get_ride(RideId::FromUnderlying(id)));
+                return WindowRideRefurbishPromptOpen(*get_ride(RideId::FromUnderlying(id)));
             case WD_SIGN:
                 return WindowSignOpen(id);
             case WD_SIGN_SMALL:
@@ -269,7 +269,7 @@ public:
             {
                 const auto rideId = RideId::FromUnderlying(intent->GetSIntExtra(INTENT_EXTRA_RIDE_ID));
                 auto ride = get_ride(rideId);
-                return ride == nullptr ? nullptr : WindowRideMainOpen(ride);
+                return ride == nullptr ? nullptr : WindowRideMainOpen(*ride);
             }
             case WindowClass::TrackDesignPlace:
                 return WindowTrackPlaceOpen(
diff --git a/src/openrct2-ui/windows/DemolishRidePrompt.cpp b/src/openrct2-ui/windows/DemolishRidePrompt.cpp
index fc3aa2054d..1e13eee9e9 100644
--- a/src/openrct2-ui/windows/DemolishRidePrompt.cpp
+++ b/src/openrct2-ui/windows/DemolishRidePrompt.cpp
@@ -45,9 +45,9 @@ class DemolishRidePromptWindow final : public Window
     money32 _demolishRideCost;
 
 public:
-    void SetRide(Ride* currentRide)
+    void SetRide(const Ride& currentRide)
     {
-        rideId = currentRide->id;
+        rideId = currentRide.id;
         _demolishRideCost = -ride_get_refund_price(currentRide);
     }
 
@@ -92,7 +92,7 @@ public:
     }
 };
 
-rct_window* WindowRideDemolishPromptOpen(Ride* ride)
+rct_window* WindowRideDemolishPromptOpen(const Ride& ride)
 {
     rct_window* w;
     DemolishRidePromptWindow* newWindow;
diff --git a/src/openrct2-ui/windows/Guest.cpp b/src/openrct2-ui/windows/Guest.cpp
index 3081041701..cda8be28c3 100644
--- a/src/openrct2-ui/windows/Guest.cpp
+++ b/src/openrct2-ui/windows/Guest.cpp
@@ -1242,7 +1242,7 @@ private:
         uint8_t currListPosition = 0;
         for (const auto& r : GetRideManager())
         {
-            if (r.IsRide() && guest->HasRidden(&r))
+            if (r.IsRide() && guest->HasRidden(r))
             {
                 list_item_positions[currListPosition] = r.id.ToUnderlying();
                 currListPosition++;
diff --git a/src/openrct2-ui/windows/MazeConstruction.cpp b/src/openrct2-ui/windows/MazeConstruction.cpp
index 3df9ad68a8..dd527ad93b 100644
--- a/src/openrct2-ui/windows/MazeConstruction.cpp
+++ b/src/openrct2-ui/windows/MazeConstruction.cpp
@@ -363,7 +363,7 @@ private:
             OpenRCT2::Audio::Play3D(OpenRCT2::Audio::SoundId::PlaceItem, result->Position);
 
             auto currentRide = get_ride(rideIndex);
-            if (currentRide != nullptr && ride_are_all_possible_entrances_and_exits_built(currentRide).Successful)
+            if (currentRide != nullptr && ride_are_all_possible_entrances_and_exits_built(*currentRide).Successful)
             {
                 tool_cancel();
                 if (currentRide->GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_HAS_NO_TRACK))
diff --git a/src/openrct2-ui/windows/RefurbishRidePrompt.cpp b/src/openrct2-ui/windows/RefurbishRidePrompt.cpp
index aa358f042d..d876b4701a 100644
--- a/src/openrct2-ui/windows/RefurbishRidePrompt.cpp
+++ b/src/openrct2-ui/windows/RefurbishRidePrompt.cpp
@@ -44,9 +44,9 @@ class RefurbishRidePromptWindow final : public Window
     money32 _demolishRideCost;
 
 public:
-    void SetRide(Ride* currentRide)
+    void SetRide(const Ride& currentRide)
     {
-        rideId = currentRide->id;
+        rideId = currentRide.id;
         _demolishRideCost = -ride_get_refund_price(currentRide);
     }
 
@@ -91,7 +91,7 @@ public:
     }
 };
 
-rct_window* WindowRideRefurbishPromptOpen(Ride* ride)
+rct_window* WindowRideRefurbishPromptOpen(const Ride& ride)
 {
     rct_window* w;
     RefurbishRidePromptWindow* newWindow;
diff --git a/src/openrct2-ui/windows/Ride.cpp b/src/openrct2-ui/windows/Ride.cpp
index 73ed13ad43..2868bad3f0 100644
--- a/src/openrct2-ui/windows/Ride.cpp
+++ b/src/openrct2-ui/windows/Ride.cpp
@@ -72,7 +72,7 @@ static constexpr const StringId WINDOW_TITLE = STR_RIDE_WINDOW_TITLE;
 static constexpr const int32_t WH = 207;
 static constexpr const int32_t WW = 316;
 
-static void PopulateVehicleTypeDropdown(Ride* ride, bool forceRefresh = false);
+static void PopulateVehicleTypeDropdown(const Ride& ride, bool forceRefresh = false);
 
 enum
 {
@@ -973,7 +973,7 @@ static void WindowRideDrawTabVehicle(rct_drawpixelinfo* dpi, rct_window* w)
         CarEntry* carEntry = &rideEntry->Cars[vehicle];
 
         auto vehicleId = ((ride->colour_scheme_type & 3) == VEHICLE_COLOUR_SCHEME_PER_VEHICLE) ? rideEntry->TabCar : 0;
-        VehicleColour vehicleColour = ride_get_vehicle_colour(ride, vehicleId);
+        VehicleColour vehicleColour = ride_get_vehicle_colour(*ride, vehicleId);
 
         // imageIndex represents a precision of 64
         auto imageIndex = OpenRCT2::Entity::Yaw::YawFrom4(2) * 2;
@@ -1088,7 +1088,7 @@ static void WindowRideDisableTabs(rct_window* w)
     w->disabled_widgets = disabled_tabs;
 }
 
-static void WindowRideUpdateOverallView(Ride* ride)
+static void WindowRideUpdateOverallView(const Ride& ride)
 {
     // Calculate x, y, z bounds of the entire ride using its track elements
     tile_element_iterator it;
@@ -1105,7 +1105,7 @@ static void WindowRideUpdateOverallView(Ride* ride)
         if (it.element->GetType() != TileElementType::Track)
             continue;
 
-        if (it.element->AsTrack()->GetRideIndex() != ride->id)
+        if (it.element->AsTrack()->GetRideIndex() != ride.id)
             continue;
 
         auto location = TileCoordsXY(it.x, it.y).ToCoordsXY();
@@ -1121,7 +1121,7 @@ static void WindowRideUpdateOverallView(Ride* ride)
         max.z = std::max(max.z, clearZ);
     }
 
-    const auto rideIndex = ride->id.ToUnderlying();
+    const auto rideIndex = ride.id.ToUnderlying();
     if (rideIndex >= ride_overall_views.size())
     {
         ride_overall_views.resize(rideIndex + 1);
@@ -1153,14 +1153,14 @@ static void WindowRideUpdateOverallView(Ride* ride)
  *
  *  rct2: 0x006AEAB4
  */
-static rct_window* WindowRideOpen(Ride* ride)
+static rct_window* WindowRideOpen(const Ride& ride)
 {
     rct_window* w;
 
     w = WindowCreateAutoPos(316, 207, window_ride_page_events[0], WindowClass::Ride, WF_10 | WF_RESIZABLE);
     w->widgets = window_ride_page_widgets[WINDOW_RIDE_PAGE_MAIN];
     w->hold_down_widgets = window_ride_page_hold_down_widgets[WINDOW_RIDE_PAGE_MAIN];
-    w->rideId = ride->id;
+    w->rideId = ride.id;
 
     w->page = WINDOW_RIDE_PAGE_MAIN;
     w->vehicleIndex = 0;
@@ -1185,21 +1185,21 @@ static rct_window* WindowRideOpen(Ride* ride)
  *
  *  rct2: 0x006ACC28
  */
-rct_window* WindowRideMainOpen(Ride* ride)
+rct_window* WindowRideMainOpen(const Ride& ride)
 {
-    if (ride->type >= RIDE_TYPE_COUNT)
+    if (ride.type >= RIDE_TYPE_COUNT)
     {
         return nullptr;
     }
 
-    rct_window* w = window_bring_to_front_by_number(WindowClass::Ride, ride->id.ToUnderlying());
+    rct_window* w = window_bring_to_front_by_number(WindowClass::Ride, ride.id.ToUnderlying());
     if (w == nullptr)
     {
         w = WindowRideOpen(ride);
         w->ride.var_482 = -1;
         w->ride.view = 0;
     }
-    else if (w->ride.view >= (1 + ride->NumTrains + ride->num_stations))
+    else if (w->ride.view >= (1 + ride.NumTrains + ride.num_stations))
     {
         w->ride.view = 0;
     }
@@ -1225,15 +1225,15 @@ rct_window* WindowRideMainOpen(Ride* ride)
  *
  *  rct2: 0x006ACCCE
  */
-static rct_window* WindowRideOpenStation(Ride* ride, StationIndex stationIndex)
+static rct_window* WindowRideOpenStation(const Ride& ride, StationIndex stationIndex)
 {
-    if (ride->type >= RIDE_TYPE_COUNT)
+    if (ride.type >= RIDE_TYPE_COUNT)
         return nullptr;
 
-    if (ride->GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_NO_VEHICLES))
+    if (ride.GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_NO_VEHICLES))
         return WindowRideMainOpen(ride);
 
-    auto w = window_bring_to_front_by_number(WindowClass::Ride, ride->id.ToUnderlying());
+    auto w = window_bring_to_front_by_number(WindowClass::Ride, ride.id.ToUnderlying());
     if (w == nullptr)
     {
         w = WindowRideOpen(ride);
@@ -1261,13 +1261,13 @@ static rct_window* WindowRideOpenStation(Ride* ride, StationIndex stationIndex)
     // View
     for (int32_t i = stationIndex.ToUnderlying(); i >= 0; i--)
     {
-        if (ride->GetStations()[i].Start.IsNull())
+        if (ride.GetStations()[i].Start.IsNull())
         {
             stationIndex = StationIndex::FromUnderlying(stationIndex.ToUnderlying() - 1);
         }
     }
 
-    w->ride.view = 1 + ride->NumTrains + stationIndex.ToUnderlying();
+    w->ride.view = 1 + ride.NumTrains + stationIndex.ToUnderlying();
     WindowRideInitViewport(w);
 
     return w;
@@ -1288,7 +1288,7 @@ rct_window* WindowRideOpenTrack(TileElement* tileElement)
                 // Open ride window in station view
                 auto entranceElement = tileElement->AsEntrance();
                 auto stationIndex = entranceElement->GetStationIndex();
-                return WindowRideOpenStation(ride, stationIndex);
+                return WindowRideOpenStation(*ride, stationIndex);
             }
             else if (type == TileElementType::Track)
             {
@@ -1299,12 +1299,12 @@ rct_window* WindowRideOpenTrack(TileElement* tileElement)
                 if (ted.SequenceProperties[0] & TRACK_SEQUENCE_FLAG_ORIGIN)
                 {
                     auto stationIndex = trackElement->GetStationIndex();
-                    return WindowRideOpenStation(ride, stationIndex);
+                    return WindowRideOpenStation(*ride, stationIndex);
                 }
             }
 
             // Open ride window in overview mode
-            return WindowRideMainOpen(ride);
+            return WindowRideMainOpen(*ride);
         }
     }
     return nullptr;
@@ -1379,7 +1379,7 @@ rct_window* WindowRideOpenVehicle(Vehicle* vehicle)
 
     if (w == nullptr)
     {
-        w = WindowRideOpen(ride);
+        w = WindowRideOpen(*ride);
         w->ride.var_482 = -1;
     }
 
@@ -1785,18 +1785,17 @@ static void WindowRideShowViewDropdown(rct_window* w, Widget* widget)
     Dropdown::SetChecked(w->ride.view, true);
 }
 
-static RideStatus WindowRideGetNextDefaultStatus(const Ride* ride)
+static RideStatus WindowRideGetNextDefaultStatus(const Ride& ride)
 {
-    switch (ride->status)
+    switch (ride.status)
     {
         default:
         case RideStatus::Closed:
-            if ((ride->lifecycle_flags & RIDE_LIFECYCLE_CRASHED)
-                || (ride->lifecycle_flags & RIDE_LIFECYCLE_HAS_STALLED_VEHICLE))
+            if ((ride.lifecycle_flags & RIDE_LIFECYCLE_CRASHED) || (ride.lifecycle_flags & RIDE_LIFECYCLE_HAS_STALLED_VEHICLE))
             {
                 return RideStatus::Closed;
             }
-            if (ride->SupportsStatus(RideStatus::Testing) && !(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+            if (ride.SupportsStatus(RideStatus::Testing) && !(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
             {
                 return RideStatus::Testing;
             }
@@ -1804,7 +1803,7 @@ static RideStatus WindowRideGetNextDefaultStatus(const Ride* ride)
         case RideStatus::Simulating:
             return RideStatus::Testing;
         case RideStatus::Testing:
-            return (ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED) ? RideStatus::Open : RideStatus::Closed;
+            return (ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED) ? RideStatus::Open : RideStatus::Closed;
         case RideStatus::Open:
             return RideStatus::Closed;
     }
@@ -1848,7 +1847,7 @@ static void WindowRideShowOpenDropdown(rct_window* w, Widget* widget)
         return;
 
     info.CurrentStatus = info.Ride->status;
-    info.DefaultStatus = WindowRideGetNextDefaultStatus(info.Ride);
+    info.DefaultStatus = WindowRideGetNextDefaultStatus(*info.Ride);
     WindowRideSetDropdown(info, RideStatus::Closed, STR_CLOSE_RIDE);
 #ifdef __SIMULATE_IN_RIDE_WINDOW__
     window_ride_set_dropdown(info, RideStatus::Simulating, STR_SIMULATE_RIDE);
@@ -1987,17 +1986,17 @@ static void WindowRideMainFollowRide(rct_window* w)
     }
 }
 
-static void PopulateVehicleTypeDropdown(Ride* ride, bool forceRefresh)
+static void PopulateVehicleTypeDropdown(const Ride& ride, bool forceRefresh)
 {
     auto& objManager = GetContext()->GetObjectManager();
-    rct_ride_entry* rideEntry = ride->GetRideEntry();
+    rct_ride_entry* rideEntry = ride.GetRideEntry();
 
     bool selectionShouldBeExpanded;
     int32_t rideTypeIterator, rideTypeIteratorMax;
 
-    const auto& rtd = ride->GetRideTypeDescriptor();
+    const auto& rtd = ride.GetRideTypeDescriptor();
     if (gCheatsShowVehiclesFromOtherTrackTypes
-        && !(rtd.HasFlag(RIDE_TYPE_FLAG_FLAT_RIDE) || rtd.HasFlag(RIDE_TYPE_FLAG_IS_MAZE) || ride->type == RIDE_TYPE_MINI_GOLF))
+        && !(rtd.HasFlag(RIDE_TYPE_FLAG_FLAT_RIDE) || rtd.HasFlag(RIDE_TYPE_FLAG_IS_MAZE) || ride.type == RIDE_TYPE_MINI_GOLF))
     {
         selectionShouldBeExpanded = true;
         rideTypeIterator = 0;
@@ -2006,8 +2005,8 @@ static void PopulateVehicleTypeDropdown(Ride* ride, bool forceRefresh)
     else
     {
         selectionShouldBeExpanded = false;
-        rideTypeIterator = ride->type;
-        rideTypeIteratorMax = ride->type;
+        rideTypeIterator = ride.type;
+        rideTypeIteratorMax = ride.type;
     }
 
     // Don't repopulate the list if we just did.
@@ -2058,7 +2057,7 @@ static void WindowRideShowVehicleTypeDropdown(rct_window* w, Widget* widget)
     if (ride == nullptr)
         return;
 
-    PopulateVehicleTypeDropdown(ride);
+    PopulateVehicleTypeDropdown(*ride);
 
     size_t numItems = std::min<size_t>(VehicleDropdownData.size(), Dropdown::ItemsMaxSize);
 
@@ -2992,7 +2991,7 @@ static void WindowRideVehicleScrollpaint(rct_window* w, rct_drawpixelinfo* dpi,
                     vehicleColourIndex = j;
                     break;
             }
-            VehicleColour vehicleColour = ride_get_vehicle_colour(ride, vehicleColourIndex);
+            VehicleColour vehicleColour = ride_get_vehicle_colour(*ride, vehicleColourIndex);
 
             ImageIndex imageIndex = carEntry->SpriteByYaw(OpenRCT2::Entity::Yaw::BaseRotation / 2, SpriteGroupType::SlopeFlat);
             imageIndex &= carEntry->TabRotationMask;
@@ -3745,11 +3744,11 @@ static void WindowRideLocateMechanic(rct_window* w)
         return;
 
     // First check if there is a mechanic assigned
-    Peep* mechanic = ride_get_assigned_mechanic(ride);
+    Peep* mechanic = ride_get_assigned_mechanic(*ride);
 
     // Otherwise find the closest mechanic
     if (mechanic == nullptr)
-        mechanic = ride_find_closest_mechanic(ride, 1);
+        mechanic = ride_find_closest_mechanic(*ride, 1);
 
     if (mechanic == nullptr)
         ContextShowError(STR_UNABLE_TO_LOCATE_MECHANIC, STR_NONE, {});
@@ -4024,7 +4023,7 @@ static void WindowRideMaintenanceDropdown(rct_window* w, WidgetIndex widgetIndex
                         num_items++;
                     }
                 }
-                ride_prepare_breakdown(ride, i);
+                ride_prepare_breakdown(*ride, i);
             }
             break;
     }
@@ -4218,13 +4217,13 @@ static void WindowRideMaintenancePaint(rct_window* w, rct_drawpixelinfo* dpi)
 
 #pragma region Colour
 
-static int32_t WindowRideHasTrackColour(Ride* ride, int32_t trackColour)
+static int32_t WindowRideHasTrackColour(const Ride& ride, int32_t trackColour)
 {
     // Get station flags (shops don't have them)
     auto stationObjFlags = 0;
-    if (!ride->GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_IS_SHOP_OR_FACILITY))
+    if (!ride.GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_IS_SHOP_OR_FACILITY))
     {
-        auto stationObj = ride->GetStationObject();
+        auto stationObj = ride.GetStationObject();
         if (stationObj != nullptr)
         {
             stationObjFlags = stationObj->Flags;
@@ -4235,12 +4234,12 @@ static int32_t WindowRideHasTrackColour(Ride* ride, int32_t trackColour)
     {
         case 0:
             return (stationObjFlags & STATION_OBJECT_FLAGS::HAS_PRIMARY_COLOUR)
-                || ride->GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_HAS_TRACK_COLOUR_MAIN);
+                || ride.GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_HAS_TRACK_COLOUR_MAIN);
         case 1:
             return (stationObjFlags & STATION_OBJECT_FLAGS::HAS_SECONDARY_COLOUR)
-                || ride->GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_HAS_TRACK_COLOUR_ADDITIONAL);
+                || ride.GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_HAS_TRACK_COLOUR_ADDITIONAL);
         case 2:
-            return ride->GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_HAS_TRACK_COLOUR_SUPPORTS);
+            return ride.GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_HAS_TRACK_COLOUR_SUPPORTS);
         default:
             return 0;
     }
@@ -4453,15 +4452,15 @@ static void WindowRideColourMousedown(rct_window* w, WidgetIndex widgetIndex, Wi
             Dropdown::SetChecked(w->vehicleIndex, true);
             break;
         case WIDX_VEHICLE_BODY_COLOUR:
-            vehicleColour = ride_get_vehicle_colour(ride, w->vehicleIndex);
+            vehicleColour = ride_get_vehicle_colour(*ride, w->vehicleIndex);
             WindowDropdownShowColour(w, widget, w->colours[1], vehicleColour.Body);
             break;
         case WIDX_VEHICLE_TRIM_COLOUR:
-            vehicleColour = ride_get_vehicle_colour(ride, w->vehicleIndex);
+            vehicleColour = ride_get_vehicle_colour(*ride, w->vehicleIndex);
             WindowDropdownShowColour(w, widget, w->colours[1], vehicleColour.Trim);
             break;
         case WIDX_VEHICLE_TERNARY_COLOUR:
-            vehicleColour = ride_get_vehicle_colour(ride, w->vehicleIndex);
+            vehicleColour = ride_get_vehicle_colour(*ride, w->vehicleIndex);
             WindowDropdownShowColour(w, widget, w->colours[1], vehicleColour.Tertiary);
             break;
     }
@@ -4669,7 +4668,7 @@ static void WindowRideColourInvalidate(rct_window* w)
     }
 
     // Track main colour
-    if (WindowRideHasTrackColour(ride, 0))
+    if (WindowRideHasTrackColour(*ride, 0))
     {
         window_ride_colour_widgets[WIDX_TRACK_MAIN_COLOUR].type = WindowWidgetType::ColourBtn;
         window_ride_colour_widgets[WIDX_TRACK_MAIN_COLOUR].image = GetColourButtonImage(trackColour.main);
@@ -4680,7 +4679,7 @@ static void WindowRideColourInvalidate(rct_window* w)
     }
 
     // Track additional colour
-    if (WindowRideHasTrackColour(ride, 1))
+    if (WindowRideHasTrackColour(*ride, 1))
     {
         window_ride_colour_widgets[WIDX_TRACK_ADDITIONAL_COLOUR].type = WindowWidgetType::ColourBtn;
         window_ride_colour_widgets[WIDX_TRACK_ADDITIONAL_COLOUR].image = GetColourButtonImage(trackColour.additional);
@@ -4709,7 +4708,7 @@ static void WindowRideColourInvalidate(rct_window* w)
     }
 
     // Track supports colour
-    if (WindowRideHasTrackColour(ride, 2) && !rtd.HasFlag(RIDE_TYPE_FLAG_IS_MAZE))
+    if (WindowRideHasTrackColour(*ride, 2) && !rtd.HasFlag(RIDE_TYPE_FLAG_IS_MAZE))
     {
         window_ride_colour_widgets[WIDX_TRACK_SUPPORT_COLOUR].type = WindowWidgetType::ColourBtn;
         window_ride_colour_widgets[WIDX_TRACK_SUPPORT_COLOUR].image = GetColourButtonImage(trackColour.supports);
@@ -4757,7 +4756,7 @@ static void WindowRideColourInvalidate(rct_window* w)
         if (vehicleColourSchemeType == 0)
             w->vehicleIndex = 0;
 
-        vehicleColour = ride_get_vehicle_colour(ride, w->vehicleIndex);
+        vehicleColour = ride_get_vehicle_colour(*ride, w->vehicleIndex);
 
         window_ride_colour_widgets[WIDX_VEHICLE_PREVIEW].type = WindowWidgetType::Scroll;
         window_ride_colour_widgets[WIDX_VEHICLE_BODY_COLOUR].type = WindowWidgetType::ColourBtn;
@@ -4990,7 +4989,7 @@ static void WindowRideColourScrollpaint(rct_window* w, rct_drawpixelinfo* dpi, i
         return;
 
     auto vehiclePreviewWidget = &window_ride_colour_widgets[WIDX_VEHICLE_PREVIEW];
-    auto vehicleColour = ride_get_vehicle_colour(ride, w->vehicleIndex);
+    auto vehicleColour = ride_get_vehicle_colour(*ride, w->vehicleIndex);
 
     // Background colour
     gfx_fill_rect(dpi, { { dpi->x, dpi->y }, { dpi->x + dpi->width - 1, dpi->y + dpi->height - 1 } }, PALETTE_INDEX_12);
@@ -5656,7 +5655,7 @@ static void WindowRideMeasurementsPaint(rct_window* w, rct_drawpixelinfo* dpi)
             auto ft = Formatter();
             ft.Add<uint32_t>(ride->excitement);
             ft.Add<StringId>(ratingName);
-            StringId stringId = !ride_has_ratings(ride) ? STR_EXCITEMENT_RATING_NOT_YET_AVAILABLE : STR_EXCITEMENT_RATING;
+            StringId stringId = !ride_has_ratings(*ride) ? STR_EXCITEMENT_RATING_NOT_YET_AVAILABLE : STR_EXCITEMENT_RATING;
             DrawTextBasic(dpi, screenCoords, stringId, ft);
             screenCoords.y += LIST_ROW_HEIGHT;
 
@@ -5667,7 +5666,7 @@ static void WindowRideMeasurementsPaint(rct_window* w, rct_drawpixelinfo* dpi)
             ft.Add<StringId>(ratingName);
 
             stringId = STR_INTENSITY_RATING;
-            if (!ride_has_ratings(ride))
+            if (!ride_has_ratings(*ride))
                 stringId = STR_INTENSITY_RATING_NOT_YET_AVAILABLE;
             else if (ride->intensity >= RIDE_RATING(10, 00))
                 stringId = STR_INTENSITY_RATING_RED;
@@ -5680,7 +5679,7 @@ static void WindowRideMeasurementsPaint(rct_window* w, rct_drawpixelinfo* dpi)
             ft = Formatter();
             ft.Add<uint32_t>(ride->nausea);
             ft.Add<StringId>(ratingName);
-            stringId = !ride_has_ratings(ride) ? STR_NAUSEA_RATING_NOT_YET_AVAILABLE : STR_NAUSEA_RATING;
+            stringId = !ride_has_ratings(*ride) ? STR_NAUSEA_RATING_NOT_YET_AVAILABLE : STR_NAUSEA_RATING;
             DrawTextBasic(dpi, screenCoords, stringId, ft);
             screenCoords.y += 2 * LIST_ROW_HEIGHT;
 
@@ -6660,7 +6659,7 @@ static void WindowRideIncomeInvalidate(rct_window* w)
     window_ride_income_widgets[WIDX_PRIMARY_PRICE_SAME_THROUGHOUT_PARK].type = WindowWidgetType::Empty;
 
     window_ride_income_widgets[WIDX_PRIMARY_PRICE].text = STR_BOTTOM_TOOLBAR_CASH;
-    money16 ridePrimaryPrice = ride_get_price(ride);
+    money16 ridePrimaryPrice = ride_get_price(*ride);
     ft.Rewind();
     ft.Add<money64>(ridePrimaryPrice);
     if (ridePrimaryPrice == 0)
@@ -6983,7 +6982,7 @@ static void WindowRideCustomerPaint(rct_window* w, rct_drawpixelinfo* dpi)
 
     // Customers per hour
     auto ft = Formatter();
-    ft.Add<int32_t>(ride_customers_per_hour(ride));
+    ft.Add<int32_t>(ride_customers_per_hour(*ride));
     DrawTextBasic(dpi, screenCoords, STR_CUSTOMERS_PER_HOUR, ft);
     screenCoords.y += LIST_ROW_HEIGHT;
 
diff --git a/src/openrct2-ui/windows/RideConstruction.cpp b/src/openrct2-ui/windows/RideConstruction.cpp
index dc25a63a8d..60731dda26 100644
--- a/src/openrct2-ui/windows/RideConstruction.cpp
+++ b/src/openrct2-ui/windows/RideConstruction.cpp
@@ -170,10 +170,10 @@ static constexpr const StringId RideConstructionSeatAngleRotationStrings[] = {
 
 static void window_ride_construction_mouseup_demolish_next_piece(const CoordsXYZD& piecePos, int32_t type);
 
-static int32_t RideGetAlternativeType(Ride* ride)
+static int32_t RideGetAlternativeType(const Ride& ride)
 {
-    return (_currentTrackAlternative & RIDE_TYPE_ALTERNATIVE_TRACK_TYPE) ? ride->GetRideTypeDescriptor().AlternateType
-                                                                         : ride->type;
+    return (_currentTrackAlternative & RIDE_TYPE_ALTERNATIVE_TRACK_TYPE) ? ride.GetRideTypeDescriptor().AlternateType
+                                                                         : ride.type;
 }
 
 /* move to ride.c */
@@ -186,7 +186,7 @@ static void CloseRideWindowForConstruction(RideId rideId)
 
 static void RideConstructPlacedForwardGameActionCallback(const GameAction* ga, const GameActions::Result* result);
 static void RideConstructPlacedBackwardGameActionCallback(const GameAction* ga, const GameActions::Result* result);
-static void CloseConstructWindowOnCompletion(Ride* ride);
+static void CloseConstructWindowOnCompletion(const Ride& ride);
 
 class RideConstructionWindow final : public Window
 {
@@ -265,7 +265,7 @@ public:
             return;
         }
 
-        if (ride_try_get_origin_element(currentRide, nullptr))
+        if (ride_try_get_origin_element(*currentRide, nullptr))
         {
             // Auto open shops if required.
             if (currentRide->mode == RideMode::ShopStall && gConfigGeneral.AutoOpenShops)
@@ -306,7 +306,7 @@ public:
             return;
         }
 
-        int32_t rideType = RideGetAlternativeType(currentRide);
+        int32_t rideType = RideGetAlternativeType(*currentRide);
 
         uint64_t disabledWidgets = 0;
 
@@ -1531,7 +1531,7 @@ public:
         {
             return;
         }
-        int32_t rideType = RideGetAlternativeType(currentRide);
+        int32_t rideType = RideGetAlternativeType(*currentRide);
 
         hold_down_widgets = 0;
         if (GetRideTypeDescriptor(rideType).HasFlag(RIDE_TYPE_FLAG_IS_SHOP_OR_FACILITY) || !currentRide->HasStation())
@@ -2372,7 +2372,7 @@ private:
             const auto& rtd = currentRide->GetRideTypeDescriptor();
             if (rtd.HasFlag(RIDE_TYPE_FLAG_FLAT_RIDE) && !rtd.HasFlag(RIDE_TYPE_FLAG_IS_SHOP_OR_FACILITY))
             {
-                ride_initialise_construction_window(currentRide);
+                ride_initialise_construction_window(*currentRide);
             }
         }
 
@@ -2412,9 +2412,9 @@ private:
         if (tool_set(*this, WIDX_ENTRANCE, Tool::Crosshair))
         {
             auto currentRide = get_ride(_currentRideIndex);
-            if (currentRide != nullptr && !ride_try_get_origin_element(currentRide, nullptr))
+            if (currentRide != nullptr && !ride_try_get_origin_element(*currentRide, nullptr))
             {
-                ride_initialise_construction_window(currentRide);
+                ride_initialise_construction_window(*currentRide);
             }
         }
         else
@@ -2438,9 +2438,9 @@ private:
         if (tool_set(*this, WIDX_EXIT, Tool::Crosshair))
         {
             auto currentRide = get_ride(_currentRideIndex);
-            if (!ride_try_get_origin_element(currentRide, nullptr))
+            if (!ride_try_get_origin_element(*currentRide, nullptr))
             {
-                ride_initialise_construction_window(currentRide);
+                ride_initialise_construction_window(*currentRide);
             }
         }
         else
@@ -2569,7 +2569,7 @@ private:
             OpenRCT2::Audio::Play3D(OpenRCT2::Audio::SoundId::PlaceItem, result->Position);
 
             auto currentRide = get_ride(gRideEntranceExitPlaceRideIndex);
-            if (currentRide != nullptr && ride_are_all_possible_entrances_and_exits_built(currentRide).Successful)
+            if (currentRide != nullptr && ride_are_all_possible_entrances_and_exits_built(*currentRide).Successful)
             {
                 tool_cancel();
                 if (currentRide->GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_HAS_NO_TRACK))
@@ -2788,7 +2788,7 @@ rct_window* WindowRideConstructionOpen()
     return WindowCreate<RideConstructionWindow>(WindowClass::RideConstruction, ScreenCoordsXY(0, 29), WW, WH, WF_NO_AUTO_CLOSE);
 }
 
-static void CloseConstructWindowOnCompletion(Ride* ride)
+static void CloseConstructWindowOnCompletion(const Ride& ride)
 {
     if (_rideConstructionState == RideConstructionState::State0)
     {
@@ -2821,7 +2821,7 @@ static void window_ride_construction_do_entrance_exit_check()
         w = window_find_by_class(WindowClass::RideConstruction);
         if (w != nullptr)
         {
-            if (!ride_are_all_possible_entrances_and_exits_built(ride).Successful)
+            if (!ride_are_all_possible_entrances_and_exits_built(*ride).Successful)
             {
                 window_event_mouse_up_call(w, WC_RIDE_CONSTRUCTION__WIDX_ENTRANCE);
             }
@@ -2847,7 +2847,7 @@ static void RideConstructPlacedForwardGameActionCallback(const GameAction* ga, c
         }
 
         CoordsXYE next_track;
-        if (track_block_get_next_from_zero(trackPos, ride, trackDirection, &next_track, &trackPos.z, &trackDirection, false))
+        if (track_block_get_next_from_zero(trackPos, *ride, trackDirection, &next_track, &trackPos.z, &trackDirection, false))
         {
             _currentTrackBegin.x = next_track.x;
             _currentTrackBegin.y = next_track.y;
@@ -2870,7 +2870,8 @@ static void RideConstructPlacedForwardGameActionCallback(const GameAction* ga, c
     }
 
     window_close_by_class(WindowClass::Error);
-    CloseConstructWindowOnCompletion(ride);
+    if (ride != nullptr)
+        CloseConstructWindowOnCompletion(*ride);
 }
 
 static void RideConstructPlacedBackwardGameActionCallback(const GameAction* ga, const GameActions::Result* result)
@@ -2891,7 +2892,7 @@ static void RideConstructPlacedBackwardGameActionCallback(const GameAction* ga,
         }
 
         track_begin_end trackBeginEnd;
-        if (track_block_get_previous_from_zero(trackPos, ride, trackDirection, &trackBeginEnd))
+        if (track_block_get_previous_from_zero(trackPos, *ride, trackDirection, &trackBeginEnd))
         {
             _currentTrackBegin.x = trackBeginEnd.begin_x;
             _currentTrackBegin.y = trackBeginEnd.begin_y;
@@ -2913,7 +2914,8 @@ static void RideConstructPlacedBackwardGameActionCallback(const GameAction* ga,
     }
 
     window_close_by_class(WindowClass::Error);
-    CloseConstructWindowOnCompletion(ride);
+    if (ride != nullptr)
+        CloseConstructWindowOnCompletion(*ride);
 }
 
 /**
@@ -3078,7 +3080,7 @@ void WindowRideConstructionUpdateEnabledTrackPieces()
     if (rideEntry == nullptr)
         return;
 
-    int32_t rideType = RideGetAlternativeType(ride);
+    int32_t rideType = RideGetAlternativeType(*ride);
     UpdateEnabledRidePieces(rideType);
 }
 
@@ -3461,7 +3463,7 @@ void ride_construction_toolupdate_entrance_exit(const ScreenCoordsXY& screenCoor
         if (ride != nullptr)
         {
             _currentTrackPrice = RideEntranceExitPlaceGhost(
-                ride, entranceOrExitCoords, entranceOrExitCoords.direction, gRideEntranceExitPlaceType, stationNum);
+                *ride, entranceOrExitCoords, entranceOrExitCoords.direction, gRideEntranceExitPlaceType, stationNum);
         }
         window_ride_construction_update_active_elements();
     }
@@ -3653,7 +3655,7 @@ void ride_construction_tooldown_construct(const ScreenCoordsXY& screenCoords)
                 int32_t saveCurrentTrackAlternative = _currentTrackAlternative;
                 int32_t saveCurrentTrackLiftHill = _currentTrackLiftHill;
 
-                ride_initialise_construction_window(ride);
+                ride_initialise_construction_window(*ride);
 
                 _currentTrackPieceDirection = saveTrackDirection;
                 _currentTrackCurve = saveCurrentTrackCurve;
@@ -4562,9 +4564,9 @@ static void window_ride_construction_mouseup_demolish_next_piece(const CoordsXYZ
         ride_construction_set_default_next_piece();
         window_ride_construction_update_active_elements();
         auto ride = get_ride(_currentRideIndex);
-        if (!ride_try_get_origin_element(ride, nullptr))
+        if (!ride_try_get_origin_element(*ride, nullptr))
         {
-            ride_initialise_construction_window(ride);
+            ride_initialise_construction_window(*ride);
             _currentTrackPieceDirection = piecePos.direction & 3;
             if (!(savedCurrentTrackCurve & RideConstructionSpecialPieceSelected))
             {
diff --git a/src/openrct2-ui/windows/RideList.cpp b/src/openrct2-ui/windows/RideList.cpp
index 9c3d75a729..3d71dc8ee1 100644
--- a/src/openrct2-ui/windows/RideList.cpp
+++ b/src/openrct2-ui/windows/RideList.cpp
@@ -607,7 +607,7 @@ public:
                     break;
                 case INFORMATION_TYPE_CUSTOMERS:
                     formatSecondary = STR_RIDE_LIST_CUSTOMERS_PER_HOUR_LABEL;
-                    ft.Add<uint32_t>(ride_customers_per_hour(ridePtr));
+                    ft.Add<uint32_t>(ride_customers_per_hour(*ridePtr));
                     break;
                 case INFORMATION_TYPE_AGE:
                 {
@@ -696,7 +696,7 @@ public:
                     break;
                 case INFORMATION_TYPE_EXCITEMENT:
                     formatSecondary = STR_RATING_UKNOWN_LABEL;
-                    if (ride_has_ratings(ridePtr))
+                    if (ride_has_ratings(*ridePtr))
                     {
                         formatSecondary = STR_EXCITEMENT_LABEL;
                         ft.Add<uint16_t>(ridePtr->excitement);
@@ -704,7 +704,7 @@ public:
                     break;
                 case INFORMATION_TYPE_INTENSITY:
                     formatSecondary = STR_RATING_UKNOWN_LABEL;
-                    if (ride_has_ratings(ridePtr))
+                    if (ride_has_ratings(*ridePtr))
                     {
                         formatSecondary = STR_INTENSITY_LABEL;
                         ft.Add<uint16_t>(ridePtr->intensity);
@@ -712,7 +712,7 @@ public:
                     break;
                 case INFORMATION_TYPE_NAUSEA:
                     formatSecondary = STR_RATING_UKNOWN_LABEL;
-                    if (ride_has_ratings(ridePtr))
+                    if (ride_has_ratings(*ridePtr))
                     {
                         formatSecondary = STR_NAUSEA_LABEL;
                         ft.Add<uint16_t>(ridePtr->nausea);
@@ -796,7 +796,7 @@ private:
         for (auto& rideRef : GetRideManager())
         {
             if (rideRef.GetClassification() != static_cast<RideClassification>(page)
-                || (rideRef.status == RideStatus::Closed && !ride_has_any_track_elements(&rideRef)))
+                || (rideRef.status == RideStatus::Closed && !ride_has_any_track_elements(rideRef)))
                 continue;
 
             if (rideRef.window_invalidate_flags & RIDE_INVALIDATE_RIDE_LIST)
@@ -847,7 +847,7 @@ private:
                 case INFORMATION_TYPE_CUSTOMERS:
                     currentListPosition = SortList(
                         currentListPosition, rideRef, [](const Ride& thisRide, const Ride& otherRide) -> bool {
-                            return ride_customers_per_hour(&thisRide) <= ride_customers_per_hour(&otherRide);
+                            return ride_customers_per_hour(thisRide) <= ride_customers_per_hour(otherRide);
                         });
                     break;
                 case INFORMATION_TYPE_AGE:
diff --git a/src/openrct2-ui/windows/TrackDesignPlace.cpp b/src/openrct2-ui/windows/TrackDesignPlace.cpp
index ae72292ab5..6189b52e82 100644
--- a/src/openrct2-ui/windows/TrackDesignPlace.cpp
+++ b/src/openrct2-ui/windows/TrackDesignPlace.cpp
@@ -163,7 +163,7 @@ public:
         if (mapCoords == _placementLoc)
         {
             TrackDesignPreviewDrawOutlines(
-                tds, _trackDesign.get(), GetOrAllocateRide(PreviewRideId), { mapCoords, 0, _currentTrackPieceDirection });
+                tds, _trackDesign.get(), *GetOrAllocateRide(PreviewRideId), { mapCoords, 0, _currentTrackPieceDirection });
             return;
         }
 
@@ -203,7 +203,7 @@ public:
             widget_invalidate(*this, WIDX_PRICE);
         }
 
-        TrackDesignPreviewDrawOutlines(tds, _trackDesign.get(), GetOrAllocateRide(PreviewRideId), trackLoc);
+        TrackDesignPreviewDrawOutlines(tds, _trackDesign.get(), *GetOrAllocateRide(PreviewRideId), trackLoc);
     }
 
     void OnToolDown(WidgetIndex widgetIndex, const ScreenCoordsXY& screenCoords) override
@@ -247,7 +247,7 @@ public:
                         }
                         else
                         {
-                            ride_initialise_construction_window(getRide);
+                            ride_initialise_construction_window(*getRide);
                             auto wnd = window_find_by_class(WindowClass::RideConstruction);
                             window_event_mouse_up_call(wnd, WC_RIDE_CONSTRUCTION__WIDX_ENTRANCE);
                         }
@@ -319,7 +319,7 @@ public:
             auto provRide = get_ride(_placementGhostRideId);
             if (provRide != nullptr)
             {
-                TrackDesignPreviewRemoveGhosts(_trackDesign.get(), provRide, _placementGhostLoc);
+                TrackDesignPreviewRemoveGhosts(_trackDesign.get(), *provRide, _placementGhostLoc);
             }
         }
     }
@@ -395,7 +395,7 @@ private:
             auto newRide = get_ride(_placementGhostRideId);
             if (newRide != nullptr)
             {
-                TrackDesignPreviewRemoveGhosts(_trackDesign.get(), newRide, _placementGhostLoc);
+                TrackDesignPreviewRemoveGhosts(_trackDesign.get(), *newRide, _placementGhostLoc);
                 _hasPlacementGhost = false;
             }
         }
@@ -425,7 +425,7 @@ private:
 
         return z
             + TrackDesignGetZPlacement(
-                   _trackDesign.get(), GetOrAllocateRide(PreviewRideId), { loc, z, _currentTrackPieceDirection });
+                   _trackDesign.get(), *GetOrAllocateRide(PreviewRideId), { loc, z, _currentTrackPieceDirection });
     }
 
     void DrawMiniPreviewTrack(TrackDesign* td6, int32_t pass, const CoordsXY& origin, CoordsXY min, CoordsXY max)
diff --git a/src/openrct2-ui/windows/Window.h b/src/openrct2-ui/windows/Window.h
index 5e88935c20..366181fb4b 100644
--- a/src/openrct2-ui/windows/Window.h
+++ b/src/openrct2-ui/windows/Window.h
@@ -89,8 +89,8 @@ rct_window* WindowParkObjectiveOpen();
 rct_window* WindowParkRatingOpen();
 
 rct_window* WindowBannerOpen(rct_windownumber number);
-rct_window* WindowRideDemolishPromptOpen(Ride* ride);
-rct_window* WindowRideRefurbishPromptOpen(Ride* ride);
+rct_window* WindowRideDemolishPromptOpen(const Ride& ride);
+rct_window* WindowRideRefurbishPromptOpen(const Ride& ride);
 rct_window* WindowSignOpen(rct_windownumber number);
 rct_window* WindowSignSmallOpen(rct_windownumber number);
 rct_window* WindowPlayerOpen(uint8_t id);
@@ -131,7 +131,7 @@ void WindowNewRideFocus(RideSelection rideItem);
 rct_window* WindowRideListOpen();
 void WindowRideListRefreshList(rct_window* w);
 
-rct_window* WindowRideMainOpen(Ride* ride);
+rct_window* WindowRideMainOpen(const Ride& ride);
 rct_window* WindowRideOpenTrack(TileElement* tileElement);
 rct_window* WindowRideOpenVehicle(Vehicle* vehicle);
 void WindowRideMeasurementsDesignCancel();
diff --git a/src/openrct2/Game.cpp b/src/openrct2/Game.cpp
index ca4234ca8e..6b2bb1653a 100644
--- a/src/openrct2/Game.cpp
+++ b/src/openrct2/Game.cpp
@@ -382,7 +382,7 @@ void game_fix_save_vars()
             log_warning(
                 "Peep %u (%s) has invalid ride station = %u for ride %u.", peep->sprite_index, curName.c_str(),
                 srcStation.ToUnderlying(), rideIdx);
-            auto station = ride_get_first_valid_station_exit(ride);
+            auto station = ride_get_first_valid_station_exit(*ride);
             if (station.IsNull())
             {
                 log_warning("Couldn't find station, removing peep %u", peep->sprite_index);
diff --git a/src/openrct2/actions/CheatSetAction.cpp b/src/openrct2/actions/CheatSetAction.cpp
index 59c1c46115..895790b596 100644
--- a/src/openrct2/actions/CheatSetAction.cpp
+++ b/src/openrct2/actions/CheatSetAction.cpp
@@ -450,13 +450,13 @@ void CheatSetAction::FixBrokenRides() const
         if ((ride.mechanic_status != RIDE_MECHANIC_STATUS_FIXING)
             && (ride.lifecycle_flags & (RIDE_LIFECYCLE_BREAKDOWN_PENDING | RIDE_LIFECYCLE_BROKEN_DOWN)))
         {
-            auto mechanic = ride_get_assigned_mechanic(&ride);
+            auto mechanic = ride_get_assigned_mechanic(ride);
             if (mechanic != nullptr)
             {
                 mechanic->RemoveFromRide();
             }
 
-            ride_fix_breakdown(&ride, 0);
+            ride_fix_breakdown(ride, 0);
             ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAIN | RIDE_INVALIDATE_RIDE_LIST;
         }
     }
diff --git a/src/openrct2/actions/RideCreateAction.cpp b/src/openrct2/actions/RideCreateAction.cpp
index 0d0bb30467..e8dbc2f00f 100644
--- a/src/openrct2/actions/RideCreateAction.cpp
+++ b/src/openrct2/actions/RideCreateAction.cpp
@@ -239,7 +239,7 @@ GameActions::Result RideCreateAction::Execute() const
         {
             if (shop_item_has_common_price(ShopItem::Admission))
             {
-                money32 price = ride_get_common_price(ride);
+                money32 price = ride_get_common_price(*ride);
                 if (price != MONEY32_UNDEFINED)
                 {
                     ride->price[0] = static_cast<money16>(price);
@@ -318,7 +318,7 @@ GameActions::Result RideCreateAction::Execute() const
     ride->mode = ride->GetDefaultMode();
     ride->MinCarsPerTrain = rideEntry->min_cars_in_train;
     ride->MaxCarsPerTrain = rideEntry->max_cars_in_train;
-    ride_set_vehicle_colours_to_random_preset(ride, _colour2);
+    ride_set_vehicle_colours_to_random_preset(*ride, _colour2);
     window_invalidate_by_class(WindowClass::RideList);
 
     res.Expenditure = ExpenditureType::RideConstruction;
diff --git a/src/openrct2/actions/RideDemolishAction.cpp b/src/openrct2/actions/RideDemolishAction.cpp
index 3cf40ba7c4..494d1d8f15 100644
--- a/src/openrct2/actions/RideDemolishAction.cpp
+++ b/src/openrct2/actions/RideDemolishAction.cpp
@@ -93,7 +93,7 @@ GameActions::Result RideDemolishAction::Query() const
         }
 
         result.ErrorTitle = STR_CANT_REFURBISH_RIDE;
-        result.Cost = GetRefurbishPrice(ride);
+        result.Cost = GetRefurbishPrice(*ride);
     }
 
     return result;
@@ -111,34 +111,34 @@ GameActions::Result RideDemolishAction::Execute() const
     switch (_modifyType)
     {
         case RIDE_MODIFY_DEMOLISH:
-            return DemolishRide(ride);
+            return DemolishRide(*ride);
         case RIDE_MODIFY_RENEW:
-            return RefurbishRide(ride);
+            return RefurbishRide(*ride);
     }
 
     return GameActions::Result(GameActions::Status::InvalidParameters, STR_CANT_DO_THIS, STR_NONE);
 }
 
-GameActions::Result RideDemolishAction::DemolishRide(Ride* ride) const
+GameActions::Result RideDemolishAction::DemolishRide(Ride& ride) const
 {
     money32 refundPrice = DemolishTracks();
 
     ride_clear_for_construction(ride);
-    ride->RemovePeeps();
-    ride->StopGuestsQueuing();
+    ride.RemovePeeps();
+    ride.StopGuestsQueuing();
 
-    ride->ValidateStations();
+    ride.ValidateStations();
     ride_clear_leftover_entrances(ride);
 
-    const auto rideId = ride->id;
+    const auto rideId = ride.id;
     News::DisableNewsItems(News::ItemType::Ride, rideId.ToUnderlying());
 
-    UnlinkAllBannersForRide(ride->id);
+    UnlinkAllBannersForRide(ride.id);
 
-    RideUse::GetHistory().RemoveValue(ride->id);
+    RideUse::GetHistory().RemoveValue(ride.id);
     for (auto peep : EntityList<Guest>())
     {
-        peep->RemoveRideFromMemory(ride->id);
+        peep->RemoveRideFromMemory(ride.id);
     }
 
     MarketingCancelCampaignsForRide(_rideIndex);
@@ -147,13 +147,13 @@ GameActions::Result RideDemolishAction::DemolishRide(Ride* ride) const
     res.Expenditure = ExpenditureType::RideConstruction;
     res.Cost = refundPrice;
 
-    if (!ride->overall_view.IsNull())
+    if (!ride.overall_view.IsNull())
     {
-        auto xy = ride->overall_view.ToTileCentre();
+        auto xy = ride.overall_view.ToTileCentre();
         res.Position = { xy, TileElementHeight(xy) };
     }
 
-    ride->Delete();
+    ride.Delete();
     gParkValue = GetContext()->GetGameState()->GetPark().CalculateParkValue();
 
     // Close windows related to the demolished ride
@@ -265,22 +265,22 @@ money32 RideDemolishAction::DemolishTracks() const
     return refundPrice;
 }
 
-GameActions::Result RideDemolishAction::RefurbishRide(Ride* ride) const
+GameActions::Result RideDemolishAction::RefurbishRide(Ride& ride) const
 {
     auto res = GameActions::Result();
     res.Expenditure = ExpenditureType::RideConstruction;
     res.Cost = GetRefurbishPrice(ride);
 
-    ride->Renew();
+    ride.Renew();
 
-    ride->lifecycle_flags &= ~RIDE_LIFECYCLE_EVER_BEEN_OPENED;
-    ride->last_crash_type = RIDE_CRASH_TYPE_NONE;
+    ride.lifecycle_flags &= ~RIDE_LIFECYCLE_EVER_BEEN_OPENED;
+    ride.last_crash_type = RIDE_CRASH_TYPE_NONE;
 
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAINTENANCE | RIDE_INVALIDATE_RIDE_CUSTOMER;
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAINTENANCE | RIDE_INVALIDATE_RIDE_CUSTOMER;
 
-    if (!ride->overall_view.IsNull())
+    if (!ride.overall_view.IsNull())
     {
-        auto location = ride->overall_view.ToTileCentre();
+        auto location = ride.overall_view.ToTileCentre();
         res.Position = { location, TileElementHeight(location) };
     }
 
@@ -289,12 +289,12 @@ GameActions::Result RideDemolishAction::RefurbishRide(Ride* ride) const
     return res;
 }
 
-money32 RideDemolishAction::GetRefurbishPrice(const Ride* ride) const
+money32 RideDemolishAction::GetRefurbishPrice(const Ride& ride) const
 {
     return -GetRefundPrice(ride) / 2;
 }
 
-money32 RideDemolishAction::GetRefundPrice(const Ride* ride) const
+money32 RideDemolishAction::GetRefundPrice(const Ride& ride) const
 {
     return ride_get_refund_price(ride);
 }
diff --git a/src/openrct2/actions/RideDemolishAction.h b/src/openrct2/actions/RideDemolishAction.h
index 57ab8a7699..4e31c75011 100644
--- a/src/openrct2/actions/RideDemolishAction.h
+++ b/src/openrct2/actions/RideDemolishAction.h
@@ -30,10 +30,10 @@ public:
     GameActions::Result Execute() const override;
 
 private:
-    GameActions::Result DemolishRide(Ride* ride) const;
+    GameActions::Result DemolishRide(Ride& ride) const;
     money32 MazeRemoveTrack(const CoordsXYZD& coords) const;
     money32 DemolishTracks() const;
-    GameActions::Result RefurbishRide(Ride* ride) const;
-    money32 GetRefurbishPrice(const Ride* ride) const;
-    money32 GetRefundPrice(const Ride* ride) const;
+    GameActions::Result RefurbishRide(Ride& ride) const;
+    money32 GetRefurbishPrice(const Ride& ride) const;
+    money32 GetRefundPrice(const Ride& ride) const;
 };
diff --git a/src/openrct2/actions/RideEntranceExitPlaceAction.cpp b/src/openrct2/actions/RideEntranceExitPlaceAction.cpp
index 84c7068853..da1bbe8f74 100644
--- a/src/openrct2/actions/RideEntranceExitPlaceAction.cpp
+++ b/src/openrct2/actions/RideEntranceExitPlaceAction.cpp
@@ -142,7 +142,7 @@ GameActions::Result RideEntranceExitPlaceAction::Execute() const
 
     if (!(GetFlags() & GAME_COMMAND_FLAG_GHOST))
     {
-        ride_clear_for_construction(ride);
+        ride_clear_for_construction(*ride);
         ride->RemovePeeps();
     }
 
diff --git a/src/openrct2/actions/RideEntranceExitRemoveAction.cpp b/src/openrct2/actions/RideEntranceExitRemoveAction.cpp
index 9a14081d5a..66f9e71da1 100644
--- a/src/openrct2/actions/RideEntranceExitRemoveAction.cpp
+++ b/src/openrct2/actions/RideEntranceExitRemoveAction.cpp
@@ -119,9 +119,9 @@ GameActions::Result RideEntranceExitRemoveAction::Execute() const
     const bool isGhost = GetFlags() & GAME_COMMAND_FLAG_GHOST;
     if (!isGhost)
     {
-        ride_clear_for_construction(ride);
+        ride_clear_for_construction(*ride);
         ride->RemovePeeps();
-        invalidate_test_results(ride);
+        invalidate_test_results(*ride);
     }
 
     auto* entranceElement = FindEntranceElement(
diff --git a/src/openrct2/actions/RideSetAppearanceAction.cpp b/src/openrct2/actions/RideSetAppearanceAction.cpp
index f1288d3383..93de254a1a 100644
--- a/src/openrct2/actions/RideSetAppearanceAction.cpp
+++ b/src/openrct2/actions/RideSetAppearanceAction.cpp
@@ -114,15 +114,15 @@ GameActions::Result RideSetAppearanceAction::Execute() const
             break;
         case RideSetAppearanceType::VehicleColourBody:
             ride->vehicle_colours[_index].Body = _value;
-            ride_update_vehicle_colours(ride);
+            ride_update_vehicle_colours(*ride);
             break;
         case RideSetAppearanceType::VehicleColourTrim:
             ride->vehicle_colours[_index].Trim = _value;
-            ride_update_vehicle_colours(ride);
+            ride_update_vehicle_colours(*ride);
             break;
         case RideSetAppearanceType::VehicleColourTernary:
             ride->vehicle_colours[_index].Tertiary = _value;
-            ride_update_vehicle_colours(ride);
+            ride_update_vehicle_colours(*ride);
             break;
         case RideSetAppearanceType::VehicleColourScheme:
             ride->colour_scheme_type &= ~(
@@ -132,7 +132,7 @@ GameActions::Result RideSetAppearanceAction::Execute() const
             {
                 ride->vehicle_colours[i] = ride->vehicle_colours[0];
             }
-            ride_update_vehicle_colours(ride);
+            ride_update_vehicle_colours(*ride);
             break;
         case RideSetAppearanceType::EntranceStyle:
             ride->entrance_style = _value;
diff --git a/src/openrct2/actions/RideSetSettingAction.cpp b/src/openrct2/actions/RideSetSettingAction.cpp
index dad215af98..458eafc966 100644
--- a/src/openrct2/actions/RideSetSettingAction.cpp
+++ b/src/openrct2/actions/RideSetSettingAction.cpp
@@ -64,7 +64,7 @@ GameActions::Result RideSetSettingAction::Query() const
                     GameActions::Status::Disallowed, STR_CANT_CHANGE_OPERATING_MODE, STR_MUST_BE_CLOSED_FIRST);
             }
 
-            if (!ride_is_mode_valid(ride) && !gCheatsShowAllOperatingModes)
+            if (!ride_is_mode_valid(*ride) && !gCheatsShowAllOperatingModes)
             {
                 log_warning("Invalid ride mode: %u", _value);
                 return GameActions::Result(GameActions::Status::InvalidParameters, STR_CANT_CHANGE_OPERATING_MODE, STR_NONE);
@@ -87,11 +87,11 @@ GameActions::Result RideSetSettingAction::Query() const
             }
             break;
         case RideSetSetting::Operation:
-            if (!ride_is_valid_operation_option(ride))
+            if (!ride_is_valid_operation_option(*ride))
             {
                 log_warning("Invalid operation option value: %u", _value);
                 return GameActions::Result(
-                    GameActions::Status::InvalidParameters, STR_CANT_CHANGE_OPERATING_MODE, GetOperationErrorMessage(ride));
+                    GameActions::Status::InvalidParameters, STR_CANT_CHANGE_OPERATING_MODE, GetOperationErrorMessage(*ride));
             }
             break;
         case RideSetSetting::InspectionInterval:
@@ -115,7 +115,7 @@ GameActions::Result RideSetSettingAction::Query() const
             break;
         }
         case RideSetSetting::LiftHillSpeed:
-            if (!ride_is_valid_lift_hill_speed(ride))
+            if (!ride_is_valid_lift_hill_speed(*ride))
             {
                 log_warning("Invalid lift hill speed: %u", _value);
                 return GameActions::Result(GameActions::Status::InvalidParameters, STR_CANT_CHANGE_OPERATING_MODE, STR_NONE);
@@ -162,8 +162,8 @@ GameActions::Result RideSetSettingAction::Execute() const
     switch (_setting)
     {
         case RideSetSetting::Mode:
-            invalidate_test_results(ride);
-            ride_clear_for_construction(ride);
+            invalidate_test_results(*ride);
+            ride_clear_for_construction(*ride);
             ride->RemovePeeps();
 
             ride->mode = static_cast<RideMode>(_value);
@@ -182,7 +182,7 @@ GameActions::Result RideSetSettingAction::Execute() const
             ride->min_waiting_time = std::min(_value, ride->min_waiting_time);
             break;
         case RideSetSetting::Operation:
-            invalidate_test_results(ride);
+            invalidate_test_results(*ride);
             ride->operation_option = _value;
             break;
         case RideSetSetting::InspectionInterval:
@@ -212,14 +212,14 @@ GameActions::Result RideSetSettingAction::Execute() const
             if (_value != ride->lift_hill_speed)
             {
                 ride->lift_hill_speed = _value;
-                invalidate_test_results(ride);
+                invalidate_test_results(*ride);
             }
             break;
         case RideSetSetting::NumCircuits:
             if (_value != ride->num_circuits)
             {
                 ride->num_circuits = _value;
-                invalidate_test_results(ride);
+                invalidate_test_results(*ride);
             }
 
             break;
@@ -240,15 +240,15 @@ GameActions::Result RideSetSettingAction::Execute() const
     return res;
 }
 
-bool RideSetSettingAction::ride_is_mode_valid(Ride* ride) const
+bool RideSetSettingAction::ride_is_mode_valid(const Ride& ride) const
 {
-    return ride->GetRideTypeDescriptor().RideModes & (1uLL << _value);
+    return ride.GetRideTypeDescriptor().RideModes & (1uLL << _value);
 }
 
-bool RideSetSettingAction::ride_is_valid_lift_hill_speed(Ride* ride) const
+bool RideSetSettingAction::ride_is_valid_lift_hill_speed(const Ride& ride) const
 {
-    int32_t minSpeed = gCheatsUnlockOperatingLimits ? 0 : ride->GetRideTypeDescriptor().LiftData.minimum_speed;
-    int32_t maxSpeed = gCheatsUnlockOperatingLimits ? 255 : ride->GetRideTypeDescriptor().LiftData.maximum_speed;
+    int32_t minSpeed = gCheatsUnlockOperatingLimits ? 0 : ride.GetRideTypeDescriptor().LiftData.minimum_speed;
+    int32_t maxSpeed = gCheatsUnlockOperatingLimits ? 255 : ride.GetRideTypeDescriptor().LiftData.maximum_speed;
     return _value >= minSpeed && _value <= maxSpeed;
 }
 
@@ -259,9 +259,9 @@ bool RideSetSettingAction::ride_is_valid_num_circuits() const
     return _value >= minNumCircuits && _value <= maxNumCircuits;
 }
 
-bool RideSetSettingAction::ride_is_valid_operation_option(Ride* ride) const
+bool RideSetSettingAction::ride_is_valid_operation_option(const Ride& ride) const
 {
-    const auto& operatingSettings = ride->GetRideTypeDescriptor().OperatingSettings;
+    const auto& operatingSettings = ride.GetRideTypeDescriptor().OperatingSettings;
     uint8_t minValue = operatingSettings.MinValue;
     uint8_t maxValue = operatingSettings.MaxValue;
     if (gCheatsUnlockOperatingLimits)
@@ -273,9 +273,9 @@ bool RideSetSettingAction::ride_is_valid_operation_option(Ride* ride) const
     return _value >= minValue && _value <= maxValue;
 }
 
-StringId RideSetSettingAction::GetOperationErrorMessage(Ride* ride) const
+StringId RideSetSettingAction::GetOperationErrorMessage(const Ride& ride) const
 {
-    switch (ride->mode)
+    switch (ride.mode)
     {
         case RideMode::StationToStation:
             return STR_CANT_CHANGE_SPEED;
@@ -290,7 +290,7 @@ StringId RideSetSettingAction::GetOperationErrorMessage(Ride* ride) const
         case RideMode::BackwardRotation:
             return STR_CANT_CHANGE_NUMBER_OF_ROTATIONS;
         default:
-            if (ride->GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_NO_VEHICLES))
+            if (ride.GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_NO_VEHICLES))
             {
                 return STR_CANT_CHANGE_THIS;
             }
diff --git a/src/openrct2/actions/RideSetSettingAction.h b/src/openrct2/actions/RideSetSettingAction.h
index 6f72bb9aca..3212894315 100644
--- a/src/openrct2/actions/RideSetSettingAction.h
+++ b/src/openrct2/actions/RideSetSettingAction.h
@@ -46,9 +46,9 @@ public:
     GameActions::Result Execute() const override;
 
 private:
-    bool ride_is_mode_valid(Ride* ride) const;
-    bool ride_is_valid_lift_hill_speed(Ride* ride) const;
+    bool ride_is_mode_valid(const Ride& ride) const;
+    bool ride_is_valid_lift_hill_speed(const Ride& ride) const;
     bool ride_is_valid_num_circuits() const;
-    bool ride_is_valid_operation_option(Ride* ride) const;
-    StringId GetOperationErrorMessage(Ride* ride) const;
+    bool ride_is_valid_operation_option(const Ride& ride) const;
+    StringId GetOperationErrorMessage(const Ride& ride) const;
 };
diff --git a/src/openrct2/actions/RideSetStatusAction.cpp b/src/openrct2/actions/RideSetStatusAction.cpp
index e4bffa30c0..d98cb4b28c 100644
--- a/src/openrct2/actions/RideSetStatusAction.cpp
+++ b/src/openrct2/actions/RideSetStatusAction.cpp
@@ -150,7 +150,7 @@ GameActions::Result RideSetStatusAction::Execute() const
                 if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_BROKEN_DOWN))
                 {
                     ride->lifecycle_flags &= ~RIDE_LIFECYCLE_CRASHED;
-                    ride_clear_for_construction(ride);
+                    ride_clear_for_construction(*ride);
                     ride->RemovePeeps();
                 }
             }
@@ -164,7 +164,7 @@ GameActions::Result RideSetStatusAction::Execute() const
         case RideStatus::Simulating:
         {
             ride->lifecycle_flags &= ~RIDE_LIFECYCLE_CRASHED;
-            ride_clear_for_construction(ride);
+            ride_clear_for_construction(*ride);
             ride->RemovePeeps();
 
             const auto modeSwitchResult = ride->Simulate(true);
@@ -195,7 +195,7 @@ GameActions::Result RideSetStatusAction::Execute() const
 
             if (ride->status == RideStatus::Simulating)
             {
-                ride_clear_for_construction(ride);
+                ride_clear_for_construction(*ride);
                 ride->RemovePeeps();
             }
 
diff --git a/src/openrct2/actions/RideSetVehicleAction.cpp b/src/openrct2/actions/RideSetVehicleAction.cpp
index 18c2606a94..c7c00e07df 100644
--- a/src/openrct2/actions/RideSetVehicleAction.cpp
+++ b/src/openrct2/actions/RideSetVehicleAction.cpp
@@ -90,7 +90,7 @@ GameActions::Result RideSetVehicleAction::Query() const
             break;
         case RideSetVehicleType::RideEntry:
         {
-            if (!ride_is_vehicle_type_valid(ride))
+            if (!ride_is_vehicle_type_valid(*ride))
             {
                 log_error("Invalid vehicle type. type = %d", _value);
                 return GameActions::Result(GameActions::Status::InvalidParameters, errTitle, STR_NONE);
@@ -133,7 +133,7 @@ GameActions::Result RideSetVehicleAction::Execute() const
     switch (_type)
     {
         case RideSetVehicleType::NumTrains:
-            ride_clear_for_construction(ride);
+            ride_clear_for_construction(*ride);
             ride->RemovePeeps();
             ride->vehicle_change_timeout = 100;
 
@@ -141,11 +141,11 @@ GameActions::Result RideSetVehicleAction::Execute() const
             break;
         case RideSetVehicleType::NumCarsPerTrain:
         {
-            ride_clear_for_construction(ride);
+            ride_clear_for_construction(*ride);
             ride->RemovePeeps();
             ride->vehicle_change_timeout = 100;
 
-            invalidate_test_results(ride);
+            invalidate_test_results(*ride);
             auto rideEntry = get_ride_entry(ride->subtype);
             if (rideEntry == nullptr)
             {
@@ -163,11 +163,11 @@ GameActions::Result RideSetVehicleAction::Execute() const
         }
         case RideSetVehicleType::RideEntry:
         {
-            ride_clear_for_construction(ride);
+            ride_clear_for_construction(*ride);
             ride->RemovePeeps();
             ride->vehicle_change_timeout = 100;
 
-            invalidate_test_results(ride);
+            invalidate_test_results(*ride);
             ride->subtype = _value;
             auto rideEntry = get_ride_entry(ride->subtype);
             if (rideEntry == nullptr)
@@ -176,7 +176,7 @@ GameActions::Result RideSetVehicleAction::Execute() const
                 return GameActions::Result(GameActions::Status::InvalidParameters, errTitle, STR_NONE);
             }
 
-            ride_set_vehicle_colours_to_random_preset(ride, _colour);
+            ride_set_vehicle_colours_to_random_preset(*ride, _colour);
             if (!gCheatsDisableTrainLengthLimit)
             {
                 ride->proposed_num_cars_per_train = std::clamp(
@@ -208,17 +208,17 @@ GameActions::Result RideSetVehicleAction::Execute() const
     return res;
 }
 
-bool RideSetVehicleAction::ride_is_vehicle_type_valid(Ride* ride) const
+bool RideSetVehicleAction::ride_is_vehicle_type_valid(const Ride& ride) const
 {
     bool selectionShouldBeExpanded;
     int32_t rideTypeIterator, rideTypeIteratorMax;
 
     {
-        const auto& rtd = ride->GetRideTypeDescriptor();
+        const auto& rtd = ride.GetRideTypeDescriptor();
         if (gCheatsShowVehiclesFromOtherTrackTypes
             && !(
-                ride->GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_FLAT_RIDE) || rtd.HasFlag(RIDE_TYPE_FLAG_IS_MAZE)
-                || ride->type == RIDE_TYPE_MINI_GOLF))
+                ride.GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_FLAT_RIDE) || rtd.HasFlag(RIDE_TYPE_FLAG_IS_MAZE)
+                || ride.type == RIDE_TYPE_MINI_GOLF))
         {
             selectionShouldBeExpanded = true;
             rideTypeIterator = 0;
@@ -227,8 +227,8 @@ bool RideSetVehicleAction::ride_is_vehicle_type_valid(Ride* ride) const
         else
         {
             selectionShouldBeExpanded = false;
-            rideTypeIterator = ride->type;
-            rideTypeIteratorMax = ride->type;
+            rideTypeIterator = ride.type;
+            rideTypeIteratorMax = ride.type;
         }
     }
 
diff --git a/src/openrct2/actions/RideSetVehicleAction.h b/src/openrct2/actions/RideSetVehicleAction.h
index c53d15d106..519caf50b6 100644
--- a/src/openrct2/actions/RideSetVehicleAction.h
+++ b/src/openrct2/actions/RideSetVehicleAction.h
@@ -40,7 +40,7 @@ public:
     GameActions::Result Execute() const override;
 
 private:
-    bool ride_is_vehicle_type_valid(Ride* ride) const;
+    bool ride_is_vehicle_type_valid(const Ride& ride) const;
 
     static_assert(sizeof(_value) >= sizeof(ObjectEntryIndex));
 };
diff --git a/src/openrct2/actions/TrackDesignAction.cpp b/src/openrct2/actions/TrackDesignAction.cpp
index 73631eb0cb..4ebfb332c2 100644
--- a/src/openrct2/actions/TrackDesignAction.cpp
+++ b/src/openrct2/actions/TrackDesignAction.cpp
@@ -99,11 +99,11 @@ GameActions::Result TrackDesignAction::Query() const
     if (GetFlags() & GAME_COMMAND_FLAG_REPLAY)
         flags |= GAME_COMMAND_FLAG_REPLAY;
 
-    auto queryRes = TrackDesignPlace(const_cast<TrackDesign*>(&_td), flags, placeScenery, ride, _loc);
+    auto queryRes = TrackDesignPlace(const_cast<TrackDesign*>(&_td), flags, placeScenery, *ride, _loc);
     if (_trackDesignPlaceStateSceneryUnavailable)
     {
         placeScenery = false;
-        queryRes = TrackDesignPlace(const_cast<TrackDesign*>(&_td), flags, placeScenery, ride, _loc);
+        queryRes = TrackDesignPlace(const_cast<TrackDesign*>(&_td), flags, placeScenery, *ride, _loc);
     }
 
     auto gameAction = RideDemolishAction(ride->id, RIDE_MODIFY_DEMOLISH);
@@ -172,11 +172,11 @@ GameActions::Result TrackDesignAction::Execute() const
     if (GetFlags() & GAME_COMMAND_FLAG_REPLAY)
         flags |= GAME_COMMAND_FLAG_REPLAY;
 
-    auto queryRes = TrackDesignPlace(const_cast<TrackDesign*>(&_td), flags, placeScenery, ride, _loc);
+    auto queryRes = TrackDesignPlace(const_cast<TrackDesign*>(&_td), flags, placeScenery, *ride, _loc);
     if (_trackDesignPlaceStateSceneryUnavailable)
     {
         placeScenery = false;
-        queryRes = TrackDesignPlace(const_cast<TrackDesign*>(&_td), flags, placeScenery, ride, _loc);
+        queryRes = TrackDesignPlace(const_cast<TrackDesign*>(&_td), flags, placeScenery, *ride, _loc);
     }
 
     if (queryRes.Error != GameActions::Status::Ok)
@@ -196,7 +196,7 @@ GameActions::Result TrackDesignAction::Execute() const
     // Execute.
     flags |= GAME_COMMAND_FLAG_APPLY;
 
-    auto execRes = TrackDesignPlace(const_cast<TrackDesign*>(&_td), flags, placeScenery, ride, _loc);
+    auto execRes = TrackDesignPlace(const_cast<TrackDesign*>(&_td), flags, placeScenery, *ride, _loc);
     if (execRes.Error != GameActions::Status::Ok)
     {
         auto gameAction = RideDemolishAction(ride->id, RIDE_MODIFY_DEMOLISH);
diff --git a/src/openrct2/actions/TrackPlaceAction.cpp b/src/openrct2/actions/TrackPlaceAction.cpp
index c547b1426f..2d32d1d2d2 100644
--- a/src/openrct2/actions/TrackPlaceAction.cpp
+++ b/src/openrct2/actions/TrackPlaceAction.cpp
@@ -527,7 +527,7 @@ GameActions::Result TrackPlaceAction::Execute() const
 
         if (!(GetFlags() & GAME_COMMAND_FLAG_GHOST))
         {
-            invalidate_test_results(ride);
+            invalidate_test_results(*ride);
             switch (_trackType)
             {
                 case TrackElemType::OnRidePhoto:
diff --git a/src/openrct2/actions/TrackRemoveAction.cpp b/src/openrct2/actions/TrackRemoveAction.cpp
index 8581ade73f..1c363962c7 100644
--- a/src/openrct2/actions/TrackRemoveAction.cpp
+++ b/src/openrct2/actions/TrackRemoveAction.cpp
@@ -438,7 +438,7 @@ GameActions::Result TrackRemoveAction::Execute() const
             surfaceElement->SetHasTrackThatNeedsWater(false);
         }
 
-        invalidate_test_results(ride);
+        invalidate_test_results(*ride);
         FootpathQueueChainReset();
         if (!gCheatsDisableClearanceChecks || !(tileElement->IsGhost()))
         {
diff --git a/src/openrct2/entity/Guest.cpp b/src/openrct2/entity/Guest.cpp
index 193c3033b0..676dee5bc6 100644
--- a/src/openrct2/entity/Guest.cpp
+++ b/src/openrct2/entity/Guest.cpp
@@ -422,18 +422,18 @@ static constexpr const ride_rating NauseaMinimumThresholds[] = {
     400,
 };
 
-static bool peep_has_voucher_for_free_ride(Guest* peep, Ride* ride);
-static void peep_ride_is_too_intense(Guest* peep, Ride* ride, bool peepAtRide);
+static bool peep_has_voucher_for_free_ride(Guest* peep, const Ride& ride);
+static void peep_ride_is_too_intense(Guest* peep, Ride& ride, bool peepAtRide);
 static void peep_reset_ride_heading(Guest* peep);
-static void peep_tried_to_enter_full_queue(Guest* peep, Ride* ride);
-static int16_t peep_calculate_ride_satisfaction(Guest* peep, Ride* ride);
-static void peep_update_favourite_ride(Guest* peep, Ride* ride);
-static int16_t peep_calculate_ride_value_satisfaction(Guest* peep, Ride* ride);
-static int16_t peep_calculate_ride_intensity_nausea_satisfaction(Guest* peep, Ride* ride);
-static void peep_update_ride_nausea_growth(Guest* peep, Ride* ride);
-static bool peep_should_go_on_ride_again(Guest* peep, Ride* ride);
+static void peep_tried_to_enter_full_queue(Guest* peep, Ride& ride);
+static int16_t peep_calculate_ride_satisfaction(Guest* peep, const Ride& ride);
+static void peep_update_favourite_ride(Guest* peep, const Ride& ride);
+static int16_t peep_calculate_ride_value_satisfaction(Guest* peep, const Ride& ride);
+static int16_t peep_calculate_ride_intensity_nausea_satisfaction(Guest* peep, const Ride& ride);
+static void peep_update_ride_nausea_growth(Guest* peep, const Ride& ride);
+static bool peep_should_go_on_ride_again(Guest* peep, const Ride& ride);
 static bool peep_should_preferred_intensity_increase(Guest* peep);
-static bool peep_really_liked_ride(Guest* peep, Ride* ride);
+static bool peep_really_liked_ride(Guest* peep, const Ride& ride);
 static PeepThoughtType peep_assess_surroundings(int16_t centre_x, int16_t centre_y, int16_t centre_z);
 static void peep_update_hunger(Guest* peep);
 static void peep_decide_whether_to_leave_park(Guest* peep);
@@ -1463,7 +1463,7 @@ void Guest::CheckCantFindExit()
  *
  *  rct2: 0x0069AF1E
  */
-bool Guest::DecideAndBuyItem(Ride* ride, ShopItem shopItem, money32 price)
+bool Guest::DecideAndBuyItem(Ride& ride, ShopItem shopItem, money32 price)
 {
     money32 itemValue;
 
@@ -1564,7 +1564,7 @@ bool Guest::DecideAndBuyItem(Ride* ride, ShopItem shopItem, money32 price)
                 if (itemValue > (static_cast<money16>(scenario_rand() & 0x07)))
                 {
                     // "I'm not paying that much for x"
-                    InsertNewThought(GetShopItemDescriptor(shopItem).TooMuchThought, ride->id);
+                    InsertNewThought(GetShopItemDescriptor(shopItem).TooMuchThought, ride.id);
                     return false;
                 }
             }
@@ -1579,7 +1579,7 @@ bool Guest::DecideAndBuyItem(Ride* ride, ShopItem shopItem, money32 price)
                 if (itemValue >= static_cast<money32>(scenario_rand() & 0x07))
                 {
                     // "This x is a really good value"
-                    InsertNewThought(GetShopItemDescriptor(shopItem).GoodValueThought, ride->id);
+                    InsertNewThought(GetShopItemDescriptor(shopItem).GoodValueThought, ride.id);
                 }
             }
 
@@ -1607,25 +1607,25 @@ bool Guest::DecideAndBuyItem(Ride* ride, ShopItem shopItem, money32 price)
                     satisfaction++;
             }
         }
-        ride->UpdateSatisfaction(satisfaction);
+        ride.UpdateSatisfaction(satisfaction);
     }
 
     // The peep has now decided to buy the item (or, specifically, has not been
     // dissuaded so far).
     GiveItem(shopItem);
-    const auto hasRandomShopColour = ride->HasLifecycleFlag(RIDE_LIFECYCLE_RANDOM_SHOP_COLOURS);
+    const auto hasRandomShopColour = ride.HasLifecycleFlag(RIDE_LIFECYCLE_RANDOM_SHOP_COLOURS);
 
     if (shopItem == ShopItem::TShirt)
-        TshirtColour = hasRandomShopColour ? scenario_rand_max(COLOUR_COUNT - 1) : ride->track_colour[0].main;
+        TshirtColour = hasRandomShopColour ? scenario_rand_max(COLOUR_COUNT - 1) : ride.track_colour[0].main;
 
     if (shopItem == ShopItem::Hat)
-        HatColour = hasRandomShopColour ? scenario_rand_max(COLOUR_COUNT - 1) : ride->track_colour[0].main;
+        HatColour = hasRandomShopColour ? scenario_rand_max(COLOUR_COUNT - 1) : ride.track_colour[0].main;
 
     if (shopItem == ShopItem::Balloon)
-        BalloonColour = hasRandomShopColour ? scenario_rand_max(COLOUR_COUNT - 1) : ride->track_colour[0].main;
+        BalloonColour = hasRandomShopColour ? scenario_rand_max(COLOUR_COUNT - 1) : ride.track_colour[0].main;
 
     if (shopItem == ShopItem::Umbrella)
-        UmbrellaColour = hasRandomShopColour ? scenario_rand_max(COLOUR_COUNT - 1) : ride->track_colour[0].main;
+        UmbrellaColour = hasRandomShopColour ? scenario_rand_max(COLOUR_COUNT - 1) : ride.track_colour[0].main;
 
     if (shopItem == ShopItem::Map)
         ResetPathfindGoal();
@@ -1634,16 +1634,16 @@ bool Guest::DecideAndBuyItem(Ride* ride, ShopItem shopItem, money32 price)
     TimeToConsume = std::min((TimeToConsume + consumptionTime), 255);
 
     if (shopItem == ShopItem::Photo)
-        Photo1RideRef = ride->id;
+        Photo1RideRef = ride.id;
 
     if (shopItem == ShopItem::Photo2)
-        Photo2RideRef = ride->id;
+        Photo2RideRef = ride.id;
 
     if (shopItem == ShopItem::Photo3)
-        Photo3RideRef = ride->id;
+        Photo3RideRef = ride.id;
 
     if (shopItem == ShopItem::Photo4)
-        Photo4RideRef = ride->id;
+        Photo4RideRef = ride.id;
 
     WindowInvalidateFlags |= PEEP_INVALIDATE_PEEP_INVENTORY;
     UpdateSpriteType();
@@ -1696,11 +1696,11 @@ bool Guest::DecideAndBuyItem(Ride* ride, ShopItem shopItem, money32 price)
     {
         SpendMoney(*expend_type, price, expenditure);
     }
-    ride->total_profit += (price - GetShopItemDescriptor(shopItem).Cost);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
-    ride->cur_num_customers++;
-    ride->total_customers++;
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_CUSTOMER;
+    ride.total_profit += (price - GetShopItemDescriptor(shopItem).Cost);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.cur_num_customers++;
+    ride.total_customers++;
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_CUSTOMER;
 
     return true;
 }
@@ -1710,11 +1710,8 @@ bool Guest::DecideAndBuyItem(Ride* ride, ShopItem shopItem, money32 price)
  * ride's satisfaction value.
  *  rct2: 0x0069545B
  */
-void Guest::OnEnterRide(Ride* ride)
+void Guest::OnEnterRide(Ride& ride)
 {
-    if (ride == nullptr)
-        return;
-
     // Calculate how satisfying the ride is for the peep. Can range from -140 to +105.
     int16_t satisfaction = peep_calculate_ride_satisfaction(this, ride);
 
@@ -1727,7 +1724,7 @@ void Guest::OnEnterRide(Ride* ride)
     else if (satisfaction >= 0)
         rideSatisfaction = 1;
 
-    ride->UpdateSatisfaction(rideSatisfaction);
+    ride.UpdateSatisfaction(rideSatisfaction);
 
     // Update various peep stats.
     if (GuestNumRides < 255)
@@ -1743,12 +1740,12 @@ void Guest::OnEnterRide(Ride* ride)
  *
  *  rct2: 0x0069576E
  */
-void Guest::OnExitRide(Ride* ride)
+void Guest::OnExitRide(Ride& ride)
 {
     if (PeepFlags & PEEP_FLAGS_RIDE_SHOULD_BE_MARKED_AS_FAVOURITE)
     {
         PeepFlags &= ~PEEP_FLAGS_RIDE_SHOULD_BE_MARKED_AS_FAVOURITE;
-        FavouriteRide = ride->id;
+        FavouriteRide = ride.id;
         // TODO fix this flag name or add another one
         WindowInvalidateFlags |= PEEP_INVALIDATE_STAFF_STATS;
     }
@@ -1759,9 +1756,9 @@ void Guest::OnExitRide(Ride* ride)
     if (PeepFlags & PEEP_FLAGS_LEAVING_PARK)
         PeepFlags &= ~(PEEP_FLAGS_PARK_ENTRANCE_CHOSEN);
 
-    if (ride != nullptr && peep_should_go_on_ride_again(this, ride))
+    if (peep_should_go_on_ride_again(this, ride))
     {
-        GuestHeadingToRideId = ride->id;
+        GuestHeadingToRideId = ride.id;
         GuestIsLostCountdown = 200;
         ResetPathfindGoal();
         WindowInvalidateFlags |= PEEP_INVALIDATE_PEEP_ACTION;
@@ -1775,9 +1772,9 @@ void Guest::OnExitRide(Ride* ride)
         }
     }
 
-    if (ride != nullptr && peep_really_liked_ride(this, ride))
+    if (peep_really_liked_ride(this, ride))
     {
-        InsertNewThought(PeepThoughtType::WasGreat, ride->id);
+        InsertNewThought(PeepThoughtType::WasGreat, ride.id);
 
         static constexpr OpenRCT2::Audio::SoundId laughs[3] = {
             OpenRCT2::Audio::SoundId::Laugh1,
@@ -1791,11 +1788,8 @@ void Guest::OnExitRide(Ride* ride)
         }
     }
 
-    if (ride != nullptr)
-    {
-        ride->total_customers++;
-        ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_CUSTOMER;
-    }
+    ride.total_customers++;
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_CUSTOMER;
 }
 
 /**
@@ -1844,7 +1838,7 @@ Ride* Guest::FindBestRideToGoOn()
         {
             if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_QUEUE_FULL))
             {
-                if (ShouldGoOnRide(&ride, StationIndex::FromUnderlying(0), false, true) && ride_has_ratings(&ride))
+                if (ShouldGoOnRide(ride, StationIndex::FromUnderlying(0), false, true) && ride_has_ratings(ride))
                 {
                     if (mostExcitingRide == nullptr || ride.excitement > mostExcitingRide->excitement)
                     {
@@ -1869,7 +1863,7 @@ BitSet<OpenRCT2::Limits::MaxRidesInPark> Guest::FindRidesToGoOn()
         // Consider rides that peep hasn't been on yet
         for (auto& ride : GetRideManager())
         {
-            if (!HasRidden(&ride))
+            if (!HasRidden(ride))
             {
                 rideConsideration[ride.id.ToUnderlying()] = true;
             }
@@ -1919,16 +1913,16 @@ BitSet<OpenRCT2::Limits::MaxRidesInPark> Guest::FindRidesToGoOn()
  * ride/shop, or they may just be thinking about it.
  *  rct2: 0x006960AB
  */
-bool Guest::ShouldGoOnRide(Ride* ride, StationIndex entranceNum, bool atQueue, bool thinking)
+bool Guest::ShouldGoOnRide(Ride& ride, StationIndex entranceNum, bool atQueue, bool thinking)
 {
     // Indicates whether a peep is physically at the ride, or is just thinking about going on the ride.
     bool peepAtRide = !thinking;
 
-    if (ride->status == RideStatus::Open && !(ride->lifecycle_flags & RIDE_LIFECYCLE_BROKEN_DOWN))
+    if (ride.status == RideStatus::Open && !(ride.lifecycle_flags & RIDE_LIFECYCLE_BROKEN_DOWN))
     {
         // Peeps that are leaving the park will refuse to go on any rides, with the exception of free transport rides.
-        assert(ride->type < std::size(RideTypeDescriptors));
-        if (!ride->GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_TRANSPORT_RIDE) || ride->value == RIDE_VALUE_UNDEFINED
+        assert(ride.type < std::size(RideTypeDescriptors));
+        if (!ride.GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_TRANSPORT_RIDE) || ride.value == RIDE_VALUE_UNDEFINED
             || ride_get_price(ride) != 0)
         {
             if (PeepFlags & PEEP_FLAGS_LEAVING_PARK)
@@ -1938,7 +1932,7 @@ bool Guest::ShouldGoOnRide(Ride* ride, StationIndex entranceNum, bool atQueue, b
             }
         }
 
-        if (ride->GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_IS_SHOP_OR_FACILITY))
+        if (ride.GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_IS_SHOP_OR_FACILITY))
         {
             return ShouldGoToShop(ride, peepAtRide);
         }
@@ -1947,7 +1941,7 @@ bool Guest::ShouldGoOnRide(Ride* ride, StationIndex entranceNum, bool atQueue, b
         // This means we can use the existing !(flags & 4) check.
         if (peepAtRide)
         {
-            auto& station = ride->GetStation(entranceNum);
+            auto& station = ride.GetStation(entranceNum);
 
             // Rides without queues can only have one peep waiting at a time.
             if (!atQueue)
@@ -1989,10 +1983,10 @@ bool Guest::ShouldGoOnRide(Ride* ride, StationIndex entranceNum, bool atQueue, b
         // Assuming the queue conditions are met, peeps will always go on free transport rides.
         // Ride ratings, recent crashes and weather will all be ignored.
         money16 ridePrice = ride_get_price(ride);
-        if (!ride->GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_TRANSPORT_RIDE) || ride->value == RIDE_VALUE_UNDEFINED
+        if (!ride.GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_TRANSPORT_RIDE) || ride.value == RIDE_VALUE_UNDEFINED
             || ridePrice != 0)
         {
-            if (PreviousRide == ride->id)
+            if (PreviousRide == ride.id)
             {
                 ChoseNotToGoOnRide(ride, peepAtRide, false);
                 return false;
@@ -2011,7 +2005,7 @@ bool Guest::ShouldGoOnRide(Ride* ride, StationIndex entranceNum, bool atQueue, b
                         }
                         else
                         {
-                            InsertNewThought(PeepThoughtType::CantAffordRide, ride->id);
+                            InsertNewThought(PeepThoughtType::CantAffordRide, ride.id);
                         }
                     }
                     ChoseNotToGoOnRide(ride, peepAtRide, true);
@@ -2020,16 +2014,16 @@ bool Guest::ShouldGoOnRide(Ride* ride, StationIndex entranceNum, bool atQueue, b
             }
 
             // If happy enough, peeps will ignore the fact that a ride has recently crashed.
-            if (ride->last_crash_type != RIDE_CRASH_TYPE_NONE && Happiness < 225)
+            if (ride.last_crash_type != RIDE_CRASH_TYPE_NONE && Happiness < 225)
             {
                 if (peepAtRide)
                 {
-                    InsertNewThought(PeepThoughtType::NotSafe, ride->id);
+                    InsertNewThought(PeepThoughtType::NotSafe, ride.id);
                     if (HappinessTarget >= 64)
                     {
                         HappinessTarget -= 8;
                     }
-                    ride->UpdatePopularity(0);
+                    ride.UpdatePopularity(0);
                 }
                 ChoseNotToGoOnRide(ride, peepAtRide, true);
                 return false;
@@ -2039,9 +2033,9 @@ bool Guest::ShouldGoOnRide(Ride* ride, StationIndex entranceNum, bool atQueue, b
             {
                 // If a peep has already decided that they're going to go on a ride, they'll skip the weather and
                 // excitement check and will only do a basic intensity check when they arrive at the ride itself.
-                if (ride->id == GuestHeadingToRideId)
+                if (ride.id == GuestHeadingToRideId)
                 {
-                    if (ride->intensity > RIDE_RATING(10, 00) && !gCheatsIgnoreRideIntensity)
+                    if (ride.intensity > RIDE_RATING(10, 00) && !gCheatsIgnoreRideIntensity)
                     {
                         peep_ride_is_too_intense(this, ride, peepAtRide);
                         return false;
@@ -2049,23 +2043,23 @@ bool Guest::ShouldGoOnRide(Ride* ride, StationIndex entranceNum, bool atQueue, b
                 }
                 else
                 {
-                    if (ClimateIsRaining() && !ShouldRideWhileRaining(*ride))
+                    if (ClimateIsRaining() && !ShouldRideWhileRaining(ride))
                     {
                         if (peepAtRide)
                         {
-                            InsertNewThought(PeepThoughtType::NotWhileRaining, ride->id);
+                            InsertNewThought(PeepThoughtType::NotWhileRaining, ride.id);
                             if (HappinessTarget >= 64)
                             {
                                 HappinessTarget -= 8;
                             }
-                            ride->UpdatePopularity(0);
+                            ride.UpdatePopularity(0);
                         }
                         ChoseNotToGoOnRide(ride, peepAtRide, true);
                         return false;
                     }
                     // If it is raining and the ride provides shelter skip the
                     // ride intensity check and get me on a sheltered ride!
-                    if (!ClimateIsRaining() || !ShouldRideWhileRaining(*ride))
+                    if (!ClimateIsRaining() || !ShouldRideWhileRaining(ride))
                     {
                         if (!gCheatsIgnoreRideIntensity)
                         {
@@ -2074,21 +2068,21 @@ bool Guest::ShouldGoOnRide(Ride* ride, StationIndex entranceNum, bool atQueue, b
                             // intensity and decrease the min intensity by about 2.5.
                             ride_rating maxIntensity = std::min(Intensity.GetMaximum() * 100, 1000) + Happiness;
                             ride_rating minIntensity = (Intensity.GetMinimum() * 100) - Happiness;
-                            if (ride->intensity < minIntensity)
+                            if (ride.intensity < minIntensity)
                             {
                                 if (peepAtRide)
                                 {
-                                    InsertNewThought(PeepThoughtType::MoreThrilling, ride->id);
+                                    InsertNewThought(PeepThoughtType::MoreThrilling, ride.id);
                                     if (HappinessTarget >= 64)
                                     {
                                         HappinessTarget -= 8;
                                     }
-                                    ride->UpdatePopularity(0);
+                                    ride.UpdatePopularity(0);
                                 }
                                 ChoseNotToGoOnRide(ride, peepAtRide, true);
                                 return false;
                             }
-                            if (ride->intensity > maxIntensity)
+                            if (ride.intensity > maxIntensity)
                             {
                                 peep_ride_is_too_intense(this, ride, peepAtRide);
                                 return false;
@@ -2097,23 +2091,23 @@ bool Guest::ShouldGoOnRide(Ride* ride, StationIndex entranceNum, bool atQueue, b
                             // Nausea calculations.
                             ride_rating maxNausea = NauseaMaximumThresholds[(EnumValue(NauseaTolerance) & 3)] + Happiness;
 
-                            if (ride->nausea > maxNausea)
+                            if (ride.nausea > maxNausea)
                             {
                                 if (peepAtRide)
                                 {
-                                    InsertNewThought(PeepThoughtType::Sickening, ride->id);
+                                    InsertNewThought(PeepThoughtType::Sickening, ride.id);
                                     if (HappinessTarget >= 64)
                                     {
                                         HappinessTarget -= 8;
                                     }
-                                    ride->UpdatePopularity(0);
+                                    ride.UpdatePopularity(0);
                                 }
                                 ChoseNotToGoOnRide(ride, peepAtRide, true);
                                 return false;
                             }
 
                             // Very nauseous peeps will only go on very gentle rides.
-                            if (ride->nausea >= FIXED_2DP(1, 40) && Nausea > 160)
+                            if (ride.nausea >= FIXED_2DP(1, 40) && Nausea > 160)
                             {
                                 ChoseNotToGoOnRide(ride, peepAtRide, false);
                                 return false;
@@ -2125,7 +2119,7 @@ bool Guest::ShouldGoOnRide(Ride* ride, StationIndex entranceNum, bool atQueue, b
 
             // If the ride has not yet been rated and is capable of having g-forces,
             // there's a 90% chance that the peep will ignore it.
-            if (!ride_has_ratings(ride) && ride->GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_PEEP_CHECK_GFORCES))
+            if (!ride_has_ratings(ride) && ride.GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_PEEP_CHECK_GFORCES))
             {
                 if ((scenario_rand() & 0xFFFF) > 0x1999U)
                 {
@@ -2135,8 +2129,8 @@ bool Guest::ShouldGoOnRide(Ride* ride, StationIndex entranceNum, bool atQueue, b
 
                 if (!gCheatsIgnoreRideIntensity)
                 {
-                    if (ride->max_positive_vertical_g > FIXED_2DP(5, 00) || ride->max_negative_vertical_g < FIXED_2DP(-4, 00)
-                        || ride->max_lateral_g > FIXED_2DP(4, 00))
+                    if (ride.max_positive_vertical_g > FIXED_2DP(5, 00) || ride.max_negative_vertical_g < FIXED_2DP(-4, 00)
+                        || ride.max_lateral_g > FIXED_2DP(4, 00))
                     {
                         ChoseNotToGoOnRide(ride, peepAtRide, false);
                         return false;
@@ -2144,7 +2138,7 @@ bool Guest::ShouldGoOnRide(Ride* ride, StationIndex entranceNum, bool atQueue, b
                 }
             }
 
-            uint32_t value = ride->value;
+            uint32_t value = ride.value;
 
             // If the value of the ride hasn't yet been calculated, peeps will be willing to pay any amount for the ride.
             if (value != 0xFFFF && !peep_has_voucher_for_free_ride(this, ride) && !(gParkFlags & PARK_FLAGS_NO_MONEY))
@@ -2159,12 +2153,12 @@ bool Guest::ShouldGoOnRide(Ride* ride, StationIndex entranceNum, bool atQueue, b
                 {
                     if (peepAtRide)
                     {
-                        InsertNewThought(PeepThoughtType::BadValue, ride->id);
+                        InsertNewThought(PeepThoughtType::BadValue, ride.id);
                         if (HappinessTarget >= 60)
                         {
                             HappinessTarget -= 16;
                         }
-                        ride->UpdatePopularity(0);
+                        ride.UpdatePopularity(0);
                     }
                     ChoseNotToGoOnRide(ride, peepAtRide, true);
                     return false;
@@ -2177,7 +2171,7 @@ bool Guest::ShouldGoOnRide(Ride* ride, StationIndex entranceNum, bool atQueue, b
                     {
                         if (!(PeepFlags & PEEP_FLAGS_HAS_PAID_FOR_PARK_ENTRY))
                         {
-                            InsertNewThought(PeepThoughtType::GoodValue, ride->id);
+                            InsertNewThought(PeepThoughtType::GoodValue, ride.id);
                         }
                     }
                 }
@@ -2187,15 +2181,15 @@ bool Guest::ShouldGoOnRide(Ride* ride, StationIndex entranceNum, bool atQueue, b
         // At this point, the peep has decided to go on the ride.
         if (peepAtRide)
         {
-            ride->UpdatePopularity(1);
+            ride.UpdatePopularity(1);
         }
 
-        if (ride->id == GuestHeadingToRideId)
+        if (ride.id == GuestHeadingToRideId)
         {
             peep_reset_ride_heading(this);
         }
 
-        ride->lifecycle_flags &= ~RIDE_LIFECYCLE_QUEUE_FULL;
+        ride.lifecycle_flags &= ~RIDE_LIFECYCLE_QUEUE_FULL;
         return true;
     }
 
@@ -2203,16 +2197,16 @@ bool Guest::ShouldGoOnRide(Ride* ride, StationIndex entranceNum, bool atQueue, b
     return false;
 }
 
-bool Guest::ShouldGoToShop(Ride* ride, bool peepAtShop)
+bool Guest::ShouldGoToShop(Ride& ride, bool peepAtShop)
 {
     // Peeps won't go to the same shop twice in a row.
-    if (ride->id == PreviousRide)
+    if (ride.id == PreviousRide)
     {
         ChoseNotToGoOnRide(ride, peepAtShop, true);
         return false;
     }
 
-    const auto& rtd = ride->GetRideTypeDescriptor();
+    const auto& rtd = ride.GetRideTypeDescriptor();
     if (rtd.HasFlag(RIDE_TYPE_FLAG_IS_TOILET))
     {
         if (Toilet < 70)
@@ -2227,12 +2221,12 @@ bool Guest::ShouldGoToShop(Ride* ride, bool peepAtShop)
         {
             if (peepAtShop)
             {
-                InsertNewThought(PeepThoughtType::NotPaying, ride->id);
+                InsertNewThought(PeepThoughtType::NotPaying, ride.id);
                 if (HappinessTarget >= 60)
                 {
                     HappinessTarget -= 16;
                 }
-                ride->UpdatePopularity(0);
+                ride.UpdatePopularity(0);
             }
             ChoseNotToGoOnRide(ride, peepAtShop, true);
             return false;
@@ -2260,7 +2254,7 @@ bool Guest::ShouldGoToShop(Ride* ride, bool peepAtShop)
             }
             else
             {
-                InsertNewThought(PeepThoughtType::CantAffordRide, ride->id);
+                InsertNewThought(PeepThoughtType::CantAffordRide, ride.id);
             }
         }
         ChoseNotToGoOnRide(ride, peepAtShop, true);
@@ -2269,8 +2263,8 @@ bool Guest::ShouldGoToShop(Ride* ride, bool peepAtShop)
 
     if (peepAtShop)
     {
-        ride->UpdatePopularity(1);
-        if (ride->id == GuestHeadingToRideId)
+        ride.UpdatePopularity(1);
+        if (ride.id == GuestHeadingToRideId)
         {
             peep_reset_ride_heading(this);
         }
@@ -2316,16 +2310,16 @@ void Guest::SpendMoney(money16& peep_expend_type, money32 amount, ExpenditureTyp
     OpenRCT2::Audio::Play3D(OpenRCT2::Audio::SoundId::Purchase, GetLocation());
 }
 
-void Guest::SetHasRidden(const Ride* ride)
+void Guest::SetHasRidden(const Ride& ride)
 {
-    OpenRCT2::RideUse::GetHistory().Add(sprite_index, ride->id);
+    OpenRCT2::RideUse::GetHistory().Add(sprite_index, ride.id);
 
-    SetHasRiddenRideType(ride->type);
+    SetHasRiddenRideType(ride.type);
 }
 
-bool Guest::HasRidden(const Ride* ride) const
+bool Guest::HasRidden(const Ride& ride) const
 {
-    return OpenRCT2::RideUse::GetHistory().Contains(sprite_index, ride->id);
+    return OpenRCT2::RideUse::GetHistory().Contains(sprite_index, ride.id);
 }
 
 void Guest::SetHasRiddenRideType(int32_t rideType)
@@ -2367,15 +2361,15 @@ bool Guest::ShouldRideWhileRaining(const Ride& ride)
     return false;
 }
 
-void Guest::ChoseNotToGoOnRide(Ride* ride, bool peepAtRide, bool updateLastRide)
+void Guest::ChoseNotToGoOnRide(const Ride& ride, bool peepAtRide, bool updateLastRide)
 {
     if (peepAtRide && updateLastRide)
     {
-        PreviousRide = ride->id;
+        PreviousRide = ride.id;
         PreviousRideTimeOut = 0;
     }
 
-    if (ride->id == GuestHeadingToRideId)
+    if (ride.id == GuestHeadingToRideId)
     {
         peep_reset_ride_heading(this);
     }
@@ -2392,9 +2386,9 @@ void Guest::ReadMap()
     }
 }
 
-static bool peep_has_voucher_for_free_ride(Guest* peep, Ride* ride)
+static bool peep_has_voucher_for_free_ride(Guest* peep, const Ride& ride)
 {
-    return peep->HasItem(ShopItem::Voucher) && peep->VoucherType == VOUCHER_TYPE_RIDE_FREE && peep->VoucherRideId == ride->id;
+    return peep->HasItem(ShopItem::Voucher) && peep->VoucherType == VOUCHER_TYPE_RIDE_FREE && peep->VoucherRideId == ride.id;
 }
 
 /**
@@ -2402,13 +2396,13 @@ static bool peep_has_voucher_for_free_ride(Guest* peep, Ride* ride)
  * Does not effect peeps that walk up to the queue entrance.
  * This flag is reset the next time a peep successfully joins the queue.
  */
-static void peep_tried_to_enter_full_queue(Guest* peep, Ride* ride)
+static void peep_tried_to_enter_full_queue(Guest* peep, Ride& ride)
 {
-    ride->lifecycle_flags |= RIDE_LIFECYCLE_QUEUE_FULL;
-    peep->PreviousRide = ride->id;
+    ride.lifecycle_flags |= RIDE_LIFECYCLE_QUEUE_FULL;
+    peep->PreviousRide = ride.id;
     peep->PreviousRideTimeOut = 0;
     // Change status "Heading to" to "Walking" if queue is full
-    if (ride->id == peep->GuestHeadingToRideId)
+    if (ride.id == peep->GuestHeadingToRideId)
     {
         peep_reset_ride_heading(peep);
     }
@@ -2420,16 +2414,16 @@ static void peep_reset_ride_heading(Guest* peep)
     peep->WindowInvalidateFlags |= PEEP_INVALIDATE_PEEP_ACTION;
 }
 
-static void peep_ride_is_too_intense(Guest* peep, Ride* ride, bool peepAtRide)
+static void peep_ride_is_too_intense(Guest* peep, Ride& ride, bool peepAtRide)
 {
     if (peepAtRide)
     {
-        peep->InsertNewThought(PeepThoughtType::Intense, ride->id);
+        peep->InsertNewThought(PeepThoughtType::Intense, ride.id);
         if (peep->HappinessTarget >= 64)
         {
             peep->HappinessTarget -= 8;
         }
-        ride->UpdatePopularity(0);
+        ride.UpdatePopularity(0);
     }
     peep->ChoseNotToGoOnRide(ride, peepAtRide, true);
 }
@@ -2438,10 +2432,10 @@ static void peep_ride_is_too_intense(Guest* peep, Ride* ride, bool peepAtRide)
  *
  *  rct2: 0x00691C6E
  */
-static Vehicle* peep_choose_car_from_ride(Peep* peep, Ride* ride, std::vector<uint8_t>& car_array)
+static Vehicle* peep_choose_car_from_ride(Peep* peep, const Ride& ride, std::vector<uint8_t>& car_array)
 {
     uint8_t chosen_car = scenario_rand();
-    if (ride->GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_HAS_G_FORCES) && ((chosen_car & 0xC) != 0xC))
+    if (ride.GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_HAS_G_FORCES) && ((chosen_car & 0xC) != 0xC))
     {
         chosen_car = (scenario_rand() & 1) ? 0 : static_cast<uint8_t>(car_array.size()) - 1;
     }
@@ -2452,7 +2446,7 @@ static Vehicle* peep_choose_car_from_ride(Peep* peep, Ride* ride, std::vector<ui
 
     peep->CurrentCar = car_array[chosen_car];
 
-    Vehicle* vehicle = GetEntity<Vehicle>(ride->vehicles[peep->CurrentTrain]);
+    Vehicle* vehicle = GetEntity<Vehicle>(ride.vehicles[peep->CurrentTrain]);
     if (vehicle == nullptr)
     {
         return nullptr;
@@ -2464,7 +2458,7 @@ static Vehicle* peep_choose_car_from_ride(Peep* peep, Ride* ride, std::vector<ui
  *
  *  rct2: 0x00691CD1
  */
-static void peep_choose_seat_from_car(Peep* peep, Ride* ride, Vehicle* vehicle)
+static void peep_choose_seat_from_car(Peep* peep, const Ride& ride, Vehicle* vehicle)
 {
     if (vehicle == nullptr)
     {
@@ -2472,7 +2466,7 @@ static void peep_choose_seat_from_car(Peep* peep, Ride* ride, Vehicle* vehicle)
     }
     uint8_t chosen_seat = vehicle->next_free_seat;
 
-    if (ride->mode == RideMode::ForwardRotation || ride->mode == RideMode::BackwardRotation)
+    if (ride.mode == RideMode::ForwardRotation || ride.mode == RideMode::BackwardRotation)
     {
         chosen_seat = (((~vehicle->Pitch + 1) >> 3) & 0xF) * 2;
         if (vehicle->next_free_seat & 1)
@@ -2491,9 +2485,9 @@ static void peep_choose_seat_from_car(Peep* peep, Ride* ride, Vehicle* vehicle)
  *
  *  rct2: 0x00691D27
  */
-void Guest::GoToRideEntrance(Ride* ride)
+void Guest::GoToRideEntrance(const Ride& ride)
 {
-    const auto& station = ride->GetStation(CurrentRideStation);
+    const auto& station = ride.GetStation(CurrentRideStation);
     if (station.Entrance.IsNull())
     {
         RemoveFromQueue();
@@ -2505,7 +2499,7 @@ void Guest::GoToRideEntrance(Ride* ride)
     int16_t y_shift = DirectionOffsets[location.direction].y;
 
     uint8_t shift_multiplier = 21;
-    rct_ride_entry* rideEntry = get_ride_entry(ride->subtype);
+    rct_ride_entry* rideEntry = get_ride_entry(ride.subtype);
     if (rideEntry != nullptr)
     {
         if (rideEntry->Cars[rideEntry->DefaultCar].flags & CAR_ENTRY_FLAG_MINI_GOLF
@@ -2531,18 +2525,18 @@ void Guest::GoToRideEntrance(Ride* ride)
     RemoveFromQueue();
 }
 
-bool Guest::FindVehicleToEnter(Ride* ride, std::vector<uint8_t>& car_array)
+bool Guest::FindVehicleToEnter(const Ride& ride, std::vector<uint8_t>& car_array)
 {
     uint8_t chosen_train = RideStation::NO_TRAIN;
 
-    if (ride->mode == RideMode::Dodgems || ride->mode == RideMode::Race)
+    if (ride.mode == RideMode::Dodgems || ride.mode == RideMode::Race)
     {
-        if (ride->lifecycle_flags & RIDE_LIFECYCLE_PASS_STATION_NO_STOPPING)
+        if (ride.lifecycle_flags & RIDE_LIFECYCLE_PASS_STATION_NO_STOPPING)
             return false;
 
-        for (int32_t i = 0; i < ride->NumTrains; ++i)
+        for (int32_t i = 0; i < ride.NumTrains; ++i)
         {
-            Vehicle* vehicle = GetEntity<Vehicle>(ride->vehicles[i]);
+            Vehicle* vehicle = GetEntity<Vehicle>(ride.vehicles[i]);
             if (vehicle == nullptr)
                 continue;
 
@@ -2557,7 +2551,7 @@ bool Guest::FindVehicleToEnter(Ride* ride, std::vector<uint8_t>& car_array)
     }
     else
     {
-        chosen_train = ride->GetStation(CurrentRideStation).TrainAtStation;
+        chosen_train = ride.GetStation(CurrentRideStation).TrainAtStation;
     }
     if (chosen_train >= OpenRCT2::Limits::MaxTrainsPerRide)
     {
@@ -2568,7 +2562,7 @@ bool Guest::FindVehicleToEnter(Ride* ride, std::vector<uint8_t>& car_array)
 
     int32_t i = 0;
 
-    auto vehicle_id = ride->vehicles[chosen_train];
+    auto vehicle_id = ride.vehicles[chosen_train];
     for (Vehicle* vehicle = GetEntity<Vehicle>(vehicle_id); vehicle != nullptr;
          vehicle = GetEntity<Vehicle>(vehicle->next_vehicle_on_train), ++i)
     {
@@ -2586,7 +2580,7 @@ bool Guest::FindVehicleToEnter(Ride* ride, std::vector<uint8_t>& car_array)
         if (num_seats == vehicle->next_free_seat)
             continue;
 
-        if (ride->mode == RideMode::ForwardRotation || ride->mode == RideMode::BackwardRotation)
+        if (ride.mode == RideMode::ForwardRotation || ride.mode == RideMode::BackwardRotation)
         {
             uint8_t position = (((~vehicle->Pitch + 1) >> 3) & 0xF) * 2;
             if (!vehicle->peep[position].IsNull())
@@ -2609,7 +2603,7 @@ static void peep_update_ride_at_entrance_try_leave(Guest* peep)
     }
 }
 
-static bool peep_check_ride_price_at_entrance(Guest* peep, Ride* ride, money32 ridePrice)
+static bool peep_check_ride_price_at_entrance(Guest* peep, const Ride& ride, money32 ridePrice)
 {
     if ((peep->HasItem(ShopItem::Voucher)) && peep->VoucherType == VOUCHER_TYPE_RIDE_FREE
         && peep->VoucherRideId == peep->CurrentRide)
@@ -2635,7 +2629,7 @@ static bool peep_check_ride_price_at_entrance(Guest* peep, Ride* ride, money32 r
         return false;
     }
 
-    uint16_t value = ride->value;
+    uint16_t value = ride.value;
     if (value != RIDE_VALUE_UNDEFINED)
     {
         if (value * 2 < ridePrice)
@@ -2656,7 +2650,7 @@ static bool peep_check_ride_price_at_entrance(Guest* peep, Ride* ride, money32 r
  * - How long the peep was waiting in the queue
  * - If the peep has been on the ride before, or on another ride of the same type
  */
-static int16_t peep_calculate_ride_satisfaction(Guest* peep, Ride* ride)
+static int16_t peep_calculate_ride_satisfaction(Guest* peep, const Ride& ride)
 {
     int16_t satisfaction = peep_calculate_ride_value_satisfaction(peep, ride);
     satisfaction += peep_calculate_ride_intensity_nausea_satisfaction(peep, ride);
@@ -2673,10 +2667,10 @@ static int16_t peep_calculate_ride_satisfaction(Guest* peep, Ride* ride)
 
     // Peeps get a small boost in satisfaction if they've been on a ride of the same type before,
     // and this boost is doubled if they've already been on this particular ride.
-    if (peep->HasRiddenRideType(ride->type))
+    if (peep->HasRiddenRideType(ride.type))
         satisfaction += 10;
 
-    if (peep->HasRidden(get_ride(peep->CurrentRide)))
+    if (peep->HasRidden(*get_ride(peep->CurrentRide)))
         satisfaction += 10;
 
     return satisfaction;
@@ -2692,10 +2686,10 @@ static int16_t peep_calculate_ride_satisfaction(Guest* peep, Ride* ride)
  * the ride becomes the peep's favourite. (This doesn't happen right away, but will be updated once the peep
  * exits the ride.)
  */
-static void peep_update_favourite_ride(Guest* peep, Ride* ride)
+static void peep_update_favourite_ride(Guest* peep, const Ride& ride)
 {
     peep->PeepFlags &= ~PEEP_FLAGS_RIDE_SHOULD_BE_MARKED_AS_FAVOURITE;
-    uint8_t peepRideRating = std::clamp((ride->excitement / 4) + peep->Happiness, 0, PEEP_MAX_HAPPINESS);
+    uint8_t peepRideRating = std::clamp((ride.excitement / 4) + peep->Happiness, 0, PEEP_MAX_HAPPINESS);
     if (peepRideRating >= peep->FavouriteRideRating)
     {
         if (peep->Happiness >= 160 && peep->HappinessTarget >= 160)
@@ -2707,25 +2701,25 @@ static void peep_update_favourite_ride(Guest* peep, Ride* ride)
 }
 
 /* rct2: 0x00695555 */
-static int16_t peep_calculate_ride_value_satisfaction(Guest* peep, Ride* ride)
+static int16_t peep_calculate_ride_value_satisfaction(Guest* peep, const Ride& ride)
 {
     if (gParkFlags & PARK_FLAGS_NO_MONEY)
     {
         return -30;
     }
 
-    if (ride->value == RIDE_VALUE_UNDEFINED)
+    if (ride.value == RIDE_VALUE_UNDEFINED)
     {
         return -30;
     }
 
     money16 ridePrice = ride_get_price(ride);
-    if (ride->value >= ridePrice)
+    if (ride.value >= ridePrice)
     {
         return -5;
     }
 
-    if ((ride->value + ((ride->value * peep->Happiness) / 256)) >= ridePrice)
+    if ((ride.value + ((ride.value * peep->Happiness) / 256)) >= ridePrice)
     {
         return -30;
     }
@@ -2739,7 +2733,7 @@ static int16_t peep_calculate_ride_value_satisfaction(Guest* peep, Ride* ride)
  * of the ride fall exactly within the peep's preferences, but lower scores can still be achieved
  * if the peep's happiness is enough to offset it.
  */
-static int16_t peep_calculate_ride_intensity_nausea_satisfaction(Guest* peep, Ride* ride)
+static int16_t peep_calculate_ride_intensity_nausea_satisfaction(Guest* peep, const Ride& ride)
 {
     if (!ride_has_ratings(ride))
     {
@@ -2750,19 +2744,19 @@ static int16_t peep_calculate_ride_intensity_nausea_satisfaction(Guest* peep, Ri
     uint8_t nauseaSatisfaction = 3;
     ride_rating maxIntensity = peep->Intensity.GetMaximum() * 100;
     ride_rating minIntensity = peep->Intensity.GetMinimum() * 100;
-    if (minIntensity <= ride->intensity && maxIntensity >= ride->intensity)
+    if (minIntensity <= ride.intensity && maxIntensity >= ride.intensity)
     {
         intensitySatisfaction--;
     }
     minIntensity -= peep->Happiness * 2;
     maxIntensity += peep->Happiness;
-    if (minIntensity <= ride->intensity && maxIntensity >= ride->intensity)
+    if (minIntensity <= ride.intensity && maxIntensity >= ride.intensity)
     {
         intensitySatisfaction--;
     }
     minIntensity -= peep->Happiness * 2;
     maxIntensity += peep->Happiness;
-    if (minIntensity <= ride->intensity && maxIntensity >= ride->intensity)
+    if (minIntensity <= ride.intensity && maxIntensity >= ride.intensity)
     {
         intensitySatisfaction--;
     }
@@ -2771,19 +2765,19 @@ static int16_t peep_calculate_ride_intensity_nausea_satisfaction(Guest* peep, Ri
     // has a minimum preferred nausea value. (For peeps with None or Low, this is set to zero.)
     ride_rating minNausea = NauseaMinimumThresholds[(EnumValue(peep->NauseaTolerance) & 3)];
     ride_rating maxNausea = NauseaMaximumThresholds[(EnumValue(peep->NauseaTolerance) & 3)];
-    if (minNausea <= ride->nausea && maxNausea >= ride->nausea)
+    if (minNausea <= ride.nausea && maxNausea >= ride.nausea)
     {
         nauseaSatisfaction--;
     }
     minNausea -= peep->Happiness * 2;
     maxNausea += peep->Happiness;
-    if (minNausea <= ride->nausea && maxNausea >= ride->nausea)
+    if (minNausea <= ride.nausea && maxNausea >= ride.nausea)
     {
         nauseaSatisfaction--;
     }
     minNausea -= peep->Happiness * 2;
     maxNausea += peep->Happiness;
-    if (minNausea <= ride->nausea && maxNausea >= ride->nausea)
+    if (minNausea <= ride.nausea && maxNausea >= ride.nausea)
     {
         nauseaSatisfaction--;
     }
@@ -2839,22 +2833,22 @@ static int16_t peep_calculate_ride_intensity_nausea_satisfaction(Guest* peep, Ri
  * - How hungry the peep is (+0% nausea at 50% hunger up to +100% nausea at 100% hunger)
  * - The peep's nausea tolerance (Final modifier: none: 100%, low: 50%, average: 25%, high: 12.5%)
  */
-static void peep_update_ride_nausea_growth(Guest* peep, Ride* ride)
+static void peep_update_ride_nausea_growth(Guest* peep, const Ride& ride)
 {
     uint32_t nauseaMultiplier = std::clamp(256 - peep->HappinessTarget, 64, 200);
-    uint32_t nauseaGrowthRateChange = (ride->nausea * nauseaMultiplier) / 512;
+    uint32_t nauseaGrowthRateChange = (ride.nausea * nauseaMultiplier) / 512;
     nauseaGrowthRateChange *= std::max(static_cast<uint8_t>(128), peep->Hunger) / 64;
     nauseaGrowthRateChange >>= (EnumValue(peep->NauseaTolerance) & 3);
     peep->NauseaTarget = static_cast<uint8_t>(std::min(peep->NauseaTarget + nauseaGrowthRateChange, 255u));
 }
 
-static bool peep_should_go_on_ride_again(Guest* peep, Ride* ride)
+static bool peep_should_go_on_ride_again(Guest* peep, const Ride& ride)
 {
-    if (!ride->GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_PEEP_WILL_RIDE_AGAIN))
+    if (!ride.GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_PEEP_WILL_RIDE_AGAIN))
         return false;
     if (!ride_has_ratings(ride))
         return false;
-    if (ride->intensity > RIDE_RATING(10, 00) && !gCheatsIgnoreRideIntensity)
+    if (ride.intensity > RIDE_RATING(10, 00) && !gCheatsIgnoreRideIntensity)
         return false;
     if (peep->Happiness < 180)
         return false;
@@ -2891,7 +2885,7 @@ static bool peep_should_preferred_intensity_increase(Guest* peep)
     return (scenario_rand() & 0xFF) >= static_cast<uint8_t>(peep->Intensity);
 }
 
-static bool peep_really_liked_ride(Guest* peep, Ride* ride)
+static bool peep_really_liked_ride(Guest* peep, const Ride& ride)
 {
     if (peep->Happiness < 215)
         return false;
@@ -2899,7 +2893,7 @@ static bool peep_really_liked_ride(Guest* peep, Ride* ride)
         return false;
     if (!ride_has_ratings(ride))
         return false;
-    if (ride->intensity > RIDE_RATING(10, 00) && !gCheatsIgnoreRideIntensity)
+    if (ride.intensity > RIDE_RATING(10, 00) && !gCheatsIgnoreRideIntensity)
         return false;
     return true;
 }
@@ -2929,8 +2923,6 @@ static PeepThoughtType peep_assess_surroundings(int16_t centre_x, int16_t centre
         {
             for (auto* tileElement : TileElementsView({ x, y }))
             {
-                Ride* ride;
-
                 if (tileElement->IsGhost())
                 {
                     continue;
@@ -2968,7 +2960,7 @@ static PeepThoughtType peep_assess_surroundings(int16_t centre_x, int16_t centre
                         break;
                     case TileElementType::Track:
                     {
-                        ride = get_ride(tileElement->AsTrack()->GetRideIndex());
+                        auto* ride = get_ride(tileElement->AsTrack()->GetRideIndex());
                         if (ride == nullptr)
                             break;
 
@@ -3193,7 +3185,7 @@ template<typename T> static void peep_head_for_nearest_ride(Guest* peep, bool co
         {
             if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_QUEUE_FULL))
             {
-                if (peep->ShouldGoOnRide(&ride, StationIndex::FromUnderlying(0), false, true))
+                if (peep->ShouldGoOnRide(ride, StationIndex::FromUnderlying(0), false, true))
                 {
                     potentialRides[numPotentialRides++] = ride.id;
                 }
@@ -3399,7 +3391,7 @@ void Guest::UpdateBuying()
             {
                 money16 price = ride->price[1];
 
-                item_bought = DecideAndBuyItem(ride, ride_type->shop_item[1], price);
+                item_bought = DecideAndBuyItem(*ride, ride_type->shop_item[1], price);
                 if (item_bought)
                 {
                     ride->no_secondary_items_sold++;
@@ -3410,7 +3402,7 @@ void Guest::UpdateBuying()
             {
                 money16 price = ride->price[0];
 
-                item_bought = DecideAndBuyItem(ride, ride_type->shop_item[0], price);
+                item_bought = DecideAndBuyItem(*ride, ride_type->shop_item[0], price);
                 if (item_bought)
                 {
                     ride->no_primary_items_sold++;
@@ -3479,7 +3471,7 @@ void Guest::UpdateRideAtEntrance()
     }
     else
     {
-        if (!FindVehicleToEnter(ride, carArray))
+        if (!FindVehicleToEnter(*ride, carArray))
             return;
     }
 
@@ -3492,19 +3484,19 @@ void Guest::UpdateRideAtEntrance()
     if (ride->lifecycle_flags & RIDE_LIFECYCLE_BROKEN_DOWN)
         return;
 
-    money16 ridePrice = ride_get_price(ride);
+    money16 ridePrice = ride_get_price(*ride);
     if (ridePrice != 0)
     {
-        if (!peep_check_ride_price_at_entrance(this, ride, ridePrice))
+        if (!peep_check_ride_price_at_entrance(this, *ride, ridePrice))
             return;
     }
 
     if (!ride->GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_NO_VEHICLES))
     {
-        Vehicle* vehicle = peep_choose_car_from_ride(this, ride, carArray);
-        peep_choose_seat_from_car(this, ride, vehicle);
+        Vehicle* vehicle = peep_choose_car_from_ride(this, *ride, carArray);
+        peep_choose_seat_from_car(this, *ride, vehicle);
     }
-    GoToRideEntrance(ride);
+    GoToRideEntrance(*ride);
 }
 
 /** rct2: 0x00981FD4, 0x00981FD6 */
@@ -3515,7 +3507,7 @@ static constexpr const CoordsXY _MazeEntranceStart[] = {
     { 24, 8 },
 };
 
-void PeepUpdateRideLeaveEntranceMaze(Guest* peep, Ride* ride, CoordsXYZD& entrance_loc)
+void PeepUpdateRideLeaveEntranceMaze(Guest* peep, Ride& ride, CoordsXYZD& entrance_loc)
 {
     peep->MazeLastEdge = entrance_loc.direction + 1;
 
@@ -3539,14 +3531,14 @@ void PeepUpdateRideLeaveEntranceMaze(Guest* peep, Ride* ride, CoordsXYZD& entran
 
     peep->SetDestination(entrance_loc, 3);
 
-    ride->cur_num_customers++;
+    ride.cur_num_customers++;
     peep->OnEnterRide(ride);
     peep->RideSubState = PeepRideSubState::MazePathfinding;
 }
 
-void PeepUpdateRideLeaveEntranceSpiralSlide(Guest* peep, Ride* ride, CoordsXYZD& entrance_loc)
+void PeepUpdateRideLeaveEntranceSpiralSlide(Guest* peep, Ride& ride, CoordsXYZD& entrance_loc)
 {
-    entrance_loc = { ride->GetStation(peep->CurrentRideStation).GetStart(), entrance_loc.direction };
+    entrance_loc = { ride.GetStation(peep->CurrentRideStation).GetStart(), entrance_loc.direction };
 
     TileElement* tile_element = ride_get_station_start_track_element(ride, peep->CurrentRideStation);
 
@@ -3559,22 +3551,22 @@ void PeepUpdateRideLeaveEntranceSpiralSlide(Guest* peep, Ride* ride, CoordsXYZD&
     peep->SetDestination(entrance_loc);
     peep->CurrentCar = 0;
 
-    ride->cur_num_customers++;
+    ride.cur_num_customers++;
     peep->OnEnterRide(ride);
     peep->RideSubState = PeepRideSubState::ApproachSpiralSlide;
 }
 
-void PeepUpdateRideLeaveEntranceDefault(Guest* peep, Ride* ride, CoordsXYZD& entrance_loc)
+void PeepUpdateRideLeaveEntranceDefault(Guest* peep, Ride& ride, CoordsXYZD& entrance_loc)
 {
     // If the ride type was changed guests will become stuck.
     // Inform the player about this if its a new issue or hasn't been addressed within 120 seconds.
-    if ((ride->current_issues & RIDE_ISSUE_GUESTS_STUCK) == 0 || gCurrentTicks - ride->last_issue_time > 3000)
+    if ((ride.current_issues & RIDE_ISSUE_GUESTS_STUCK) == 0 || gCurrentTicks - ride.last_issue_time > 3000)
     {
-        ride->current_issues |= RIDE_ISSUE_GUESTS_STUCK;
-        ride->last_issue_time = gCurrentTicks;
+        ride.current_issues |= RIDE_ISSUE_GUESTS_STUCK;
+        ride.last_issue_time = gCurrentTicks;
 
         auto ft = Formatter();
-        ride->FormatNameTo(ft);
+        ride.FormatNameTo(ft);
         if (gConfigNotifications.RideWarnings)
         {
             News::AddItemToQueue(News::ItemType::Ride, STR_GUESTS_GETTING_STUCK_ON_RIDE, peep->CurrentRide.ToUnderlying(), ft);
@@ -3613,7 +3605,7 @@ void Guest::UpdateRideLeaveEntranceWaypoints(const Ride& ride)
     Guard::Assert(!station.Entrance.IsNull());
     uint8_t direction_entrance = station.Entrance.direction;
 
-    TileElement* tile_element = ride_get_station_start_track_element(&ride, CurrentRideStation);
+    TileElement* tile_element = ride_get_station_start_track_element(ride, CurrentRideStation);
 
     uint8_t direction_track = (tile_element == nullptr ? 0 : tile_element->GetDirection());
 
@@ -3697,7 +3689,7 @@ void Guest::UpdateRideAdvanceThroughEntrance()
         Guard::Assert(!entranceLocation.IsNull());
 
         const auto& rtd = GetRideTypeDescriptor(ride->type);
-        rtd.UpdateLeaveEntrance(this, ride, entranceLocation);
+        rtd.UpdateLeaveEntrance(this, *ride, entranceLocation);
         return;
     }
 
@@ -3772,14 +3764,14 @@ void Guest::UpdateRideAdvanceThroughEntrance()
  *
  *  rct2: 0x0069321D
  */
-static void peep_go_to_ride_exit(Peep* peep, Ride* ride, int16_t x, int16_t y, int16_t z, uint8_t exit_direction)
+static void peep_go_to_ride_exit(Peep* peep, const Ride& ride, int16_t x, int16_t y, int16_t z, uint8_t exit_direction)
 {
-    z += ride->GetRideTypeDescriptor().Heights.PlatformHeight;
+    z += ride.GetRideTypeDescriptor().Heights.PlatformHeight;
 
     peep->MoveTo({ x, y, z });
 
     Guard::Assert(peep->CurrentRideStation.ToUnderlying() < OpenRCT2::Limits::MaxStationsPerRide);
-    auto exit = ride->GetStation(peep->CurrentRideStation).Exit;
+    auto exit = ride.GetStation(peep->CurrentRideStation).Exit;
     Guard::Assert(!exit.IsNull());
     x = exit.x;
     y = exit.y;
@@ -3793,7 +3785,7 @@ static void peep_go_to_ride_exit(Peep* peep, Ride* ride, int16_t x, int16_t y, i
 
     int16_t shift_multiplier = 20;
 
-    rct_ride_entry* rideEntry = get_ride_entry(ride->subtype);
+    rct_ride_entry* rideEntry = get_ride_entry(ride.subtype);
     if (rideEntry != nullptr)
     {
         CarEntry* carEntry = &rideEntry->Cars[rideEntry->DefaultCar];
@@ -3819,7 +3811,7 @@ static void peep_go_to_ride_exit(Peep* peep, Ride* ride, int16_t x, int16_t y, i
  *
  *  rct2: 0x006920B4
  */
-void Guest::UpdateRideFreeVehicleEnterRide(Ride* ride)
+void Guest::UpdateRideFreeVehicleEnterRide(Ride& ride)
 {
     money16 ridePrice = ride_get_price(ride);
     if (ridePrice != 0)
@@ -3831,8 +3823,8 @@ void Guest::UpdateRideFreeVehicleEnterRide(Ride* ride)
         }
         else
         {
-            ride->total_profit += ridePrice;
-            ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+            ride.total_profit += ridePrice;
+            ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
             SpendMoney(PaidOnRides, ridePrice, ExpenditureType::ParkRideTickets);
         }
     }
@@ -3843,7 +3835,7 @@ void Guest::UpdateRideFreeVehicleEnterRide(Ride* ride)
         queueTime += 3;
 
     queueTime /= 2;
-    auto& station = ride->GetStation(CurrentRideStation);
+    auto& station = ride.GetStation(CurrentRideStation);
     if (queueTime != station.QueueTime)
     {
         station.QueueTime = queueTime;
@@ -3854,10 +3846,10 @@ void Guest::UpdateRideFreeVehicleEnterRide(Ride* ride)
     {
         auto ft = Formatter();
         FormatNameTo(ft);
-        ride->FormatNameTo(ft);
+        ride.FormatNameTo(ft);
 
         StringId msg_string;
-        if (ride->GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_IN_RIDE))
+        if (ride.GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_IN_RIDE))
             msg_string = STR_PEEP_TRACKING_PEEP_IS_IN_X;
         else
             msg_string = STR_PEEP_TRACKING_PEEP_IS_ON_X;
@@ -3868,7 +3860,7 @@ void Guest::UpdateRideFreeVehicleEnterRide(Ride* ride)
         }
     }
 
-    const auto& rtd = ride->GetRideTypeDescriptor();
+    const auto& rtd = ride.GetRideTypeDescriptor();
     if (rtd.HasFlag(RIDE_TYPE_FLAG_IS_SPIRAL_SLIDE))
     {
         SwitchToSpecialSprite(1);
@@ -3881,9 +3873,9 @@ void Guest::UpdateRideFreeVehicleEnterRide(Ride* ride)
  *
  *  rct2: 0x00691FD4
  */
-static void peep_update_ride_no_free_vehicle_rejoin_queue(Guest* peep, Ride* ride)
+static void peep_update_ride_no_free_vehicle_rejoin_queue(Guest* peep, Ride& ride)
 {
-    TileCoordsXYZD entranceLocation = ride->GetStation(peep->CurrentRideStation).Entrance;
+    TileCoordsXYZD entranceLocation = ride.GetStation(peep->CurrentRideStation).Entrance;
 
     int32_t x = entranceLocation.x * 32;
     int32_t y = entranceLocation.y * 32;
@@ -3894,7 +3886,7 @@ static void peep_update_ride_no_free_vehicle_rejoin_queue(Guest* peep, Ride* rid
     peep->SetState(PeepState::QueuingFront);
     peep->RideSubState = PeepRideSubState::AtEntrance;
 
-    ride->QueueInsertGuestAtFront(peep->CurrentRideStation, peep);
+    ride.QueueInsertGuestAtFront(peep->CurrentRideStation, peep);
 }
 
 /**
@@ -3916,11 +3908,11 @@ void Guest::UpdateRideFreeVehicleCheck()
     {
         if (ride->status != RideStatus::Open || ride->vehicle_change_timeout != 0 || (++RejoinQueueTimeout) == 0)
         {
-            peep_update_ride_no_free_vehicle_rejoin_queue(this, ride);
+            peep_update_ride_no_free_vehicle_rejoin_queue(this, *ride);
             return;
         }
 
-        UpdateRideFreeVehicleEnterRide(ride);
+        UpdateRideFreeVehicleEnterRide(*ride);
         return;
     }
 
@@ -3966,7 +3958,7 @@ void Guest::UpdateRideFreeVehicleCheck()
 
     if (!vehicle->IsUsedInPairs())
     {
-        UpdateRideFreeVehicleEnterRide(ride);
+        UpdateRideFreeVehicleEnterRide(*ride);
         return;
     }
 
@@ -3974,7 +3966,7 @@ void Guest::UpdateRideFreeVehicleCheck()
     {
         if (CurrentSeat & 1 || !(vehicle->next_free_seat & 1))
         {
-            UpdateRideFreeVehicleEnterRide(ride);
+            UpdateRideFreeVehicleEnterRide(*ride);
             return;
         }
     }
@@ -3983,7 +3975,7 @@ void Guest::UpdateRideFreeVehicleCheck()
         uint8_t seat = CurrentSeat | 1;
         if (seat < vehicle->next_free_seat)
         {
-            UpdateRideFreeVehicleEnterRide(ride);
+            UpdateRideFreeVehicleEnterRide(*ride);
             return;
         }
     }
@@ -4008,7 +4000,7 @@ void Guest::UpdateRideFreeVehicleCheck()
     vehicle->next_free_seat--;
     vehicle->peep[CurrentSeat] = EntityId::GetNull();
 
-    peep_update_ride_no_free_vehicle_rejoin_queue(this, ride);
+    peep_update_ride_no_free_vehicle_rejoin_queue(this, *ride);
 }
 
 void Guest::UpdateRideApproachVehicle()
@@ -4057,7 +4049,7 @@ void Guest::UpdateRideEnterVehicle()
                     seatedGuest->SetState(PeepState::OnRide);
                     seatedGuest->GuestTimeOnRide = 0;
                     seatedGuest->RideSubState = PeepRideSubState::OnRide;
-                    seatedGuest->OnEnterRide(ride);
+                    seatedGuest->OnEnterRide(*ride);
                 }
             }
 
@@ -4073,7 +4065,7 @@ void Guest::UpdateRideEnterVehicle()
 
             GuestTimeOnRide = 0;
             RideSubState = PeepRideSubState::OnRide;
-            OnEnterRide(ride);
+            OnEnterRide(*ride);
         }
     }
 }
@@ -4119,7 +4111,7 @@ void Guest::UpdateRideLeaveVehicle()
     if (ride_station.ToUnderlying() >= OpenRCT2::Limits::MaxStationsPerRide)
     {
         // HACK #5658: Some parks have hacked rides which end up in this state
-        auto bestStationIndex = ride_get_first_valid_station_exit(ride);
+        auto bestStationIndex = ride_get_first_valid_station_exit(*ride);
         if (bestStationIndex.IsNull())
         {
             bestStationIndex = StationIndex::FromUnderlying(0);
@@ -4206,7 +4198,7 @@ void Guest::UpdateRideLeaveVehicle()
             platformLocation.y = vehicle->y + yShift * shiftMultiplier;
 
             peep_go_to_ride_exit(
-                this, ride, platformLocation.x, platformLocation.y, platformLocation.z, platformLocation.direction);
+                this, *ride, platformLocation.x, platformLocation.y, platformLocation.z, platformLocation.direction);
             return;
         }
 
@@ -4244,14 +4236,14 @@ void Guest::UpdateRideLeaveVehicle()
         platformLocation.z = station.GetBaseZ();
 
         peep_go_to_ride_exit(
-            this, ride, platformLocation.x, platformLocation.y, platformLocation.z, platformLocation.direction);
+            this, *ride, platformLocation.x, platformLocation.y, platformLocation.z, platformLocation.direction);
         return;
     }
 
     auto exitLocation = station.Exit.ToCoordsXYZD();
     Guard::Assert(!exitLocation.IsNull());
 
-    TileElement* trackElement = ride_get_station_start_track_element(ride, CurrentRideStation);
+    TileElement* trackElement = ride_get_station_start_track_element(*ride, CurrentRideStation);
 
     Direction station_direction = (trackElement == nullptr ? 0 : trackElement->GetDirection());
 
@@ -4372,7 +4364,7 @@ void Guest::UpdateRideInExit()
     if (ride->lifecycle_flags & RIDE_LIFECYCLE_ON_RIDE_PHOTO)
     {
         ShopItem secondaryItem = ride->GetRideTypeDescriptor().PhotoItem;
-        if (DecideAndBuyItem(ride, secondaryItem, ride->price[1]))
+        if (DecideAndBuyItem(*ride, secondaryItem, ride->price[1]))
         {
             ride->no_secondary_items_sold++;
         }
@@ -4959,7 +4951,7 @@ void Guest::UpdateRideLeaveExit()
         return;
     }
 
-    OnExitRide(ride);
+    OnExitRide(*ride);
 
     if (ride != nullptr && (PeepFlags & PEEP_FLAGS_TRACKING))
     {
diff --git a/src/openrct2/entity/Guest.h b/src/openrct2/entity/Guest.h
index 7177be48b2..e49ff2ceda 100644
--- a/src/openrct2/entity/Guest.h
+++ b/src/openrct2/entity/Guest.h
@@ -327,25 +327,25 @@ public:
     bool HasDrink() const;
     bool HasFoodOrDrink() const;
     bool HasEmptyContainer() const;
-    void OnEnterRide(Ride* ride);
-    void OnExitRide(Ride* ride);
+    void OnEnterRide(Ride& ride);
+    void OnExitRide(Ride& ride);
     void UpdateSpriteType();
     bool HeadingForRideOrParkExit() const;
     void StopPurchaseThought(ride_type_t rideType);
     void TryGetUpFromSitting();
     bool ShouldRideWhileRaining(const Ride& ride);
-    void ChoseNotToGoOnRide(Ride* ride, bool peepAtRide, bool updateLastRide);
+    void ChoseNotToGoOnRide(const Ride& ride, bool peepAtRide, bool updateLastRide);
     void PickRideToGoOn();
     void ReadMap();
-    bool ShouldGoOnRide(Ride* ride, StationIndex entranceNum, bool atQueue, bool thinking);
-    bool ShouldGoToShop(Ride* ride, bool peepAtShop);
+    bool ShouldGoOnRide(Ride& ride, StationIndex entranceNum, bool atQueue, bool thinking);
+    bool ShouldGoToShop(Ride& ride, bool peepAtShop);
     bool ShouldFindBench();
     bool UpdateWalkingFindBench();
     bool UpdateWalkingFindBin();
     void SpendMoney(money16& peep_expend_type, money32 amount, ExpenditureType type);
     void SpendMoney(money32 amount, ExpenditureType type);
-    void SetHasRidden(const Ride* ride);
-    bool HasRidden(const Ride* ride) const;
+    void SetHasRidden(const Ride& ride);
+    bool HasRidden(const Ride& ride) const;
     void SetHasRiddenRideType(int32_t rideType);
     bool HasRiddenRideType(int32_t rideType) const;
     void SetParkEntryTime(int32_t entryTime);
@@ -353,7 +353,7 @@ public:
     void CheckIfLost();
     void CheckCantFindRide();
     void CheckCantFindExit();
-    bool DecideAndBuyItem(Ride* ride, ShopItem shopItem, money32 price);
+    bool DecideAndBuyItem(Ride& ride, ShopItem shopItem, money32 price);
     void SetSpriteType(PeepSpriteType new_sprite_type);
     void HandleEasterEggName();
     int32_t GetEasterEggNameId() const;
@@ -395,7 +395,7 @@ private:
     void UpdateRideLeaveEntranceWaypoints(const Ride& ride);
     uint8_t GetWaypointedSeatLocation(const Ride& ride, CarEntry* vehicle_type, uint8_t track_direction) const;
     void UpdateRideFreeVehicleCheck();
-    void UpdateRideFreeVehicleEnterRide(Ride* ride);
+    void UpdateRideFreeVehicleEnterRide(Ride& ride);
     void UpdateRideApproachVehicle();
     void UpdateRideEnterVehicle();
     void UpdateRideLeaveVehicle();
@@ -423,8 +423,8 @@ private:
     void GivePassingPeepsIceCream(Guest* passingPeep);
     Ride* FindBestRideToGoOn();
     OpenRCT2::BitSet<OpenRCT2::Limits::MaxRidesInPark> FindRidesToGoOn();
-    bool FindVehicleToEnter(Ride* ride, std::vector<uint8_t>& car_array);
-    void GoToRideEntrance(Ride* ride);
+    bool FindVehicleToEnter(const Ride& ride, std::vector<uint8_t>& car_array);
+    void GoToRideEntrance(const Ride& ride);
 };
 
 void UpdateRideApproachVehicleWaypointsMotionSimulator(Guest&, const CoordsXY&, int16_t&);
@@ -479,9 +479,9 @@ void increment_guests_heading_for_park();
 void decrement_guests_in_park();
 void decrement_guests_heading_for_park();
 
-void PeepUpdateRideLeaveEntranceMaze(Guest* peep, Ride* ride, CoordsXYZD& entrance_loc);
-void PeepUpdateRideLeaveEntranceSpiralSlide(Guest* peep, Ride* ride, CoordsXYZD& entrance_loc);
-void PeepUpdateRideLeaveEntranceDefault(Guest* peep, Ride* ride, CoordsXYZD& entrance_loc);
+void PeepUpdateRideLeaveEntranceMaze(Guest* peep, Ride& ride, CoordsXYZD& entrance_loc);
+void PeepUpdateRideLeaveEntranceSpiralSlide(Guest* peep, Ride& ride, CoordsXYZD& entrance_loc);
+void PeepUpdateRideLeaveEntranceDefault(Guest* peep, Ride& ride, CoordsXYZD& entrance_loc);
 
 CoordsXY GetGuestWaypointLocationDefault(const Vehicle& vehicle, const Ride& ride, const StationIndex& CurrentRideStation);
 CoordsXY GetGuestWaypointLocationEnterprise(const Vehicle& vehicle, const Ride& ride, const StationIndex& CurrentRideStation);
diff --git a/src/openrct2/entity/Peep.cpp b/src/openrct2/entity/Peep.cpp
index d443b52de9..c9290908bb 100644
--- a/src/openrct2/entity/Peep.cpp
+++ b/src/openrct2/entity/Peep.cpp
@@ -1769,7 +1769,7 @@ static bool peep_interact_with_entrance(Peep* peep, const CoordsXYE& coords, uin
         // Guest walks up to the ride for the first time since entering
         // the path tile or since considering another ride attached to
         // the path tile.
-        if (!guest->ShouldGoOnRide(ride, stationNum, false, false))
+        if (!guest->ShouldGoOnRide(*ride, stationNum, false, false))
         {
             // Peep remembers that this is the last ride they
             // considered while on this path tile.
@@ -2202,7 +2202,7 @@ static void peep_interact_with_path(Peep* peep, const CoordsXYE& coords)
                 /* Peep is approaching the entrance of a ride queue.
                  * Decide whether to go on the ride. */
                 auto ride = get_ride(rideIndex);
-                if (ride != nullptr && guest->ShouldGoOnRide(ride, stationNum, true, false))
+                if (ride != nullptr && guest->ShouldGoOnRide(*ride, stationNum, true, false))
                 {
                     // Peep has decided to go on the ride at the queue.
                     guest->InteractionRideIndex = rideIndex;
@@ -2312,7 +2312,7 @@ static bool peep_interact_with_shop(Peep* peep, const CoordsXYE& coords)
     if (ride->GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_PEEP_SHOULD_GO_INSIDE_FACILITY))
     {
         guest->TimeLost = 0;
-        if (!guest->ShouldGoOnRide(ride, StationIndex::FromUnderlying(0), false, false))
+        if (!guest->ShouldGoOnRide(*ride, StationIndex::FromUnderlying(0), false, false))
         {
             peep_return_to_centre_of_tile(guest);
             return true;
diff --git a/src/openrct2/entity/Staff.cpp b/src/openrct2/entity/Staff.cpp
index 7650b8d62b..6f329e1361 100644
--- a/src/openrct2/entity/Staff.cpp
+++ b/src/openrct2/entity/Staff.cpp
@@ -1954,26 +1954,26 @@ void Staff::UpdateFixing(int32_t steps)
         {
             case PEEP_FIXING_ENTER_STATION:
                 NextFlags &= ~PEEP_NEXT_FLAG_IS_SLOPED;
-                progressToNextSubstate = UpdateFixingEnterStation(ride);
+                progressToNextSubstate = UpdateFixingEnterStation(*ride);
                 break;
 
             case PEEP_FIXING_MOVE_TO_BROKEN_DOWN_VEHICLE:
-                progressToNextSubstate = UpdateFixingMoveToBrokenDownVehicle(firstRun, ride);
+                progressToNextSubstate = UpdateFixingMoveToBrokenDownVehicle(firstRun, *ride);
                 break;
 
             case PEEP_FIXING_FIX_VEHICLE_CLOSED_RESTRAINTS:
             case PEEP_FIXING_FIX_VEHICLE_CLOSED_DOORS:
             case PEEP_FIXING_FIX_VEHICLE_OPEN_RESTRAINTS:
             case PEEP_FIXING_FIX_VEHICLE_OPEN_DOORS:
-                progressToNextSubstate = UpdateFixingFixVehicle(firstRun, ride);
+                progressToNextSubstate = UpdateFixingFixVehicle(firstRun, *ride);
                 break;
 
             case PEEP_FIXING_FIX_VEHICLE_MALFUNCTION:
-                progressToNextSubstate = UpdateFixingFixVehicleMalfunction(firstRun, ride);
+                progressToNextSubstate = UpdateFixingFixVehicleMalfunction(firstRun, *ride);
                 break;
 
             case PEEP_FIXING_MOVE_TO_STATION_END:
-                progressToNextSubstate = UpdateFixingMoveToStationEnd(firstRun, ride);
+                progressToNextSubstate = UpdateFixingMoveToStationEnd(firstRun, *ride);
                 break;
 
             case PEEP_FIXING_FIX_STATION_END:
@@ -1981,27 +1981,27 @@ void Staff::UpdateFixing(int32_t steps)
                 break;
 
             case PEEP_FIXING_MOVE_TO_STATION_START:
-                progressToNextSubstate = UpdateFixingMoveToStationStart(firstRun, ride);
+                progressToNextSubstate = UpdateFixingMoveToStationStart(firstRun, *ride);
                 break;
 
             case PEEP_FIXING_FIX_STATION_START:
-                progressToNextSubstate = UpdateFixingFixStationStart(firstRun, ride);
+                progressToNextSubstate = UpdateFixingFixStationStart(firstRun, *ride);
                 break;
 
             case PEEP_FIXING_FIX_STATION_BRAKES:
-                progressToNextSubstate = UpdateFixingFixStationBrakes(firstRun, ride);
+                progressToNextSubstate = UpdateFixingFixStationBrakes(firstRun, *ride);
                 break;
 
             case PEEP_FIXING_MOVE_TO_STATION_EXIT:
-                progressToNextSubstate = UpdateFixingMoveToStationExit(firstRun, ride);
+                progressToNextSubstate = UpdateFixingMoveToStationExit(firstRun, *ride);
                 break;
 
             case PEEP_FIXING_FINISH_FIX_OR_INSPECT:
-                progressToNextSubstate = UpdateFixingFinishFixOrInspect(firstRun, steps, ride);
+                progressToNextSubstate = UpdateFixingFinishFixOrInspect(firstRun, steps, *ride);
                 break;
 
             case PEEP_FIXING_LEAVE_BY_ENTRANCE_EXIT:
-                progressToNextSubstate = UpdateFixingLeaveByEntranceExit(firstRun, ride);
+                progressToNextSubstate = UpdateFixingLeaveByEntranceExit(firstRun, *ride);
                 break;
 
             default:
@@ -2037,10 +2037,10 @@ void Staff::UpdateFixing(int32_t steps)
  * rct2: 0x006C0EEC
  * fixing SubState: enter_station - applies to fixing all break down reasons and ride inspections.
  */
-bool Staff::UpdateFixingEnterStation(Ride* ride) const
+bool Staff::UpdateFixingEnterStation(Ride& ride) const
 {
-    ride->mechanic_status = RIDE_MECHANIC_STATUS_FIXING;
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAINTENANCE;
+    ride.mechanic_status = RIDE_MECHANIC_STATUS_FIXING;
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAINTENANCE;
 
     return true;
 }
@@ -2050,7 +2050,7 @@ bool Staff::UpdateFixingEnterStation(Ride* ride) const
  * fixing SubState: move_to_broken_down_vehicle - applies to fixing all vehicle specific breakdown reasons
  * - see FixingSubstatesForBreakdown[]
  */
-bool Staff::UpdateFixingMoveToBrokenDownVehicle(bool firstRun, const Ride* ride)
+bool Staff::UpdateFixingMoveToBrokenDownVehicle(bool firstRun, const Ride& ride)
 {
     if (!firstRun)
     {
@@ -2103,7 +2103,7 @@ bool Staff::UpdateFixingMoveToBrokenDownVehicle(bool firstRun, const Ride* ride)
  * 4. doors stuck open.
  * - see FixingSubstatesForBreakdown[]
  */
-bool Staff::UpdateFixingFixVehicle(bool firstRun, const Ride* ride)
+bool Staff::UpdateFixingFixVehicle(bool firstRun, const Ride& ride)
 {
     if (!firstRun)
     {
@@ -2145,7 +2145,7 @@ bool Staff::UpdateFixingFixVehicle(bool firstRun, const Ride* ride)
  * fixing SubState: fix_vehicle_malfunction - applies fixing to vehicle malfunction.
  * - see FixingSubstatesForBreakdown[]
  */
-bool Staff::UpdateFixingFixVehicleMalfunction(bool firstRun, const Ride* ride)
+bool Staff::UpdateFixingFixVehicleMalfunction(bool firstRun, const Ride& ride)
 {
     if (!firstRun)
     {
@@ -2195,16 +2195,16 @@ static constexpr const CoordsXY _StationFixingOffsets[] = {
  * inspection.
  * - see FixingSubstatesForBreakdown[]
  */
-bool Staff::UpdateFixingMoveToStationEnd(bool firstRun, const Ride* ride)
+bool Staff::UpdateFixingMoveToStationEnd(bool firstRun, const Ride& ride)
 {
     if (!firstRun)
     {
-        if (ride->GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_HAS_SINGLE_PIECE_STATION | RIDE_TYPE_FLAG_HAS_NO_TRACK))
+        if (ride.GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_HAS_SINGLE_PIECE_STATION | RIDE_TYPE_FLAG_HAS_NO_TRACK))
         {
             return true;
         }
 
-        auto stationPos = ride->GetStation(CurrentRideStation).GetStart();
+        auto stationPos = ride.GetStation(CurrentRideStation).GetStart();
         if (stationPos.IsNull())
         {
             return true;
@@ -2281,16 +2281,16 @@ bool Staff::UpdateFixingFixStationEnd(bool firstRun)
  * 3. applies to inspection.
  * - see FixingSubstatesForBreakdown[]
  */
-bool Staff::UpdateFixingMoveToStationStart(bool firstRun, const Ride* ride)
+bool Staff::UpdateFixingMoveToStationStart(bool firstRun, const Ride& ride)
 {
     if (!firstRun)
     {
-        if (ride->GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_HAS_SINGLE_PIECE_STATION | RIDE_TYPE_FLAG_HAS_NO_TRACK))
+        if (ride.GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_HAS_SINGLE_PIECE_STATION | RIDE_TYPE_FLAG_HAS_NO_TRACK))
         {
             return true;
         }
 
-        auto stationPosition = ride->GetStation(CurrentRideStation).GetStart();
+        auto stationPosition = ride.GetStation(CurrentRideStation).GetStart();
         if (stationPosition.IsNull())
         {
             return true;
@@ -2357,11 +2357,11 @@ bool Staff::UpdateFixingMoveToStationStart(bool firstRun, const Ride* ride)
  * 2. applies to inspection.
  * - see FixingSubstatesForBreakdown[]
  */
-bool Staff::UpdateFixingFixStationStart(bool firstRun, const Ride* ride)
+bool Staff::UpdateFixingFixStationStart(bool firstRun, const Ride& ride)
 {
     if (!firstRun)
     {
-        if (ride->GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_HAS_SINGLE_PIECE_STATION | RIDE_TYPE_FLAG_HAS_NO_TRACK))
+        if (ride.GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_HAS_SINGLE_PIECE_STATION | RIDE_TYPE_FLAG_HAS_NO_TRACK))
         {
             return true;
         }
@@ -2390,7 +2390,7 @@ bool Staff::UpdateFixingFixStationStart(bool firstRun, const Ride* ride)
  * fixing SubState: fix_station_brakes - applies to fixing brake failure
  * - see FixingSubstatesForBreakdown[]
  */
-bool Staff::UpdateFixingFixStationBrakes(bool firstRun, Ride* ride)
+bool Staff::UpdateFixingFixStationBrakes(bool firstRun, Ride& ride)
 {
     if (!firstRun)
     {
@@ -2413,8 +2413,8 @@ bool Staff::UpdateFixingFixStationBrakes(bool firstRun, Ride* ride)
 
     if (ActionFrame == 0x28)
     {
-        ride->mechanic_status = RIDE_MECHANIC_STATUS_HAS_FIXED_STATION_BRAKES;
-        ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAINTENANCE;
+        ride.mechanic_status = RIDE_MECHANIC_STATUS_HAS_FIXED_STATION_BRAKES;
+        ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAINTENANCE;
     }
 
     if (ActionFrame == 0x13 || ActionFrame == 0x19 || ActionFrame == 0x1F || ActionFrame == 0x25 || ActionFrame == 0x2B)
@@ -2430,14 +2430,14 @@ bool Staff::UpdateFixingFixStationBrakes(bool firstRun, Ride* ride)
  * fixing SubState: move_to_station_exit - applies to fixing all failures & inspections
  * - see FixingSubstatesForBreakdown[]
  */
-bool Staff::UpdateFixingMoveToStationExit(bool firstRun, const Ride* ride)
+bool Staff::UpdateFixingMoveToStationExit(bool firstRun, const Ride& ride)
 {
     if (!firstRun)
     {
-        auto stationPosition = ride->GetStation(CurrentRideStation).Exit.ToCoordsXY();
+        auto stationPosition = ride.GetStation(CurrentRideStation).Exit.ToCoordsXY();
         if (stationPosition.IsNull())
         {
-            stationPosition = ride->GetStation(CurrentRideStation).Entrance.ToCoordsXY();
+            stationPosition = ride.GetStation(CurrentRideStation).Entrance.ToCoordsXY();
 
             if (stationPosition.IsNull())
             {
@@ -2468,7 +2468,7 @@ bool Staff::UpdateFixingMoveToStationExit(bool firstRun, const Ride* ride)
  * fixing SubState: finish_fix_or_inspect - applies to fixing all failures & inspections
  * - see FixingSubstatesForBreakdown[]
  */
-bool Staff::UpdateFixingFinishFixOrInspect(bool firstRun, int32_t steps, Ride* ride)
+bool Staff::UpdateFixingFinishFixOrInspect(bool firstRun, int32_t steps, Ride& ride)
 {
     if (!firstRun)
     {
@@ -2478,7 +2478,7 @@ bool Staff::UpdateFixingFinishFixOrInspect(bool firstRun, int32_t steps, Ride* r
 
             StaffRidesInspected++;
             WindowInvalidateFlags |= RIDE_INVALIDATE_RIDE_INCOME | RIDE_INVALIDATE_RIDE_LIST;
-            ride->mechanic_status = RIDE_MECHANIC_STATUS_UNDEFINED;
+            ride.mechanic_status = RIDE_MECHANIC_STATUS_UNDEFINED;
             return true;
         }
 
@@ -2501,7 +2501,7 @@ bool Staff::UpdateFixingFinishFixOrInspect(bool firstRun, int32_t steps, Ride* r
     }
 
     ride_fix_breakdown(ride, steps);
-    ride->mechanic_status = RIDE_MECHANIC_STATUS_UNDEFINED;
+    ride.mechanic_status = RIDE_MECHANIC_STATUS_UNDEFINED;
     return true;
 }
 
@@ -2510,14 +2510,14 @@ bool Staff::UpdateFixingFinishFixOrInspect(bool firstRun, int32_t steps, Ride* r
  * fixing SubState: leave_by_entrance_exit - applies to fixing all failures & inspections
  * - see FixingSubstatesForBreakdown[]
  */
-bool Staff::UpdateFixingLeaveByEntranceExit(bool firstRun, const Ride* ride)
+bool Staff::UpdateFixingLeaveByEntranceExit(bool firstRun, const Ride& ride)
 {
     if (!firstRun)
     {
-        auto exitPosition = ride->GetStation(CurrentRideStation).Exit.ToCoordsXY();
+        auto exitPosition = ride.GetStation(CurrentRideStation).Exit.ToCoordsXY();
         if (exitPosition.IsNull())
         {
-            exitPosition = ride->GetStation(CurrentRideStation).Entrance.ToCoordsXY();
+            exitPosition = ride.GetStation(CurrentRideStation).Entrance.ToCoordsXY();
 
             if (exitPosition.IsNull())
             {
@@ -2538,10 +2538,10 @@ bool Staff::UpdateFixingLeaveByEntranceExit(bool firstRun, const Ride* ride)
     int16_t xy_distance;
     if (auto loc = UpdateAction(xy_distance); loc.has_value())
     {
-        auto stationHeight = ride->GetStation(CurrentRideStation).GetBaseZ();
+        auto stationHeight = ride.GetStation(CurrentRideStation).GetBaseZ();
         if (xy_distance >= 16)
         {
-            stationHeight += ride->GetRideTypeDescriptor().Heights.PlatformHeight;
+            stationHeight += ride.GetRideTypeDescriptor().Heights.PlatformHeight;
         }
 
         MoveTo({ loc.value(), stationHeight });
diff --git a/src/openrct2/entity/Staff.h b/src/openrct2/entity/Staff.h
index 09458bc629..fb89783ed2 100644
--- a/src/openrct2/entity/Staff.h
+++ b/src/openrct2/entity/Staff.h
@@ -75,18 +75,18 @@ private:
     void UpdateWatering();
     void UpdateAnswering();
     void UpdateFixing(int32_t steps);
-    bool UpdateFixingEnterStation(Ride* ride) const;
-    bool UpdateFixingMoveToBrokenDownVehicle(bool firstRun, const Ride* ride);
-    bool UpdateFixingFixVehicle(bool firstRun, const Ride* ride);
-    bool UpdateFixingFixVehicleMalfunction(bool firstRun, const Ride* ride);
-    bool UpdateFixingMoveToStationEnd(bool firstRun, const Ride* ride);
+    bool UpdateFixingEnterStation(Ride& ride) const;
+    bool UpdateFixingMoveToBrokenDownVehicle(bool firstRun, const Ride& ride);
+    bool UpdateFixingFixVehicle(bool firstRun, const Ride& ride);
+    bool UpdateFixingFixVehicleMalfunction(bool firstRun, const Ride& ride);
+    bool UpdateFixingMoveToStationEnd(bool firstRun, const Ride& ride);
     bool UpdateFixingFixStationEnd(bool firstRun);
-    bool UpdateFixingMoveToStationStart(bool firstRun, const Ride* ride);
-    bool UpdateFixingFixStationStart(bool firstRun, const Ride* ride);
-    bool UpdateFixingFixStationBrakes(bool firstRun, Ride* ride);
-    bool UpdateFixingMoveToStationExit(bool firstRun, const Ride* ride);
-    bool UpdateFixingFinishFixOrInspect(bool firstRun, int32_t steps, Ride* ride);
-    bool UpdateFixingLeaveByEntranceExit(bool firstRun, const Ride* ride);
+    bool UpdateFixingMoveToStationStart(bool firstRun, const Ride& ride);
+    bool UpdateFixingFixStationStart(bool firstRun, const Ride& ride);
+    bool UpdateFixingFixStationBrakes(bool firstRun, Ride& ride);
+    bool UpdateFixingMoveToStationExit(bool firstRun, const Ride& ride);
+    bool UpdateFixingFinishFixOrInspect(bool firstRun, int32_t steps, Ride& ride);
+    bool UpdateFixingLeaveByEntranceExit(bool firstRun, const Ride& ride);
     void UpdateRideInspected(RideId rideIndex);
     void UpdateHeadingToInspect();
 
diff --git a/src/openrct2/interface/InteractiveConsole.cpp b/src/openrct2/interface/InteractiveConsole.cpp
index 3b41c136ee..da695bd6b5 100644
--- a/src/openrct2/interface/InteractiveConsole.cpp
+++ b/src/openrct2/interface/InteractiveConsole.cpp
@@ -242,7 +242,7 @@ static int32_t cc_rides(InteractiveConsole& console, const arguments_t& argv)
                     else
                     {
                         ride->mode = static_cast<RideMode>(mode & 0xFF);
-                        invalidate_test_results(ride);
+                        invalidate_test_results(*ride);
                     }
                 }
             }
diff --git a/src/openrct2/management/Award.cpp b/src/openrct2/management/Award.cpp
index 28af4c8c71..56cebe2d72 100644
--- a/src/openrct2/management/Award.cpp
+++ b/src/openrct2/management/Award.cpp
@@ -415,7 +415,7 @@ static bool award_is_deserved_most_disappointing(int32_t activeAwardTypes)
     auto disappointingRides = 0;
     for (const auto& ride : GetRideManager())
     {
-        if (ride_has_ratings(&ride) && ride.popularity != 0xFF)
+        if (ride_has_ratings(ride) && ride.popularity != 0xFF)
         {
             countedRides++;
             if (ride.popularity <= 6)
diff --git a/src/openrct2/ride/Ride.cpp b/src/openrct2/ride/Ride.cpp
index bf6ffe9498..8397e888e0 100644
--- a/src/openrct2/ride/Ride.cpp
+++ b/src/openrct2/ride/Ride.cpp
@@ -104,16 +104,16 @@ struct StationIndexWithMessage
 
 // Static function declarations
 Staff* find_closest_mechanic(const CoordsXY& entrancePosition, int32_t forInspection);
-static void ride_breakdown_status_update(Ride* ride);
-static void ride_breakdown_update(Ride* ride);
-static void ride_call_closest_mechanic(Ride* ride);
-static void ride_call_mechanic(Ride* ride, Peep* mechanic, int32_t forInspection);
-static void ride_entrance_exit_connected(Ride* ride);
-static int32_t ride_get_new_breakdown_problem(Ride* ride);
-static void ride_inspection_update(Ride* ride);
-static void ride_mechanic_status_update(Ride* ride, int32_t mechanicStatus);
-static void RideMusicUpdate(Ride* ride);
-static void ride_shop_connected(Ride* ride);
+static void ride_breakdown_status_update(Ride& ride);
+static void ride_breakdown_update(Ride& ride);
+static void ride_call_closest_mechanic(Ride& ride);
+static void ride_call_mechanic(Ride& ride, Peep* mechanic, int32_t forInspection);
+static void ride_entrance_exit_connected(Ride& ride);
+static int32_t ride_get_new_breakdown_problem(const Ride& ride);
+static void ride_inspection_update(Ride& ride);
+static void ride_mechanic_status_update(Ride& ride, int32_t mechanicStatus);
+static void RideMusicUpdate(Ride& ride);
+static void ride_shop_connected(const Ride& ride);
 
 RideManager GetRideManager()
 {
@@ -373,8 +373,8 @@ money64 Ride::CalculateIncomePerHour() const
     {
         return 0;
     }
-    auto customersPerHour = ride_customers_per_hour(this);
-    money64 priceMinusCost = ride_get_price(this);
+    auto customersPerHour = ride_customers_per_hour(*this);
+    money64 priceMinusCost = ride_get_price(*this);
 
     ShopItem currentShopItem = entry->shop_item[0];
     if (currentShopItem != ShopItem::None)
@@ -421,7 +421,7 @@ money64 Ride::CalculateIncomePerHour() const
  * dl ride index
  * esi result map element
  */
-bool ride_try_get_origin_element(const Ride* ride, CoordsXYE* output)
+bool ride_try_get_origin_element(const Ride& ride, CoordsXYE* output)
 {
     TileElement* resultTileElement = nullptr;
 
@@ -431,7 +431,7 @@ bool ride_try_get_origin_element(const Ride* ride, CoordsXYE* output)
     {
         if (it.element->GetType() != TileElementType::Track)
             continue;
-        if (it.element->AsTrack()->GetRideIndex() != ride->id)
+        if (it.element->AsTrack()->GetRideIndex() != ride.id)
             continue;
 
         // Found a track piece for target ride
@@ -474,7 +474,7 @@ bool ride_try_get_origin_element(const Ride* ride, CoordsXYE* output)
  * on the first element of a track block
  */
 bool track_block_get_next_from_zero(
-    const CoordsXYZ& startPos, Ride* ride, uint8_t direction_start, CoordsXYE* output, int32_t* z, int32_t* direction,
+    const CoordsXYZ& startPos, const Ride& ride, uint8_t direction_start, CoordsXYE* output, int32_t* z, int32_t* direction,
     bool isGhost)
 {
     auto trackPos = startPos;
@@ -498,7 +498,7 @@ bool track_block_get_next_from_zero(
         if (trackElement == nullptr)
             continue;
 
-        if (trackElement->GetRideIndex() != ride->id)
+        if (trackElement->GetRideIndex() != ride.id)
             continue;
 
         if (trackElement->GetSequenceIndex() != 0)
@@ -582,7 +582,7 @@ bool track_block_get_next(CoordsXYE* input, CoordsXYE* output, int32_t* z, int32
     uint8_t directionStart = ((trackCoordinate.rotation_end + rotation) & TILE_ELEMENT_DIRECTION_MASK)
         | (trackCoordinate.rotation_end & TRACK_BLOCK_2);
 
-    return track_block_get_next_from_zero({ coords, OriginZ }, ride, directionStart, output, z, direction, false);
+    return track_block_get_next_from_zero({ coords, OriginZ }, *ride, directionStart, output, z, direction, false);
 }
 
 /**
@@ -594,7 +594,7 @@ bool track_block_get_next(CoordsXYE* input, CoordsXYE* output, int32_t* z, int32
  *  rct2: 0x006C63D6
  */
 bool track_block_get_previous_from_zero(
-    const CoordsXYZ& startPos, Ride* ride, uint8_t direction, track_begin_end* outTrackBeginEnd)
+    const CoordsXYZ& startPos, const Ride& ride, uint8_t direction, track_begin_end* outTrackBeginEnd)
 {
     uint8_t directionStart = direction;
     direction = DirectionReverse(direction);
@@ -621,7 +621,7 @@ bool track_block_get_previous_from_zero(
         if (trackElement == nullptr)
             continue;
 
-        if (trackElement->GetRideIndex() != ride->id)
+        if (trackElement->GetRideIndex() != ride.id)
             continue;
 
         const auto* ted = &GetTrackElementDescriptor(trackElement->GetTrackType());
@@ -721,7 +721,7 @@ bool track_block_get_previous(const CoordsXYE& trackPos, track_begin_end* outTra
     rotation = ((trackCoordinate.rotation_begin + rotation) & TILE_ELEMENT_DIRECTION_MASK)
         | (trackCoordinate.rotation_begin & TRACK_BLOCK_2);
 
-    return track_block_get_previous_from_zero({ coords, z }, ride, rotation, outTrackBeginEnd);
+    return track_block_get_previous_from_zero({ coords, z }, *ride, rotation, outTrackBeginEnd);
 }
 
 /**
@@ -975,7 +975,7 @@ std::unique_ptr<TrackDesign> Ride::SaveToTrackDesign(TrackDesignState& tds) cons
         return nullptr;
     }
 
-    if (!ride_has_ratings(this))
+    if (!ride_has_ratings(*this))
     {
         ContextShowError(STR_CANT_SAVE_TRACK_DESIGN, STR_NONE, {});
         return nullptr;
@@ -1032,13 +1032,13 @@ void Ride::Update()
     if (vehicle_change_timeout != 0)
         vehicle_change_timeout--;
 
-    RideMusicUpdate(this);
+    RideMusicUpdate(*this);
 
     // Update stations
     const auto& rtd = GetRideTypeDescriptor();
     if (!rtd.HasFlag(RIDE_TYPE_FLAG_IS_MAZE))
         for (StationIndex::UnderlyingType i = 0; i < OpenRCT2::Limits::MaxStationsPerRide; i++)
-            ride_update_station(this, StationIndex::FromUnderlying(i));
+            ride_update_station(*this, StationIndex::FromUnderlying(i));
 
     // Update financial statistics
     num_customers_timeout++;
@@ -1069,7 +1069,7 @@ void Ride::Update()
     if (rtd.RideUpdate != nullptr)
         rtd.RideUpdate(*this);
 
-    ride_breakdown_update(this);
+    ride_breakdown_update(*this);
 
     // Various things include news messages
     if (lifecycle_flags & (RIDE_LIFECYCLE_BREAKDOWN_PENDING | RIDE_LIFECYCLE_BROKEN_DOWN | RIDE_LIFECYCLE_DUE_INSPECTION))
@@ -1079,10 +1079,10 @@ void Ride::Update()
         // for identical balance with vanilla.
         const auto updatingRideByte = static_cast<uint8_t>((gCurrentTicks / 2) & 0xFF);
         if (updatingRideByte == static_cast<uint8_t>(id.ToUnderlying()))
-            ride_breakdown_status_update(this);
+            ride_breakdown_status_update(*this);
     }
 
-    ride_inspection_update(this);
+    ride_inspection_update(*this);
 
     // If ride is simulating but crashed, reset the vehicles
     if (status == RideStatus::Simulating && (lifecycle_flags & RIDE_LIFECYCLE_CRASHED))
@@ -1229,7 +1229,7 @@ void UpdateSpiralSlide(Ride& ride)
 
         auto startLoc = ride.stations[i].Start;
 
-        TileElement* tileElement = ride_get_station_start_track_element(&ride, StationIndex::FromUnderlying(i));
+        TileElement* tileElement = ride_get_station_start_track_element(ride, StationIndex::FromUnderlying(i));
         if (tileElement == nullptr)
             continue;
 
@@ -1259,64 +1259,64 @@ static uint8_t _breakdownProblemProbabilities[] = {
  *
  *  rct2: 0x006AC7C2
  */
-static void ride_inspection_update(Ride* ride)
+static void ride_inspection_update(Ride& ride)
 {
     if (gCurrentTicks & 2047)
         return;
     if (gScreenFlags & SCREEN_FLAGS_TRACK_DESIGNER)
         return;
 
-    ride->last_inspection++;
-    if (ride->last_inspection == 0)
-        ride->last_inspection--;
+    ride.last_inspection++;
+    if (ride.last_inspection == 0)
+        ride.last_inspection--;
 
-    int32_t inspectionIntervalMinutes = RideInspectionInterval[ride->inspection_interval];
+    int32_t inspectionIntervalMinutes = RideInspectionInterval[ride.inspection_interval];
     // An inspection interval of 0 minutes means the ride is set to never be inspected.
     if (inspectionIntervalMinutes == 0)
     {
-        ride->lifecycle_flags &= ~RIDE_LIFECYCLE_DUE_INSPECTION;
+        ride.lifecycle_flags &= ~RIDE_LIFECYCLE_DUE_INSPECTION;
         return;
     }
 
-    if (ride->GetRideTypeDescriptor().AvailableBreakdowns == 0)
+    if (ride.GetRideTypeDescriptor().AvailableBreakdowns == 0)
         return;
 
-    if (inspectionIntervalMinutes > ride->last_inspection)
+    if (inspectionIntervalMinutes > ride.last_inspection)
         return;
 
-    if (ride->lifecycle_flags
+    if (ride.lifecycle_flags
         & (RIDE_LIFECYCLE_BREAKDOWN_PENDING | RIDE_LIFECYCLE_BROKEN_DOWN | RIDE_LIFECYCLE_DUE_INSPECTION
            | RIDE_LIFECYCLE_CRASHED))
         return;
 
     // Inspect the first station that has an exit
-    ride->lifecycle_flags |= RIDE_LIFECYCLE_DUE_INSPECTION;
-    ride->mechanic_status = RIDE_MECHANIC_STATUS_CALLING;
+    ride.lifecycle_flags |= RIDE_LIFECYCLE_DUE_INSPECTION;
+    ride.mechanic_status = RIDE_MECHANIC_STATUS_CALLING;
 
     auto stationIndex = ride_get_first_valid_station_exit(ride);
-    ride->inspection_station = (!stationIndex.IsNull()) ? stationIndex : StationIndex::FromUnderlying(0);
+    ride.inspection_station = (!stationIndex.IsNull()) ? stationIndex : StationIndex::FromUnderlying(0);
 }
 
-static int32_t get_age_penalty(Ride* ride)
+static int32_t get_age_penalty(const Ride& ride)
 {
-    auto years = date_get_year(ride->GetAge());
+    auto years = date_get_year(ride.GetAge());
     switch (years)
     {
         case 0:
             return 0;
         case 1:
-            return ride->unreliability_factor / 8;
+            return ride.unreliability_factor / 8;
         case 2:
-            return ride->unreliability_factor / 4;
+            return ride.unreliability_factor / 4;
         case 3:
         case 4:
-            return ride->unreliability_factor / 2;
+            return ride.unreliability_factor / 2;
         case 5:
         case 6:
         case 7:
-            return ride->unreliability_factor;
+            return ride.unreliability_factor;
         default:
-            return ride->unreliability_factor * 2;
+            return ride.unreliability_factor * 2;
     }
 }
 
@@ -1324,7 +1324,7 @@ static int32_t get_age_penalty(Ride* ride)
  *
  *  rct2: 0x006AC622
  */
-static void ride_breakdown_update(Ride* ride)
+static void ride_breakdown_update(Ride& ride)
 {
     if (gCurrentTicks & 255)
         return;
@@ -1332,8 +1332,8 @@ static void ride_breakdown_update(Ride* ride)
     if (gScreenFlags & SCREEN_FLAGS_TRACK_DESIGNER)
         return;
 
-    if (ride->lifecycle_flags & (RIDE_LIFECYCLE_BROKEN_DOWN | RIDE_LIFECYCLE_CRASHED))
-        ride->downtime_history[0]++;
+    if (ride.lifecycle_flags & (RIDE_LIFECYCLE_BROKEN_DOWN | RIDE_LIFECYCLE_CRASHED))
+        ride.downtime_history[0]++;
 
     if (!(gCurrentTicks & 8191))
     {
@@ -1341,35 +1341,35 @@ static void ride_breakdown_update(Ride* ride)
 
         for (int32_t i = 0; i < OpenRCT2::Limits::DowntimeHistorySize; i++)
         {
-            totalDowntime += ride->downtime_history[i];
+            totalDowntime += ride.downtime_history[i];
         }
 
-        ride->downtime = std::min(totalDowntime / 2, 100);
+        ride.downtime = std::min(totalDowntime / 2, 100);
 
         for (int32_t i = OpenRCT2::Limits::DowntimeHistorySize - 1; i > 0; i--)
         {
-            ride->downtime_history[i] = ride->downtime_history[i - 1];
+            ride.downtime_history[i] = ride.downtime_history[i - 1];
         }
-        ride->downtime_history[0] = 0;
+        ride.downtime_history[0] = 0;
 
-        ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAINTENANCE;
+        ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAINTENANCE;
     }
 
-    if (ride->lifecycle_flags & (RIDE_LIFECYCLE_BREAKDOWN_PENDING | RIDE_LIFECYCLE_BROKEN_DOWN | RIDE_LIFECYCLE_CRASHED))
+    if (ride.lifecycle_flags & (RIDE_LIFECYCLE_BREAKDOWN_PENDING | RIDE_LIFECYCLE_BROKEN_DOWN | RIDE_LIFECYCLE_CRASHED))
         return;
-    if (ride->status == RideStatus::Closed || ride->status == RideStatus::Simulating)
+    if (ride.status == RideStatus::Closed || ride.status == RideStatus::Simulating)
         return;
 
-    if (!ride->CanBreakDown())
+    if (!ride.CanBreakDown())
     {
-        ride->reliability = RIDE_INITIAL_RELIABILITY;
+        ride.reliability = RIDE_INITIAL_RELIABILITY;
         return;
     }
 
     // Calculate breakdown probability?
-    int32_t unreliabilityAccumulator = ride->unreliability_factor + get_age_penalty(ride);
-    ride->reliability = static_cast<uint16_t>(std::max(0, (ride->reliability - unreliabilityAccumulator)));
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAINTENANCE;
+    int32_t unreliabilityAccumulator = ride.unreliability_factor + get_age_penalty(ride);
+    ride.reliability = static_cast<uint16_t>(std::max(0, (ride.reliability - unreliabilityAccumulator)));
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAINTENANCE;
 
     // Random probability of a breakdown. Roughly this is 1 in
     //
@@ -1377,8 +1377,8 @@ static void ride_breakdown_update(Ride* ride)
     //
     // a 0.8% chance, less the breakdown factor which accumulates as the game
     // continues.
-    if ((ride->reliability == 0
-         || static_cast<int32_t>(scenario_rand() & 0x2FFFFF) <= 1 + RIDE_INITIAL_RELIABILITY - ride->reliability)
+    if ((ride.reliability == 0
+         || static_cast<int32_t>(scenario_rand() & 0x2FFFFF) <= 1 + RIDE_INITIAL_RELIABILITY - ride.reliability)
         && !gCheatsDisableAllBreakdowns)
     {
         int32_t breakdownReason = ride_get_new_breakdown_problem(ride);
@@ -1391,17 +1391,17 @@ static void ride_breakdown_update(Ride* ride)
  *
  *  rct2: 0x006B7294
  */
-static int32_t ride_get_new_breakdown_problem(Ride* ride)
+static int32_t ride_get_new_breakdown_problem(const Ride& ride)
 {
     int32_t availableBreakdownProblems, totalProbability, randomProbability, problemBits, breakdownProblem;
 
     // Brake failure is more likely when it's raining
     _breakdownProblemProbabilities[BREAKDOWN_BRAKES_FAILURE] = ClimateIsRaining() ? 20 : 3;
 
-    if (!ride->CanBreakDown())
+    if (!ride.CanBreakDown())
         return -1;
 
-    availableBreakdownProblems = ride->GetRideTypeDescriptor().AvailableBreakdowns;
+    availableBreakdownProblems = ride.GetRideTypeDescriptor().AvailableBreakdowns;
 
     // Calculate the total probability range for all possible breakdown problems
     totalProbability = 0;
@@ -1433,16 +1433,16 @@ static int32_t ride_get_new_breakdown_problem(Ride* ride)
     // Brakes failure can not happen if block brakes are used (so long as there is more than one vehicle)
     // However if this is the case, brake failure should be taken out the equation, otherwise block brake
     // rides have a lower probability to break down due to a random implementation reason.
-    if (ride->IsBlockSectioned())
-        if (ride->NumTrains != 1)
+    if (ride.IsBlockSectioned())
+        if (ride.NumTrains != 1)
             return -1;
 
     // If brakes failure is disabled, also take it out of the equation (see above comment why)
     if (gCheatsDisableBrakesFailure)
         return -1;
 
-    auto monthsOld = ride->GetAge();
-    if (monthsOld < 16 || ride->reliability_percentage > 50)
+    auto monthsOld = ride.GetAge();
+    if (monthsOld < 16 || ride.reliability_percentage > 50)
         return -1;
 
     return BREAKDOWN_BRAKES_FAILURE;
@@ -1459,19 +1459,19 @@ bool Ride::CanBreakDown() const
     return entry != nullptr && !(entry->flags & RIDE_ENTRY_FLAG_CANNOT_BREAK_DOWN);
 }
 
-static void choose_random_train_to_breakdown_safe(Ride* ride)
+static void choose_random_train_to_breakdown_safe(Ride& ride)
 {
     // Prevent integer division by zero in case of hacked ride.
-    if (ride->NumTrains == 0)
+    if (ride.NumTrains == 0)
         return;
 
-    ride->broken_vehicle = scenario_rand() % ride->NumTrains;
+    ride.broken_vehicle = scenario_rand() % ride.NumTrains;
 
     // Prevent crash caused by accessing SPRITE_INDEX_NULL on hacked rides.
     // This should probably be cleaned up on import instead.
-    while (ride->vehicles[ride->broken_vehicle].IsNull() && ride->broken_vehicle != 0)
+    while (ride.vehicles[ride.broken_vehicle].IsNull() && ride.broken_vehicle != 0)
     {
-        --ride->broken_vehicle;
+        --ride.broken_vehicle;
     }
 }
 
@@ -1479,20 +1479,20 @@ static void choose_random_train_to_breakdown_safe(Ride* ride)
  *
  *  rct2: 0x006B7348
  */
-void ride_prepare_breakdown(Ride* ride, int32_t breakdownReason)
+void ride_prepare_breakdown(Ride& ride, int32_t breakdownReason)
 {
     StationIndex i;
     Vehicle* vehicle;
 
-    if (ride->lifecycle_flags & (RIDE_LIFECYCLE_BREAKDOWN_PENDING | RIDE_LIFECYCLE_BROKEN_DOWN | RIDE_LIFECYCLE_CRASHED))
+    if (ride.lifecycle_flags & (RIDE_LIFECYCLE_BREAKDOWN_PENDING | RIDE_LIFECYCLE_BROKEN_DOWN | RIDE_LIFECYCLE_CRASHED))
         return;
 
-    ride->lifecycle_flags |= RIDE_LIFECYCLE_BREAKDOWN_PENDING;
+    ride.lifecycle_flags |= RIDE_LIFECYCLE_BREAKDOWN_PENDING;
 
-    ride->breakdown_reason_pending = breakdownReason;
-    ride->breakdown_sound_modifier = 0;
-    ride->not_fixed_timeout = 0;
-    ride->inspection_station = StationIndex::FromUnderlying(0); // ensure set to something.
+    ride.breakdown_reason_pending = breakdownReason;
+    ride.breakdown_sound_modifier = 0;
+    ride.not_fixed_timeout = 0;
+    ride.inspection_station = StationIndex::FromUnderlying(0); // ensure set to something.
 
     switch (breakdownReason)
     {
@@ -1502,7 +1502,7 @@ void ride_prepare_breakdown(Ride* ride, int32_t breakdownReason)
             i = ride_get_first_valid_station_exit(ride);
             if (!i.IsNull())
             {
-                ride->inspection_station = i;
+                ride.inspection_station = i;
             }
 
             break;
@@ -1512,15 +1512,15 @@ void ride_prepare_breakdown(Ride* ride, int32_t breakdownReason)
         case BREAKDOWN_DOORS_STUCK_OPEN:
             // Choose a random train and car
             choose_random_train_to_breakdown_safe(ride);
-            if (ride->num_cars_per_train != 0)
+            if (ride.num_cars_per_train != 0)
             {
-                ride->broken_car = scenario_rand() % ride->num_cars_per_train;
+                ride.broken_car = scenario_rand() % ride.num_cars_per_train;
 
                 // Set flag on broken car
-                vehicle = GetEntity<Vehicle>(ride->vehicles[ride->broken_vehicle]);
+                vehicle = GetEntity<Vehicle>(ride.vehicles[ride.broken_vehicle]);
                 if (vehicle != nullptr)
                 {
-                    vehicle = vehicle->GetCar(ride->broken_car);
+                    vehicle = vehicle->GetCar(ride.broken_car);
                 }
                 if (vehicle != nullptr)
                 {
@@ -1531,10 +1531,10 @@ void ride_prepare_breakdown(Ride* ride, int32_t breakdownReason)
         case BREAKDOWN_VEHICLE_MALFUNCTION:
             // Choose a random train
             choose_random_train_to_breakdown_safe(ride);
-            ride->broken_car = 0;
+            ride.broken_car = 0;
 
             // Set flag on broken train, first car
-            vehicle = GetEntity<Vehicle>(ride->vehicles[ride->broken_vehicle]);
+            vehicle = GetEntity<Vehicle>(ride.vehicles[ride.broken_vehicle]);
             if (vehicle != nullptr)
             {
                 vehicle->SetUpdateFlag(VEHICLE_UPDATE_FLAG_BROKEN_TRAIN);
@@ -1546,7 +1546,7 @@ void ride_prepare_breakdown(Ride* ride, int32_t breakdownReason)
             i = ride_get_first_valid_station_exit(ride);
             if (!i.IsNull())
             {
-                ride->inspection_station = i;
+                ride.inspection_station = i;
             }
             break;
     }
@@ -1556,13 +1556,13 @@ void ride_prepare_breakdown(Ride* ride, int32_t breakdownReason)
  *
  *  rct2: 0x006B74FA
  */
-void ride_breakdown_add_news_item(Ride* ride)
+void ride_breakdown_add_news_item(const Ride& ride)
 {
     if (gConfigNotifications.RideBrokenDown)
     {
         Formatter ft;
-        ride->FormatNameTo(ft);
-        News::AddItemToQueue(News::ItemType::Ride, STR_RIDE_IS_BROKEN_DOWN, ride->id.ToUnderlying(), ft);
+        ride.FormatNameTo(ft);
+        News::AddItemToQueue(News::ItemType::Ride, STR_RIDE_IS_BROKEN_DOWN, ride.id.ToUnderlying(), ft);
     }
 }
 
@@ -1570,67 +1570,67 @@ void ride_breakdown_add_news_item(Ride* ride)
  *
  *  rct2: 0x006B75C8
  */
-static void ride_breakdown_status_update(Ride* ride)
+static void ride_breakdown_status_update(Ride& ride)
 {
     // Warn player if ride hasn't been fixed for ages
-    if (ride->lifecycle_flags & RIDE_LIFECYCLE_BROKEN_DOWN)
+    if (ride.lifecycle_flags & RIDE_LIFECYCLE_BROKEN_DOWN)
     {
-        ride->not_fixed_timeout++;
+        ride.not_fixed_timeout++;
         // When there has been a full 255 timeout ticks this
         // will force timeout ticks to keep issuing news every
         // 16 ticks. Note there is no reason to do this.
-        if (ride->not_fixed_timeout == 0)
-            ride->not_fixed_timeout -= 16;
+        if (ride.not_fixed_timeout == 0)
+            ride.not_fixed_timeout -= 16;
 
-        if (!(ride->not_fixed_timeout & 15) && ride->mechanic_status != RIDE_MECHANIC_STATUS_FIXING
-            && ride->mechanic_status != RIDE_MECHANIC_STATUS_HAS_FIXED_STATION_BRAKES)
+        if (!(ride.not_fixed_timeout & 15) && ride.mechanic_status != RIDE_MECHANIC_STATUS_FIXING
+            && ride.mechanic_status != RIDE_MECHANIC_STATUS_HAS_FIXED_STATION_BRAKES)
         {
             if (gConfigNotifications.RideWarnings)
             {
                 Formatter ft;
-                ride->FormatNameTo(ft);
-                News::AddItemToQueue(News::ItemType::Ride, STR_RIDE_IS_STILL_NOT_FIXED, ride->id.ToUnderlying(), ft);
+                ride.FormatNameTo(ft);
+                News::AddItemToQueue(News::ItemType::Ride, STR_RIDE_IS_STILL_NOT_FIXED, ride.id.ToUnderlying(), ft);
             }
         }
     }
 
-    ride_mechanic_status_update(ride, ride->mechanic_status);
+    ride_mechanic_status_update(ride, ride.mechanic_status);
 }
 
 /**
  *
  *  rct2: 0x006B762F
  */
-static void ride_mechanic_status_update(Ride* ride, int32_t mechanicStatus)
+static void ride_mechanic_status_update(Ride& ride, int32_t mechanicStatus)
 {
     // Turn a pending breakdown into a breakdown.
     if ((mechanicStatus == RIDE_MECHANIC_STATUS_UNDEFINED || mechanicStatus == RIDE_MECHANIC_STATUS_CALLING
          || mechanicStatus == RIDE_MECHANIC_STATUS_HEADING)
-        && (ride->lifecycle_flags & RIDE_LIFECYCLE_BREAKDOWN_PENDING) && !(ride->lifecycle_flags & RIDE_LIFECYCLE_BROKEN_DOWN))
+        && (ride.lifecycle_flags & RIDE_LIFECYCLE_BREAKDOWN_PENDING) && !(ride.lifecycle_flags & RIDE_LIFECYCLE_BROKEN_DOWN))
     {
-        auto breakdownReason = ride->breakdown_reason_pending;
+        auto breakdownReason = ride.breakdown_reason_pending;
         if (breakdownReason == BREAKDOWN_SAFETY_CUT_OUT || breakdownReason == BREAKDOWN_BRAKES_FAILURE
             || breakdownReason == BREAKDOWN_CONTROL_FAILURE)
         {
-            ride->lifecycle_flags |= RIDE_LIFECYCLE_BROKEN_DOWN;
-            ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAINTENANCE | RIDE_INVALIDATE_RIDE_LIST
+            ride.lifecycle_flags |= RIDE_LIFECYCLE_BROKEN_DOWN;
+            ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAINTENANCE | RIDE_INVALIDATE_RIDE_LIST
                 | RIDE_INVALIDATE_RIDE_MAIN;
-            ride->breakdown_reason = breakdownReason;
+            ride.breakdown_reason = breakdownReason;
             ride_breakdown_add_news_item(ride);
         }
     }
     switch (mechanicStatus)
     {
         case RIDE_MECHANIC_STATUS_UNDEFINED:
-            if (ride->lifecycle_flags & RIDE_LIFECYCLE_BROKEN_DOWN)
+            if (ride.lifecycle_flags & RIDE_LIFECYCLE_BROKEN_DOWN)
             {
-                ride->mechanic_status = RIDE_MECHANIC_STATUS_CALLING;
+                ride.mechanic_status = RIDE_MECHANIC_STATUS_CALLING;
             }
             break;
         case RIDE_MECHANIC_STATUS_CALLING:
-            if (ride->GetRideTypeDescriptor().AvailableBreakdowns == 0)
+            if (ride.GetRideTypeDescriptor().AvailableBreakdowns == 0)
             {
-                ride->lifecycle_flags &= ~(
+                ride.lifecycle_flags &= ~(
                     RIDE_LIFECYCLE_BREAKDOWN_PENDING | RIDE_LIFECYCLE_BROKEN_DOWN | RIDE_LIFECYCLE_DUE_INSPECTION);
                 break;
             }
@@ -1640,13 +1640,13 @@ static void ride_mechanic_status_update(Ride* ride, int32_t mechanicStatus)
         case RIDE_MECHANIC_STATUS_HEADING:
         {
             auto mechanic = ride_get_mechanic(ride);
-            bool rideNeedsRepair = (ride->lifecycle_flags & (RIDE_LIFECYCLE_BREAKDOWN_PENDING | RIDE_LIFECYCLE_BROKEN_DOWN));
+            bool rideNeedsRepair = (ride.lifecycle_flags & (RIDE_LIFECYCLE_BREAKDOWN_PENDING | RIDE_LIFECYCLE_BROKEN_DOWN));
             if (mechanic == nullptr
                 || (mechanic->State != PeepState::HeadingToInspection && mechanic->State != PeepState::Answering)
-                || mechanic->CurrentRide != ride->id)
+                || mechanic->CurrentRide != ride.id)
             {
-                ride->mechanic_status = RIDE_MECHANIC_STATUS_CALLING;
-                ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAINTENANCE;
+                ride.mechanic_status = RIDE_MECHANIC_STATUS_CALLING;
+                ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAINTENANCE;
                 ride_mechanic_status_update(ride, RIDE_MECHANIC_STATUS_CALLING);
             }
             // if the ride is broken down, but a mechanic was heading for an inspection, update orders to fix
@@ -1665,8 +1665,8 @@ static void ride_mechanic_status_update(Ride* ride, int32_t mechanicStatus)
                 || (mechanic->State != PeepState::HeadingToInspection && mechanic->State != PeepState::Fixing
                     && mechanic->State != PeepState::Inspecting && mechanic->State != PeepState::Answering))
             {
-                ride->mechanic_status = RIDE_MECHANIC_STATUS_CALLING;
-                ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAINTENANCE;
+                ride.mechanic_status = RIDE_MECHANIC_STATUS_CALLING;
+                ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAINTENANCE;
                 ride_mechanic_status_update(ride, RIDE_MECHANIC_STATUS_CALLING);
             }
             break;
@@ -1678,33 +1678,33 @@ static void ride_mechanic_status_update(Ride* ride, int32_t mechanicStatus)
  *
  *  rct2: 0x006B796C
  */
-static void ride_call_mechanic(Ride* ride, Peep* mechanic, int32_t forInspection)
+static void ride_call_mechanic(Ride& ride, Peep* mechanic, int32_t forInspection)
 {
     mechanic->SetState(forInspection ? PeepState::HeadingToInspection : PeepState::Answering);
     mechanic->SubState = 0;
-    ride->mechanic_status = RIDE_MECHANIC_STATUS_HEADING;
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAINTENANCE;
-    ride->mechanic = mechanic->sprite_index;
-    mechanic->CurrentRide = ride->id;
-    mechanic->CurrentRideStation = ride->inspection_station;
+    ride.mechanic_status = RIDE_MECHANIC_STATUS_HEADING;
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAINTENANCE;
+    ride.mechanic = mechanic->sprite_index;
+    mechanic->CurrentRide = ride.id;
+    mechanic->CurrentRideStation = ride.inspection_station;
 }
 
 /**
  *
  *  rct2: 0x006B76AB
  */
-static void ride_call_closest_mechanic(Ride* ride)
+static void ride_call_closest_mechanic(Ride& ride)
 {
-    auto forInspection = (ride->lifecycle_flags & (RIDE_LIFECYCLE_BREAKDOWN_PENDING | RIDE_LIFECYCLE_BROKEN_DOWN)) == 0;
+    auto forInspection = (ride.lifecycle_flags & (RIDE_LIFECYCLE_BREAKDOWN_PENDING | RIDE_LIFECYCLE_BROKEN_DOWN)) == 0;
     auto mechanic = ride_find_closest_mechanic(ride, forInspection);
     if (mechanic != nullptr)
         ride_call_mechanic(ride, mechanic, forInspection);
 }
 
-Staff* ride_find_closest_mechanic(Ride* ride, int32_t forInspection)
+Staff* ride_find_closest_mechanic(const Ride& ride, int32_t forInspection)
 {
     // Get either exit position or entrance position if there is no exit
-    auto& station = ride->GetStation(ride->inspection_station);
+    auto& station = ride.GetStation(ride.inspection_station);
     TileCoordsXYZD location = station.Exit;
     if (location.IsNull())
     {
@@ -1779,9 +1779,9 @@ Staff* find_closest_mechanic(const CoordsXY& entrancePosition, int32_t forInspec
     return closestMechanic;
 }
 
-Staff* ride_get_mechanic(Ride* ride)
+Staff* ride_get_mechanic(const Ride& ride)
 {
-    auto staff = GetEntity<Staff>(ride->mechanic);
+    auto staff = GetEntity<Staff>(ride.mechanic);
     if (staff != nullptr && staff->IsMechanic())
     {
         return staff;
@@ -1789,12 +1789,12 @@ Staff* ride_get_mechanic(Ride* ride)
     return nullptr;
 }
 
-Staff* ride_get_assigned_mechanic(Ride* ride)
+Staff* ride_get_assigned_mechanic(const Ride& ride)
 {
-    if (ride->lifecycle_flags & RIDE_LIFECYCLE_BROKEN_DOWN)
+    if (ride.lifecycle_flags & RIDE_LIFECYCLE_BROKEN_DOWN)
     {
-        if (ride->mechanic_status == RIDE_MECHANIC_STATUS_HEADING || ride->mechanic_status == RIDE_MECHANIC_STATUS_FIXING
-            || ride->mechanic_status == RIDE_MECHANIC_STATUS_HAS_FIXED_STATION_BRAKES)
+        if (ride.mechanic_status == RIDE_MECHANIC_STATUS_HEADING || ride.mechanic_status == RIDE_MECHANIC_STATUS_FIXING
+            || ride.mechanic_status == RIDE_MECHANIC_STATUS_HAS_FIXED_STATION_BRAKES)
         {
             return ride_get_mechanic(ride);
         }
@@ -1811,15 +1811,15 @@ Staff* ride_get_assigned_mechanic(Ride* ride)
  *
  *  Calculates the sample rate for ride music.
  */
-static int32_t RideMusicSampleRate(Ride* ride)
+static int32_t RideMusicSampleRate(const Ride& ride)
 {
     int32_t sampleRate = 22050;
 
     // Alter sample rate for a power cut effect
-    if (ride->lifecycle_flags & (RIDE_LIFECYCLE_BREAKDOWN_PENDING | RIDE_LIFECYCLE_BROKEN_DOWN))
+    if (ride.lifecycle_flags & (RIDE_LIFECYCLE_BREAKDOWN_PENDING | RIDE_LIFECYCLE_BROKEN_DOWN))
     {
-        sampleRate = ride->breakdown_sound_modifier * 70;
-        if (ride->breakdown_reason_pending != BREAKDOWN_CONTROL_FAILURE)
+        sampleRate = ride.breakdown_sound_modifier * 70;
+        if (ride.breakdown_reason_pending != BREAKDOWN_CONTROL_FAILURE)
             sampleRate *= -1;
         sampleRate += 22050;
     }
@@ -1831,30 +1831,29 @@ static int32_t RideMusicSampleRate(Ride* ride)
  *
  *  Ride music slows down upon breaking. If it's completely broken, no music should play.
  */
-static bool RideMusicBreakdownEffect(Ride* ride)
+static bool RideMusicBreakdownEffect(Ride& ride)
 {
     // Oscillate parameters for a power cut effect when breaking down
-    if (ride->lifecycle_flags & (RIDE_LIFECYCLE_BREAKDOWN_PENDING | RIDE_LIFECYCLE_BROKEN_DOWN))
+    if (ride.lifecycle_flags & (RIDE_LIFECYCLE_BREAKDOWN_PENDING | RIDE_LIFECYCLE_BROKEN_DOWN))
     {
-        if (ride->breakdown_reason_pending == BREAKDOWN_CONTROL_FAILURE)
+        if (ride.breakdown_reason_pending == BREAKDOWN_CONTROL_FAILURE)
         {
             if (!(gCurrentTicks & 7))
-                if (ride->breakdown_sound_modifier != 255)
-                    ride->breakdown_sound_modifier++;
+                if (ride.breakdown_sound_modifier != 255)
+                    ride.breakdown_sound_modifier++;
         }
         else
         {
-            if ((ride->lifecycle_flags & RIDE_LIFECYCLE_BROKEN_DOWN)
-                || ride->breakdown_reason_pending == BREAKDOWN_BRAKES_FAILURE
-                || ride->breakdown_reason_pending == BREAKDOWN_CONTROL_FAILURE)
+            if ((ride.lifecycle_flags & RIDE_LIFECYCLE_BROKEN_DOWN) || ride.breakdown_reason_pending == BREAKDOWN_BRAKES_FAILURE
+                || ride.breakdown_reason_pending == BREAKDOWN_CONTROL_FAILURE)
             {
-                if (ride->breakdown_sound_modifier != 255)
-                    ride->breakdown_sound_modifier++;
+                if (ride.breakdown_sound_modifier != 255)
+                    ride.breakdown_sound_modifier++;
             }
 
-            if (ride->breakdown_sound_modifier == 255)
+            if (ride.breakdown_sound_modifier == 255)
             {
-                ride->music_tune_id = TUNE_ID_NULL;
+                ride.music_tune_id = TUNE_ID_NULL;
                 return true;
             }
         }
@@ -1866,13 +1865,13 @@ static bool RideMusicBreakdownEffect(Ride* ride)
  *
  *  Circus music is a sound effect, rather than music. Needs separate processing.
  */
-void CircusMusicUpdate(Ride* ride)
+void CircusMusicUpdate(Ride& ride)
 {
-    Vehicle* vehicle = GetEntity<Vehicle>(ride->vehicles[0]);
+    Vehicle* vehicle = GetEntity<Vehicle>(ride.vehicles[0]);
     if (vehicle == nullptr || vehicle->status != Vehicle::Status::DoingCircusShow)
     {
-        ride->music_position = 0;
-        ride->music_tune_id = TUNE_ID_NULL;
+        ride.music_position = 0;
+        ride.music_tune_id = TUNE_ID_NULL;
         return;
     }
 
@@ -1881,22 +1880,22 @@ void CircusMusicUpdate(Ride* ride)
         return;
     }
 
-    CoordsXYZ rideCoords = ride->GetStation().GetStart().ToTileCentre();
+    CoordsXYZ rideCoords = ride.GetStation().GetStart().ToTileCentre();
 
     const auto sampleRate = RideMusicSampleRate(ride);
 
-    OpenRCT2::RideAudio::UpdateMusicInstance(*ride, rideCoords, sampleRate);
+    OpenRCT2::RideAudio::UpdateMusicInstance(ride, rideCoords, sampleRate);
 }
 
 /**
  *
  *  rct2: 0x006ABE85
  */
-void DefaultMusicUpdate(Ride* ride)
+void DefaultMusicUpdate(Ride& ride)
 {
-    if (ride->status != RideStatus::Open || !(ride->lifecycle_flags & RIDE_LIFECYCLE_MUSIC))
+    if (ride.status != RideStatus::Open || !(ride.lifecycle_flags & RIDE_LIFECYCLE_MUSIC))
     {
-        ride->music_tune_id = TUNE_ID_NULL;
+        ride.music_tune_id = TUNE_ID_NULL;
         return;
     }
 
@@ -1906,29 +1905,29 @@ void DefaultMusicUpdate(Ride* ride)
     }
 
     // Select random tune from available tunes for a music style (of course only merry-go-rounds have more than one tune)
-    if (ride->music_tune_id == TUNE_ID_NULL)
+    if (ride.music_tune_id == TUNE_ID_NULL)
     {
         auto& objManager = GetContext()->GetObjectManager();
-        auto musicObj = static_cast<MusicObject*>(objManager.GetLoadedObject(ObjectType::Music, ride->music));
+        auto musicObj = static_cast<MusicObject*>(objManager.GetLoadedObject(ObjectType::Music, ride.music));
         if (musicObj != nullptr)
         {
             auto numTracks = musicObj->GetTrackCount();
-            ride->music_tune_id = static_cast<uint8_t>(util_rand() % numTracks);
-            ride->music_position = 0;
+            ride.music_tune_id = static_cast<uint8_t>(util_rand() % numTracks);
+            ride.music_position = 0;
         }
         return;
     }
 
-    CoordsXYZ rideCoords = ride->GetStation().GetStart().ToTileCentre();
+    CoordsXYZ rideCoords = ride.GetStation().GetStart().ToTileCentre();
 
     int32_t sampleRate = RideMusicSampleRate(ride);
 
-    OpenRCT2::RideAudio::UpdateMusicInstance(*ride, rideCoords, sampleRate);
+    OpenRCT2::RideAudio::UpdateMusicInstance(ride, rideCoords, sampleRate);
 }
 
-static void RideMusicUpdate(Ride* ride)
+static void RideMusicUpdate(Ride& ride)
 {
-    const auto& rtd = ride->GetRideTypeDescriptor();
+    const auto& rtd = ride.GetRideTypeDescriptor();
 
     if (!rtd.HasFlag(RIDE_TYPE_FLAG_MUSIC_ON_DEFAULT) && !rtd.HasFlag(RIDE_TYPE_FLAG_ALLOW_MUSIC))
         return;
@@ -2127,11 +2126,11 @@ std::pair<RideMeasurement*, OpenRCT2String> Ride::GetMeasurement()
 
 #pragma region Colour functions
 
-VehicleColour ride_get_vehicle_colour(Ride* ride, int32_t vehicleIndex)
+VehicleColour ride_get_vehicle_colour(const Ride& ride, int32_t vehicleIndex)
 {
     // Prevent indexing array out of bounds
     vehicleIndex = std::min<int32_t>(vehicleIndex, OpenRCT2::Limits::MaxCarsPerTrain);
-    return ride->vehicle_colours[vehicleIndex];
+    return ride.vehicle_colours[vehicleIndex];
 }
 
 static bool RideTypeVehicleColourExists(ObjectEntryIndex subType, const VehicleColour& vehicleColour)
@@ -2184,28 +2183,28 @@ int32_t ride_get_unused_preset_vehicle_colour(ObjectEntryIndex subType)
  *
  *  rct2: 0x006DE52C
  */
-void ride_set_vehicle_colours_to_random_preset(Ride* ride, uint8_t preset_index)
+void ride_set_vehicle_colours_to_random_preset(Ride& ride, uint8_t preset_index)
 {
-    rct_ride_entry* rideEntry = get_ride_entry(ride->subtype);
+    rct_ride_entry* rideEntry = get_ride_entry(ride.subtype);
     vehicle_colour_preset_list* presetList = rideEntry->vehicle_preset_list;
 
     if (presetList->count != 0 && presetList->count != 255)
     {
         assert(preset_index < presetList->count);
 
-        ride->colour_scheme_type = RIDE_COLOUR_SCHEME_MODE_ALL_SAME;
+        ride.colour_scheme_type = RIDE_COLOUR_SCHEME_MODE_ALL_SAME;
         VehicleColour* preset = &presetList->list[preset_index];
-        ride->vehicle_colours[0] = *preset;
+        ride.vehicle_colours[0] = *preset;
     }
     else
     {
-        ride->colour_scheme_type = RIDE_COLOUR_SCHEME_MODE_DIFFERENT_PER_TRAIN;
+        ride.colour_scheme_type = RIDE_COLOUR_SCHEME_MODE_DIFFERENT_PER_TRAIN;
         uint32_t count = presetList->count;
         for (uint32_t i = 0; i < count; i++)
         {
             auto index = i % static_cast<uint8_t>(32);
             VehicleColour* preset = &presetList->list[index];
-            ride->vehicle_colours[i] = *preset;
+            ride.vehicle_colours[i] = *preset;
         }
     }
 }
@@ -2228,9 +2227,9 @@ void ride_check_all_reachable()
             continue;
 
         if (ride.GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_IS_SHOP_OR_FACILITY))
-            ride_shop_connected(&ride);
+            ride_shop_connected(ride);
         else
-            ride_entrance_exit_connected(&ride);
+            ride_entrance_exit_connected(ride);
     }
 }
 
@@ -2250,9 +2249,9 @@ static bool ride_entrance_exit_is_reachable(const TileCoordsXYZD& coordinates)
     return MapCoordIsConnected(loc, coordinates.direction);
 }
 
-static void ride_entrance_exit_connected(Ride* ride)
+static void ride_entrance_exit_connected(Ride& ride)
 {
-    for (auto& station : ride->GetStations())
+    for (auto& station : ride.GetStations())
     {
         auto station_start = station.Start;
         auto entrance = station.Entrance;
@@ -2264,31 +2263,31 @@ static void ride_entrance_exit_connected(Ride* ride)
         {
             // name of ride is parameter of the format string
             Formatter ft;
-            ride->FormatNameTo(ft);
+            ride.FormatNameTo(ft);
             if (gConfigNotifications.RideWarnings)
             {
-                News::AddItemToQueue(News::ItemType::Ride, STR_ENTRANCE_NOT_CONNECTED, ride->id.ToUnderlying(), ft);
+                News::AddItemToQueue(News::ItemType::Ride, STR_ENTRANCE_NOT_CONNECTED, ride.id.ToUnderlying(), ft);
             }
-            ride->connected_message_throttle = 3;
+            ride.connected_message_throttle = 3;
         }
 
         if (!exit.IsNull() && !ride_entrance_exit_is_reachable(exit))
         {
             // name of ride is parameter of the format string
             Formatter ft;
-            ride->FormatNameTo(ft);
+            ride.FormatNameTo(ft);
             if (gConfigNotifications.RideWarnings)
             {
-                News::AddItemToQueue(News::ItemType::Ride, STR_EXIT_NOT_CONNECTED, ride->id.ToUnderlying(), ft);
+                News::AddItemToQueue(News::ItemType::Ride, STR_EXIT_NOT_CONNECTED, ride.id.ToUnderlying(), ft);
             }
-            ride->connected_message_throttle = 3;
+            ride.connected_message_throttle = 3;
         }
     }
 }
 
-static void ride_shop_connected(Ride* ride)
+static void ride_shop_connected(const Ride& ride)
 {
-    auto shopLoc = TileCoordsXY(ride->GetStation().Start);
+    auto shopLoc = TileCoordsXY(ride.GetStation().Start);
     if (shopLoc.IsNull())
         return;
 
@@ -2298,7 +2297,7 @@ static void ride_shop_connected(Ride* ride)
     {
         if (tileElement == nullptr)
             break;
-        if (tileElement->GetType() == TileElementType::Track && tileElement->AsTrack()->GetRideIndex() == ride->id)
+        if (tileElement->GetType() == TileElementType::Track && tileElement->AsTrack()->GetRideIndex() == ride.id)
         {
             trackElement = tileElement->AsTrack();
             break;
@@ -2309,8 +2308,8 @@ static void ride_shop_connected(Ride* ride)
         return;
 
     auto track_type = trackElement->GetTrackType();
-    ride = get_ride(trackElement->GetRideIndex());
-    if (ride == nullptr)
+    auto ride2 = get_ride(trackElement->GetRideIndex());
+    if (ride2 == nullptr)
     {
         return;
     }
@@ -2347,11 +2346,11 @@ static void ride_shop_connected(Ride* ride)
     if (gConfigNotifications.RideWarnings)
     {
         Formatter ft;
-        ride->FormatNameTo(ft);
-        News::AddItemToQueue(News::ItemType::Ride, STR_ENTRANCE_NOT_CONNECTED, ride->id.ToUnderlying(), ft);
+        ride2->FormatNameTo(ft);
+        News::AddItemToQueue(News::ItemType::Ride, STR_ENTRANCE_NOT_CONNECTED, ride2->id.ToUnderlying(), ft);
     }
 
-    ride->connected_message_throttle = 3;
+    ride2->connected_message_throttle = 3;
 }
 
 #pragma endregion
@@ -2511,10 +2510,10 @@ void ride_set_map_tooltip(TileElement* tileElement)
  *
  *  rct2: 0x006B4CC1
  */
-static ResultWithMessage ride_mode_check_valid_station_numbers(Ride* ride)
+static ResultWithMessage ride_mode_check_valid_station_numbers(const Ride& ride)
 {
     uint16_t numStations = 0;
-    for (const auto& station : ride->GetStations())
+    for (const auto& station : ride.GetStations())
     {
         if (!station.Start.IsNull())
         {
@@ -2522,7 +2521,7 @@ static ResultWithMessage ride_mode_check_valid_station_numbers(Ride* ride)
         }
     }
 
-    switch (ride->mode)
+    switch (ride.mode)
     {
         case RideMode::ReverseInclineLaunchedShuttle:
         case RideMode::PoweredLaunchPasstrough:
@@ -2542,7 +2541,7 @@ static ResultWithMessage ride_mode_check_valid_station_numbers(Ride* ride)
         }
     }
 
-    const auto& rtd = ride->GetRideTypeDescriptor();
+    const auto& rtd = ride.GetRideTypeDescriptor();
     if (rtd.HasFlag(RIDE_TYPE_FLAG_HAS_ONE_STATION) && numStations > 1)
         return { false, STR_UNABLE_TO_OPERATE_WITH_MORE_THAN_ONE_STATION_IN_THIS_MODE };
 
@@ -2553,16 +2552,16 @@ static ResultWithMessage ride_mode_check_valid_station_numbers(Ride* ride)
  * returns stationIndex of first station on success
  * STATION_INDEX_NULL on failure.
  */
-static StationIndexWithMessage ride_mode_check_station_present(Ride* ride)
+static StationIndexWithMessage ride_mode_check_station_present(const Ride& ride)
 {
     auto stationIndex = ride_get_first_valid_station_start(ride);
 
     if (stationIndex.IsNull())
     {
-        if (ride->GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_HAS_NO_TRACK))
+        if (ride.GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_HAS_NO_TRACK))
             return { StationIndex::GetNull(), STR_NOT_YET_CONSTRUCTED };
 
-        const auto& rtd = ride->GetRideTypeDescriptor();
+        const auto& rtd = ride.GetRideTypeDescriptor();
         if (rtd.HasFlag(RIDE_TYPE_FLAG_IS_MAZE))
             return { StationIndex::GetNull(), STR_NOT_YET_CONSTRUCTED };
 
@@ -3384,9 +3383,9 @@ static bool vehicle_create_trains(RideId rideIndex, const CoordsXYZ& trainsPos,
  *
  *  rct2: 0x006DDE9E
  */
-static void ride_create_vehicles_find_first_block(Ride* ride, CoordsXYE* outXYElement)
+static void ride_create_vehicles_find_first_block(const Ride& ride, CoordsXYE* outXYElement)
 {
-    Vehicle* vehicle = GetEntity<Vehicle>(ride->vehicles[0]);
+    Vehicle* vehicle = GetEntity<Vehicle>(ride.vehicles[0]);
     if (vehicle == nullptr)
         return;
 
@@ -3508,7 +3507,7 @@ ResultWithMessage Ride::CreateVehicles(const CoordsXYE& element, bool isApplying
         if (IsBlockSectioned())
         {
             CoordsXYE firstBlock{};
-            ride_create_vehicles_find_first_block(this, &firstBlock);
+            ride_create_vehicles_find_first_block(*this, &firstBlock);
             MoveTrainsToBlockBrakes(firstBlock.element->AsTrack());
         }
         else
@@ -3532,7 +3531,7 @@ ResultWithMessage Ride::CreateVehicles(const CoordsXYE& element, bool isApplying
             }
         }
     }
-    ride_update_vehicle_colours(this);
+    ride_update_vehicle_colours(*this);
     return { true };
 }
 
@@ -3601,11 +3600,11 @@ void Ride::MoveTrainsToBlockBrakes(TrackElement* firstBlock)
  * appropriate track.
  *  rct2: 0x006D31A6
  */
-static ResultWithMessage ride_initialise_cable_lift_track(Ride* ride, bool isApplying)
+static ResultWithMessage ride_initialise_cable_lift_track(const Ride& ride, bool isApplying)
 {
     CoordsXYZ location;
     location.SetNull();
-    for (const auto& station : ride->GetStations())
+    for (const auto& station : ride.GetStations())
     {
         location = station.GetStart();
         if (!location.IsNull())
@@ -3724,7 +3723,7 @@ static ResultWithMessage ride_create_cable_lift(RideId rideIndex, bool isApplyin
         return { false, STR_UNABLE_TO_CREATE_ENOUGH_VEHICLES };
     }
 
-    auto cableLiftInitialiseResult = ride_initialise_cable_lift_track(ride, isApplying);
+    auto cableLiftInitialiseResult = ride_initialise_cable_lift_track(*ride, isApplying);
     if (!cableLiftInitialiseResult.Successful)
     {
         return { false, cableLiftInitialiseResult.Message };
@@ -3819,7 +3818,7 @@ void Ride::ConstructMissingEntranceOrExit() const
         window_scroll_to_location(*w, location);
 
         CoordsXYE trackElement;
-        ride_try_get_origin_element(this, &trackElement);
+        ride_try_get_origin_element(*this, &trackElement);
         FindTrackGap(trackElement, &trackElement);
         int32_t ok = ride_modify(trackElement);
         if (ok == 0)
@@ -4114,7 +4113,7 @@ bool Ride::NameExists(std::string_view name, RideId excludeRideId)
             Formatter ft;
             ride.FormatNameTo(ft);
             format_string(buffer, 256, STR_STRINGID, ft.Data());
-            if (name == buffer && ride_has_any_track_elements(&ride))
+            if (name == buffer && ride_has_any_track_elements(ride))
             {
                 return true;
             }
@@ -4183,11 +4182,11 @@ void Ride::SetColourPreset(uint8_t index)
     colour_scheme_type = 0;
 }
 
-money32 ride_get_common_price(Ride* forRide)
+money32 ride_get_common_price(const Ride& forRide)
 {
     for (const auto& ride : GetRideManager())
     {
-        if (ride.type == forRide->type && &ride != forRide)
+        if (ride.type == forRide.type && ride.id != forRide.id)
         {
             return ride.price[0];
         }
@@ -4239,19 +4238,19 @@ RideNaming get_ride_naming(const ride_type_t rideType, rct_ride_entry* rideEntry
  * if by some miracle you manage 4 element none sloped.
  */
 
-void increment_turn_count_1_element(Ride* ride, uint8_t type)
+void increment_turn_count_1_element(Ride& ride, uint8_t type)
 {
     uint16_t* turn_count;
     switch (type)
     {
         case 0:
-            turn_count = &ride->turn_count_default;
+            turn_count = &ride.turn_count_default;
             break;
         case 1:
-            turn_count = &ride->turn_count_banked;
+            turn_count = &ride.turn_count_banked;
             break;
         case 2:
-            turn_count = &ride->turn_count_sloped;
+            turn_count = &ride.turn_count_sloped;
             break;
         default:
             return;
@@ -4264,19 +4263,19 @@ void increment_turn_count_1_element(Ride* ride, uint8_t type)
     *turn_count |= value;
 }
 
-void increment_turn_count_2_elements(Ride* ride, uint8_t type)
+void increment_turn_count_2_elements(Ride& ride, uint8_t type)
 {
     uint16_t* turn_count;
     switch (type)
     {
         case 0:
-            turn_count = &ride->turn_count_default;
+            turn_count = &ride.turn_count_default;
             break;
         case 1:
-            turn_count = &ride->turn_count_banked;
+            turn_count = &ride.turn_count_banked;
             break;
         case 2:
-            turn_count = &ride->turn_count_sloped;
+            turn_count = &ride.turn_count_sloped;
             break;
         default:
             return;
@@ -4289,19 +4288,19 @@ void increment_turn_count_2_elements(Ride* ride, uint8_t type)
     *turn_count |= value;
 }
 
-void increment_turn_count_3_elements(Ride* ride, uint8_t type)
+void increment_turn_count_3_elements(Ride& ride, uint8_t type)
 {
     uint16_t* turn_count;
     switch (type)
     {
         case 0:
-            turn_count = &ride->turn_count_default;
+            turn_count = &ride.turn_count_default;
             break;
         case 1:
-            turn_count = &ride->turn_count_banked;
+            turn_count = &ride.turn_count_banked;
             break;
         case 2:
-            turn_count = &ride->turn_count_sloped;
+            turn_count = &ride.turn_count_sloped;
             break;
         default:
             return;
@@ -4314,7 +4313,7 @@ void increment_turn_count_3_elements(Ride* ride, uint8_t type)
     *turn_count |= value;
 }
 
-void increment_turn_count_4_plus_elements(Ride* ride, uint8_t type)
+void increment_turn_count_4_plus_elements(Ride& ride, uint8_t type)
 {
     uint16_t* turn_count;
     switch (type)
@@ -4325,7 +4324,7 @@ void increment_turn_count_4_plus_elements(Ride* ride, uint8_t type)
             increment_turn_count_3_elements(ride, type);
             return;
         case 2:
-            turn_count = &ride->turn_count_sloped;
+            turn_count = &ride.turn_count_sloped;
             break;
         default:
             return;
@@ -4338,19 +4337,19 @@ void increment_turn_count_4_plus_elements(Ride* ride, uint8_t type)
     *turn_count |= value;
 }
 
-int32_t get_turn_count_1_element(Ride* ride, uint8_t type)
+int32_t get_turn_count_1_element(const Ride& ride, uint8_t type)
 {
-    uint16_t* turn_count;
+    const uint16_t* turn_count;
     switch (type)
     {
         case 0:
-            turn_count = &ride->turn_count_default;
+            turn_count = &ride.turn_count_default;
             break;
         case 1:
-            turn_count = &ride->turn_count_banked;
+            turn_count = &ride.turn_count_banked;
             break;
         case 2:
-            turn_count = &ride->turn_count_sloped;
+            turn_count = &ride.turn_count_sloped;
             break;
         default:
             return 0;
@@ -4359,19 +4358,19 @@ int32_t get_turn_count_1_element(Ride* ride, uint8_t type)
     return (*turn_count) & TURN_MASK_1_ELEMENT;
 }
 
-int32_t get_turn_count_2_elements(Ride* ride, uint8_t type)
+int32_t get_turn_count_2_elements(const Ride& ride, uint8_t type)
 {
-    uint16_t* turn_count;
+    const uint16_t* turn_count;
     switch (type)
     {
         case 0:
-            turn_count = &ride->turn_count_default;
+            turn_count = &ride.turn_count_default;
             break;
         case 1:
-            turn_count = &ride->turn_count_banked;
+            turn_count = &ride.turn_count_banked;
             break;
         case 2:
-            turn_count = &ride->turn_count_sloped;
+            turn_count = &ride.turn_count_sloped;
             break;
         default:
             return 0;
@@ -4380,19 +4379,19 @@ int32_t get_turn_count_2_elements(Ride* ride, uint8_t type)
     return ((*turn_count) & TURN_MASK_2_ELEMENTS) >> 5;
 }
 
-int32_t get_turn_count_3_elements(Ride* ride, uint8_t type)
+int32_t get_turn_count_3_elements(const Ride& ride, uint8_t type)
 {
-    uint16_t* turn_count;
+    const uint16_t* turn_count;
     switch (type)
     {
         case 0:
-            turn_count = &ride->turn_count_default;
+            turn_count = &ride.turn_count_default;
             break;
         case 1:
-            turn_count = &ride->turn_count_banked;
+            turn_count = &ride.turn_count_banked;
             break;
         case 2:
-            turn_count = &ride->turn_count_sloped;
+            turn_count = &ride.turn_count_sloped;
             break;
         default:
             return 0;
@@ -4401,16 +4400,16 @@ int32_t get_turn_count_3_elements(Ride* ride, uint8_t type)
     return ((*turn_count) & TURN_MASK_3_ELEMENTS) >> 8;
 }
 
-int32_t get_turn_count_4_plus_elements(Ride* ride, uint8_t type)
+int32_t get_turn_count_4_plus_elements(const Ride& ride, uint8_t type)
 {
-    uint16_t* turn_count;
+    const uint16_t* turn_count;
     switch (type)
     {
         case 0:
         case 1:
             return 0;
         case 2:
-            turn_count = &ride->turn_count_sloped;
+            turn_count = &ride.turn_count_sloped;
             break;
         default:
             return 0;
@@ -4449,10 +4448,10 @@ bool Ride::HasWhirlpool() const
     return special_track_elements & RIDE_ELEMENT_WHIRLPOOL;
 }
 
-uint8_t ride_get_helix_sections(Ride* ride)
+uint8_t ride_get_helix_sections(const Ride& ride)
 {
     // Helix sections stored in the low 5 bits.
-    return ride->special_track_elements & 0x1F;
+    return ride.special_track_elements & 0x1F;
 }
 
 bool Ride::IsPoweredLaunched() const
@@ -4466,7 +4465,7 @@ bool Ride::IsBlockSectioned() const
     return mode == RideMode::ContinuousCircuitBlockSectioned || mode == RideMode::PoweredLaunchBlockSectioned;
 }
 
-bool ride_has_any_track_elements(const Ride* ride)
+bool ride_has_any_track_elements(const Ride& ride)
 {
     tile_element_iterator it;
 
@@ -4475,7 +4474,7 @@ bool ride_has_any_track_elements(const Ride* ride)
     {
         if (it.element->GetType() != TileElementType::Track)
             continue;
-        if (it.element->AsTrack()->GetRideIndex() != ride->id)
+        if (it.element->AsTrack()->GetRideIndex() != ride.id)
             continue;
         if (it.element->IsGhost())
             continue;
@@ -4589,24 +4588,24 @@ void set_vehicle_type_image_max_sizes(CarEntry* vehicle_type, int32_t num_images
  *
  *  rct2: 0x006B59C6
  */
-void invalidate_test_results(Ride* ride)
+void invalidate_test_results(Ride& ride)
 {
-    ride->measurement = {};
-    ride->excitement = RIDE_RATING_UNDEFINED;
-    ride->lifecycle_flags &= ~RIDE_LIFECYCLE_TESTED;
-    ride->lifecycle_flags &= ~RIDE_LIFECYCLE_TEST_IN_PROGRESS;
-    if (ride->lifecycle_flags & RIDE_LIFECYCLE_ON_TRACK)
+    ride.measurement = {};
+    ride.excitement = RIDE_RATING_UNDEFINED;
+    ride.lifecycle_flags &= ~RIDE_LIFECYCLE_TESTED;
+    ride.lifecycle_flags &= ~RIDE_LIFECYCLE_TEST_IN_PROGRESS;
+    if (ride.lifecycle_flags & RIDE_LIFECYCLE_ON_TRACK)
     {
-        for (int32_t i = 0; i < ride->NumTrains; i++)
+        for (int32_t i = 0; i < ride.NumTrains; i++)
         {
-            Vehicle* vehicle = GetEntity<Vehicle>(ride->vehicles[i]);
+            Vehicle* vehicle = GetEntity<Vehicle>(ride.vehicles[i]);
             if (vehicle != nullptr)
             {
                 vehicle->ClearUpdateFlag(VEHICLE_UPDATE_FLAG_TESTING);
             }
         }
     }
-    window_invalidate_by_number(WindowClass::Ride, ride->id.ToUnderlying());
+    window_invalidate_by_number(WindowClass::Ride, ride.id.ToUnderlying());
 }
 
 /**
@@ -4616,18 +4615,18 @@ void invalidate_test_results(Ride* ride)
  * @param rideIndex (dl)
  * @param reliabilityIncreaseFactor (ax)
  */
-void ride_fix_breakdown(Ride* ride, int32_t reliabilityIncreaseFactor)
+void ride_fix_breakdown(Ride& ride, int32_t reliabilityIncreaseFactor)
 {
-    ride->lifecycle_flags &= ~RIDE_LIFECYCLE_BREAKDOWN_PENDING;
-    ride->lifecycle_flags &= ~RIDE_LIFECYCLE_BROKEN_DOWN;
-    ride->lifecycle_flags &= ~RIDE_LIFECYCLE_DUE_INSPECTION;
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAIN | RIDE_INVALIDATE_RIDE_LIST | RIDE_INVALIDATE_RIDE_MAINTENANCE;
+    ride.lifecycle_flags &= ~RIDE_LIFECYCLE_BREAKDOWN_PENDING;
+    ride.lifecycle_flags &= ~RIDE_LIFECYCLE_BROKEN_DOWN;
+    ride.lifecycle_flags &= ~RIDE_LIFECYCLE_DUE_INSPECTION;
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAIN | RIDE_INVALIDATE_RIDE_LIST | RIDE_INVALIDATE_RIDE_MAINTENANCE;
 
-    if (ride->lifecycle_flags & RIDE_LIFECYCLE_ON_TRACK)
+    if (ride.lifecycle_flags & RIDE_LIFECYCLE_ON_TRACK)
     {
-        for (int32_t i = 0; i < ride->NumTrains; i++)
+        for (int32_t i = 0; i < ride.NumTrains; i++)
         {
-            for (Vehicle* vehicle = GetEntity<Vehicle>(ride->vehicles[i]); vehicle != nullptr;
+            for (Vehicle* vehicle = GetEntity<Vehicle>(ride.vehicles[i]); vehicle != nullptr;
                  vehicle = GetEntity<Vehicle>(vehicle->next_vehicle_on_train))
             {
                 vehicle->ClearUpdateFlag(VEHICLE_UPDATE_FLAG_ZERO_VELOCITY);
@@ -4637,17 +4636,17 @@ void ride_fix_breakdown(Ride* ride, int32_t reliabilityIncreaseFactor)
         }
     }
 
-    uint8_t unreliability = 100 - ride->reliability_percentage;
-    ride->reliability += reliabilityIncreaseFactor * (unreliability / 2);
+    uint8_t unreliability = 100 - ride.reliability_percentage;
+    ride.reliability += reliabilityIncreaseFactor * (unreliability / 2);
 }
 
 /**
  *
  *  rct2: 0x006DE102
  */
-void ride_update_vehicle_colours(Ride* ride)
+void ride_update_vehicle_colours(const Ride& ride)
 {
-    if (ride->type == RIDE_TYPE_SPACE_RINGS || ride->GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_VEHICLE_IS_INTEGRAL))
+    if (ride.type == RIDE_TYPE_SPACE_RINGS || ride.GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_VEHICLE_IS_INTEGRAL))
     {
         gfx_invalidate_screen();
     }
@@ -4657,19 +4656,19 @@ void ride_update_vehicle_colours(Ride* ride)
         int32_t carIndex = 0;
         VehicleColour colours = {};
 
-        for (Vehicle* vehicle = GetEntity<Vehicle>(ride->vehicles[i]); vehicle != nullptr;
+        for (Vehicle* vehicle = GetEntity<Vehicle>(ride.vehicles[i]); vehicle != nullptr;
              vehicle = GetEntity<Vehicle>(vehicle->next_vehicle_on_train))
         {
-            switch (ride->colour_scheme_type & 3)
+            switch (ride.colour_scheme_type & 3)
             {
                 case RIDE_COLOUR_SCHEME_MODE_ALL_SAME:
-                    colours = ride->vehicle_colours[0];
+                    colours = ride.vehicle_colours[0];
                     break;
                 case RIDE_COLOUR_SCHEME_MODE_DIFFERENT_PER_TRAIN:
-                    colours = ride->vehicle_colours[i];
+                    colours = ride.vehicle_colours[i];
                     break;
                 case RIDE_COLOUR_SCHEME_MODE_DIFFERENT_PER_CAR:
-                    colours = ride->vehicle_colours[std::min(carIndex, OpenRCT2::Limits::MaxCarsPerTrain - 1)];
+                    colours = ride.vehicle_colours[std::min(carIndex, OpenRCT2::Limits::MaxCarsPerTrain - 1)];
                     break;
             }
 
@@ -4875,10 +4874,10 @@ OpenRCT2::BitSet<TRACK_GROUP_COUNT> ride_entry_get_supported_track_pieces(const
     return supportedPieces;
 }
 
-static std::optional<int32_t> ride_get_smallest_station_length(Ride* ride)
+static std::optional<int32_t> ride_get_smallest_station_length(const Ride& ride)
 {
     std::optional<int32_t> result;
-    for (const auto& station : ride->GetStations())
+    for (const auto& station : ride.GetStations())
     {
         if (!station.Start.IsNull())
         {
@@ -4895,14 +4894,14 @@ static std::optional<int32_t> ride_get_smallest_station_length(Ride* ride)
  *
  *  rct2: 0x006CB3AA
  */
-static int32_t ride_get_track_length(Ride* ride)
+static int32_t ride_get_track_length(const Ride& ride)
 {
     TileElement* tileElement = nullptr;
     track_type_t trackType;
     CoordsXYZ trackStart;
     bool foundTrack = false;
 
-    for (const auto& station : ride->GetStations())
+    for (const auto& station : ride.GetStations())
     {
         trackStart = station.GetStart();
         if (trackStart.IsNull())
@@ -4994,7 +4993,7 @@ void Ride::UpdateMaxVehicles()
         MaxCarsPerTrain = rideEntry->max_cars_in_train;
 
         // Calculate maximum train length based on smallest station length
-        auto stationNumTiles = ride_get_smallest_station_length(this);
+        auto stationNumTiles = ride_get_smallest_station_length(*this);
         if (!stationNumTiles.has_value())
             return;
 
@@ -5078,7 +5077,7 @@ void Ride::UpdateMaxVehicles()
                     }
 
                     totalSpacing >>= 13;
-                    int32_t trackLength = ride_get_track_length(this) / 4;
+                    int32_t trackLength = ride_get_track_length(*this) / 4;
                     if (poweredMaxSpeed > 10)
                         trackLength = (trackLength * 3) / 4;
                     if (poweredMaxSpeed > 25)
@@ -5194,31 +5193,31 @@ void Ride::Crash(uint8_t vehicleIndex)
 }
 
 // Gets the approximate value of customers per hour for this ride. Multiplies ride_customers_in_last_5_minutes() by 12.
-uint32_t ride_customers_per_hour(const Ride* ride)
+uint32_t ride_customers_per_hour(const Ride& ride)
 {
     return ride_customers_in_last_5_minutes(ride) * 12;
 }
 
 // Calculates the number of customers for this ride in the last 5 minutes (or more correctly 9600 game ticks)
-uint32_t ride_customers_in_last_5_minutes(const Ride* ride)
+uint32_t ride_customers_in_last_5_minutes(const Ride& ride)
 {
     uint32_t sum = 0;
 
     for (int32_t i = 0; i < OpenRCT2::Limits::CustomerHistorySize; i++)
     {
-        sum += ride->num_customers[i];
+        sum += ride.num_customers[i];
     }
 
     return sum;
 }
 
-Vehicle* ride_get_broken_vehicle(const Ride* ride)
+Vehicle* ride_get_broken_vehicle(const Ride& ride)
 {
-    auto vehicleIndex = ride->vehicles[ride->broken_vehicle];
+    auto vehicleIndex = ride.vehicles[ride.broken_vehicle];
     Vehicle* vehicle = GetEntity<Vehicle>(vehicleIndex);
     if (vehicle != nullptr)
     {
-        return vehicle->GetCar(ride->broken_car);
+        return vehicle->GetCar(ride.broken_car);
     }
     return nullptr;
 }
@@ -5252,18 +5251,18 @@ bool Ride::IsRide() const
     return GetClassification() == RideClassification::Ride;
 }
 
-money16 ride_get_price(const Ride* ride)
+money16 ride_get_price(const Ride& ride)
 {
     if (gParkFlags & PARK_FLAGS_NO_MONEY)
         return 0;
-    if (ride->IsRide())
+    if (ride.IsRide())
     {
         if (!ParkRidePricesUnlocked())
         {
             return 0;
         }
     }
-    return ride->price[0];
+    return ride.price[0];
 }
 
 /**
@@ -5333,13 +5332,13 @@ static bool check_for_adjacent_station(const CoordsXYZ& stationCoords, uint8_t d
 /**
  * Return whether ride has at least one adjacent station to it.
  */
-bool ride_has_adjacent_station(Ride* ride)
+bool ride_has_adjacent_station(const Ride& ride)
 {
     bool found = false;
 
     /* Loop through all of the ride stations, checking for an
      * adjacent station on either side. */
-    for (const auto& station : ride->GetStations())
+    for (const auto& station : ride.GetStations())
     {
         auto stationStart = station.GetStart();
         if (!stationStart.IsNull())
@@ -5365,15 +5364,15 @@ bool ride_has_adjacent_station(Ride* ride)
     return found;
 }
 
-bool ride_has_station_shelter(Ride* ride)
+bool ride_has_station_shelter(const Ride& ride)
 {
-    const auto* stationObj = ride->GetStationObject();
+    const auto* stationObj = ride.GetStationObject();
     return stationObj != nullptr && (stationObj->Flags & STATION_OBJECT_FLAGS::HAS_SHELTER);
 }
 
-bool ride_has_ratings(const Ride* ride)
+bool ride_has_ratings(const Ride& ride)
 {
-    return ride->excitement != RIDE_RATING_UNDEFINED;
+    return ride.excitement != RIDE_RATING_UNDEFINED;
 }
 
 int32_t get_booster_speed(ride_type_t rideType, int32_t rawSpeed)
@@ -5482,7 +5481,7 @@ const MusicObject* Ride::GetMusicObject() const
 
 // Normally, a station has at most one entrance and one exit, which are at the same height
 // as the station. But in hacked parks, neither can be taken for granted. This code ensures
-// that the ride->entrances and ride->exits arrays will point to one of them. There is
+// that the ride.entrances and ride.exits arrays will point to one of them. There is
 // an ever-so-slight chance two entrances/exits for the same station reside on the same tile.
 // In cases like this, the one at station height will be considered the "true" one.
 // If none exists at that height, newer and higher placed ones take precedence.
@@ -5624,7 +5623,7 @@ void determine_ride_entrance_and_exit_locations()
     }
 }
 
-void ride_clear_leftover_entrances(Ride* ride)
+void ride_clear_leftover_entrances(const Ride& ride)
 {
     for (TileCoordsXY tilePos = {}; tilePos.x < gMapSize.x; ++tilePos.x)
     {
@@ -5636,7 +5635,7 @@ void ride_clear_leftover_entrances(Ride* ride)
                     || entrance->GetEntranceType() == ENTRANCE_TYPE_RIDE_EXIT;
                 if (!isRideEntranceExit)
                     continue;
-                if (entrance->GetRideIndex() != ride->id)
+                if (entrance->GetRideIndex() != ride.id)
                     continue;
 
                 TileElementRemove(entrance->as<TileElement>());
@@ -5800,12 +5799,12 @@ std::vector<RideId> GetTracklessRides()
 
 ResultWithMessage Ride::ChangeStatusDoStationChecks(StationIndex& stationIndex)
 {
-    auto stationIndexCheck = ride_mode_check_station_present(this);
+    auto stationIndexCheck = ride_mode_check_station_present(*this);
     stationIndex = stationIndexCheck.StationIndex;
     if (stationIndex.IsNull())
         return { false, stationIndexCheck.Message };
 
-    auto stationNumbersCheck = ride_mode_check_valid_station_numbers(this);
+    auto stationNumbersCheck = ride_mode_check_valid_station_numbers(*this);
     if (!stationNumbersCheck.Successful)
         return { false, stationNumbersCheck.Message };
 
diff --git a/src/openrct2/ride/Ride.h b/src/openrct2/ride/Ride.h
index 11e81f0237..8be288dc9b 100644
--- a/src/openrct2/ride/Ride.h
+++ b/src/openrct2/ride/Ride.h
@@ -1017,61 +1017,61 @@ void reset_all_ride_build_dates();
 void ride_update_favourited_stat();
 void ride_check_all_reachable();
 
-bool ride_try_get_origin_element(const Ride* ride, CoordsXYE* output);
-void ride_clear_blocked_tiles(Ride* ride);
-Staff* ride_get_mechanic(Ride* ride);
-Staff* ride_get_assigned_mechanic(Ride* ride);
-VehicleColour ride_get_vehicle_colour(Ride* ride, int32_t vehicleIndex);
+bool ride_try_get_origin_element(const Ride& ride, CoordsXYE* output);
+void ride_clear_blocked_tiles(const Ride& ride);
+Staff* ride_get_mechanic(const Ride& ride);
+Staff* ride_get_assigned_mechanic(const Ride& ride);
+VehicleColour ride_get_vehicle_colour(const Ride& ride, int32_t vehicleIndex);
 int32_t ride_get_unused_preset_vehicle_colour(ObjectEntryIndex subType);
-void ride_set_vehicle_colours_to_random_preset(Ride* ride, uint8_t preset_index);
+void ride_set_vehicle_colours_to_random_preset(Ride& ride, uint8_t preset_index);
 void ride_measurements_update();
-void ride_breakdown_add_news_item(Ride* ride);
-Staff* ride_find_closest_mechanic(Ride* ride, int32_t forInspection);
-int32_t ride_initialise_construction_window(Ride* ride);
+void ride_breakdown_add_news_item(const Ride& ride);
+Staff* ride_find_closest_mechanic(const Ride& ride, int32_t forInspection);
+int32_t ride_initialise_construction_window(Ride& ride);
 void ride_set_map_tooltip(TileElement* tileElement);
-void ride_prepare_breakdown(Ride* ride, int32_t breakdownReason);
-TileElement* ride_get_station_start_track_element(const Ride* ride, StationIndex stationIndex);
+void ride_prepare_breakdown(Ride& ride, int32_t breakdownReason);
+TileElement* ride_get_station_start_track_element(const Ride& ride, StationIndex stationIndex);
 TileElement* ride_get_station_exit_element(const CoordsXYZ& elementPos);
-int32_t ride_get_refund_price(const Ride* ride);
+int32_t ride_get_refund_price(const Ride& ride);
 int32_t ride_get_random_colour_preset_index(ride_type_t rideType);
-money32 ride_get_common_price(Ride* forRide);
+money32 ride_get_common_price(const Ride& forRide);
 
-void ride_clear_for_construction(Ride* ride);
-void invalidate_test_results(Ride* ride);
+void ride_clear_for_construction(Ride& ride);
+void invalidate_test_results(Ride& ride);
 
-void increment_turn_count_1_element(Ride* ride, uint8_t type);
-void increment_turn_count_2_elements(Ride* ride, uint8_t type);
-void increment_turn_count_3_elements(Ride* ride, uint8_t type);
-void increment_turn_count_4_plus_elements(Ride* ride, uint8_t type);
-int32_t get_turn_count_1_element(Ride* ride, uint8_t type);
-int32_t get_turn_count_2_elements(Ride* ride, uint8_t type);
-int32_t get_turn_count_3_elements(Ride* ride, uint8_t type);
-int32_t get_turn_count_4_plus_elements(Ride* ride, uint8_t type);
+void increment_turn_count_1_element(Ride& ride, uint8_t type);
+void increment_turn_count_2_elements(Ride& ride, uint8_t type);
+void increment_turn_count_3_elements(Ride& ride, uint8_t type);
+void increment_turn_count_4_plus_elements(Ride& ride, uint8_t type);
+int32_t get_turn_count_1_element(const Ride& ride, uint8_t type);
+int32_t get_turn_count_2_elements(const Ride& ride, uint8_t type);
+int32_t get_turn_count_3_elements(const Ride& ride, uint8_t type);
+int32_t get_turn_count_4_plus_elements(const Ride& ride, uint8_t type);
 
-uint8_t ride_get_helix_sections(Ride* ride);
+uint8_t ride_get_helix_sections(const Ride& ride);
 
-bool ride_has_any_track_elements(const Ride* ride);
+bool ride_has_any_track_elements(const Ride& ride);
 
 bool track_block_get_next(CoordsXYE* input, CoordsXYE* output, int32_t* z, int32_t* direction);
 bool track_block_get_next_from_zero(
-    const CoordsXYZ& startPos, Ride* ride, uint8_t direction_start, CoordsXYE* output, int32_t* z, int32_t* direction,
+    const CoordsXYZ& startPos, const Ride& ride, uint8_t direction_start, CoordsXYE* output, int32_t* z, int32_t* direction,
     bool isGhost);
 
 bool track_block_get_previous(const CoordsXYE& trackPos, track_begin_end* outTrackBeginEnd);
 bool track_block_get_previous_from_zero(
-    const CoordsXYZ& startPos, Ride* ride, uint8_t direction, track_begin_end* outTrackBeginEnd);
+    const CoordsXYZ& startPos, const Ride& ride, uint8_t direction, track_begin_end* outTrackBeginEnd);
 
 void ride_get_start_of_track(CoordsXYE* output);
 
 void window_ride_construction_update_active_elements();
 money32 RideEntranceExitPlaceGhost(
-    Ride* ride, const CoordsXY& entranceExitCoords, Direction direction, int32_t placeType, StationIndex stationNum);
+    const Ride& ride, const CoordsXY& entranceExitCoords, Direction direction, int32_t placeType, StationIndex stationNum);
 
-ResultWithMessage ride_are_all_possible_entrances_and_exits_built(Ride* ride);
-void ride_fix_breakdown(Ride* ride, int32_t reliabilityIncreaseFactor);
+ResultWithMessage ride_are_all_possible_entrances_and_exits_built(const Ride& ride);
+void ride_fix_breakdown(Ride& ride, int32_t reliabilityIncreaseFactor);
 
 uint8_t ride_entry_get_vehicle_at_position(int32_t rideEntryIndex, int32_t numCarsPerTrain, int32_t position);
-void ride_update_vehicle_colours(Ride* ride);
+void ride_update_vehicle_colours(const Ride& ride);
 
 OpenRCT2::BitSet<TRACK_GROUP_COUNT> ride_entry_get_supported_track_pieces(const rct_ride_entry* rideEntry);
 
@@ -1081,17 +1081,17 @@ money32 set_operating_setting_nested(RideId rideId, RideSetSetting setting, uint
 
 void UpdateGhostTrackAndArrow();
 
-uint32_t ride_customers_per_hour(const Ride* ride);
-uint32_t ride_customers_in_last_5_minutes(const Ride* ride);
+uint32_t ride_customers_per_hour(const Ride& ride);
+uint32_t ride_customers_in_last_5_minutes(const Ride& ride);
 
-Vehicle* ride_get_broken_vehicle(const Ride* ride);
+Vehicle* ride_get_broken_vehicle(const Ride& ride);
 
-money16 ride_get_price(const Ride* ride);
+money16 ride_get_price(const Ride& ride);
 
 TileElement* get_station_platform(const CoordsXYRangedZ& coords);
-bool ride_has_adjacent_station(Ride* ride);
-bool ride_has_station_shelter(Ride* ride);
-bool ride_has_ratings(const Ride* ride);
+bool ride_has_adjacent_station(const Ride& ride);
+bool ride_has_station_shelter(const Ride& ride);
+bool ride_has_ratings(const Ride& ride);
 
 int32_t get_booster_speed(ride_type_t rideType, int32_t rawSpeed);
 void fix_invalid_vehicle_sprite_sizes();
@@ -1100,9 +1100,9 @@ bool ride_entry_has_category(const rct_ride_entry* rideEntry, uint8_t category);
 int32_t ride_get_entry_index(int32_t rideType, int32_t rideSubType);
 
 void determine_ride_entrance_and_exit_locations();
-void ride_clear_leftover_entrances(Ride* ride);
+void ride_clear_leftover_entrances(const Ride& ride);
 
 std::vector<RideId> GetTracklessRides();
 
-void CircusMusicUpdate(Ride* ride);
-void DefaultMusicUpdate(Ride* ride);
+void CircusMusicUpdate(Ride& ride);
+void DefaultMusicUpdate(Ride& ride);
diff --git a/src/openrct2/ride/RideConstruction.cpp b/src/openrct2/ride/RideConstruction.cpp
index 3d199b4d46..608a94499b 100644
--- a/src/openrct2/ride/RideConstruction.cpp
+++ b/src/openrct2/ride/RideConstruction.cpp
@@ -91,25 +91,25 @@ Direction gRideEntranceExitPlaceDirection;
 using namespace OpenRCT2;
 using namespace OpenRCT2::TrackMetaData;
 
-static int32_t ride_check_if_construction_allowed(Ride* ride)
+static int32_t ride_check_if_construction_allowed(Ride& ride)
 {
     Formatter ft;
-    rct_ride_entry* rideEntry = ride->GetRideEntry();
+    rct_ride_entry* rideEntry = ride.GetRideEntry();
     if (rideEntry == nullptr)
     {
         ContextShowError(STR_INVALID_RIDE_TYPE, STR_CANT_EDIT_INVALID_RIDE_TYPE, ft);
         return 0;
     }
-    if (ride->lifecycle_flags & RIDE_LIFECYCLE_BROKEN_DOWN)
+    if (ride.lifecycle_flags & RIDE_LIFECYCLE_BROKEN_DOWN)
     {
-        ride->FormatNameTo(ft);
+        ride.FormatNameTo(ft);
         ContextShowError(STR_CANT_START_CONSTRUCTION_ON, STR_HAS_BROKEN_DOWN_AND_REQUIRES_FIXING, ft);
         return 0;
     }
 
-    if (ride->status != RideStatus::Closed && ride->status != RideStatus::Simulating)
+    if (ride.status != RideStatus::Closed && ride.status != RideStatus::Simulating)
     {
-        ride->FormatNameTo(ft);
+        ride.FormatNameTo(ft);
         ContextShowError(STR_CANT_START_CONSTRUCTION_ON, STR_MUST_BE_CLOSED_FIRST, ft);
         return 0;
     }
@@ -133,7 +133,7 @@ static rct_window* ride_create_or_find_construction_window(RideId rideIndex)
 void RideConstructionStart(Ride& ride)
 {
     CoordsXYE trackElement;
-    if (ride_try_get_origin_element(&ride, &trackElement))
+    if (ride_try_get_origin_element(ride, &trackElement))
     {
         ride.FindTrackGap(trackElement, &trackElement);
 
@@ -143,7 +143,7 @@ void RideConstructionStart(Ride& ride)
     }
     else
     {
-        ride_initialise_construction_window(&ride);
+        ride_initialise_construction_window(ride);
     }
 }
 
@@ -151,12 +151,12 @@ void RideConstructionStart(Ride& ride)
  *
  *  rct2: 0x006DD4D5
  */
-static void ride_remove_cable_lift(Ride* ride)
+static void ride_remove_cable_lift(Ride& ride)
 {
-    if (ride->lifecycle_flags & RIDE_LIFECYCLE_CABLE_LIFT)
+    if (ride.lifecycle_flags & RIDE_LIFECYCLE_CABLE_LIFT)
     {
-        ride->lifecycle_flags &= ~RIDE_LIFECYCLE_CABLE_LIFT;
-        auto spriteIndex = ride->cable_lift;
+        ride.lifecycle_flags &= ~RIDE_LIFECYCLE_CABLE_LIFT;
+        auto spriteIndex = ride.cable_lift;
         do
         {
             Vehicle* vehicle = GetEntity<Vehicle>(spriteIndex);
@@ -219,12 +219,12 @@ void Ride::RemoveVehicles()
  *
  *  rct2: 0x006DD4AC
  */
-void ride_clear_for_construction(Ride* ride)
+void ride_clear_for_construction(Ride& ride)
 {
-    ride->measurement = {};
+    ride.measurement = {};
 
-    ride->lifecycle_flags &= ~(RIDE_LIFECYCLE_BREAKDOWN_PENDING | RIDE_LIFECYCLE_BROKEN_DOWN);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAIN | RIDE_INVALIDATE_RIDE_LIST;
+    ride.lifecycle_flags &= ~(RIDE_LIFECYCLE_BREAKDOWN_PENDING | RIDE_LIFECYCLE_BROKEN_DOWN);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAIN | RIDE_INVALIDATE_RIDE_LIST;
 
     // Open circuit rides will go directly into building mode (creating ghosts) where it would normally clear the stats,
     // however this causes desyncs since it's directly run from the window and other clients would not get it.
@@ -235,10 +235,10 @@ void ride_clear_for_construction(Ride* ride)
     }
 
     ride_remove_cable_lift(ride);
-    ride->RemoveVehicles();
+    ride.RemoveVehicles();
     ride_clear_blocked_tiles(ride);
 
-    auto w = window_find_by_number(WindowClass::Ride, ride->id.ToUnderlying());
+    auto w = window_find_by_number(WindowClass::Ride, ride.id.ToUnderlying());
     if (w != nullptr)
         window_event_resize_call(w);
 }
@@ -250,7 +250,7 @@ void ride_clear_for_construction(Ride* ride)
 void Ride::RemovePeeps()
 {
     // Find first station
-    auto stationIndex = ride_get_first_valid_station_start(this);
+    auto stationIndex = ride_get_first_valid_station_start(*this);
 
     // Get exit position and direction
     auto exitPosition = CoordsXYZD{ 0, 0, 0, INVALID_DIRECTION };
@@ -340,7 +340,7 @@ void Ride::RemovePeeps()
     window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAIN;
 }
 
-void ride_clear_blocked_tiles(Ride* ride)
+void ride_clear_blocked_tiles(const Ride& ride)
 {
     for (TileCoordsXY tilePos = {}; tilePos.x < gMapSize.x; ++tilePos.x)
     {
@@ -348,7 +348,7 @@ void ride_clear_blocked_tiles(Ride* ride)
         {
             for (auto* trackElement : TileElementsView<TrackElement>(tilePos.ToCoordsXY()))
             {
-                if (trackElement->GetRideIndex() != ride->id)
+                if (trackElement->GetRideIndex() != ride.id)
                     continue;
 
                 // Unblock footpath element that is at same position
@@ -517,7 +517,7 @@ void ride_remove_provisional_track_piece()
             y -= CoordsDirectionDelta[direction].y;
         }
         CoordsXYE next_track;
-        if (track_block_get_next_from_zero({ x, y, z }, ride, direction, &next_track, &z, &direction, true))
+        if (track_block_get_next_from_zero({ x, y, z }, *ride, direction, &next_track, &z, &direction, true))
         {
             auto trackType = next_track.element->AsTrack()->GetTrackType();
             int32_t trackSequence = next_track.element->AsTrack()->GetSequenceIndex();
@@ -643,7 +643,7 @@ void ride_construction_set_default_next_piece()
     {
         case RideConstructionState::Front:
             direction = _currentTrackPieceDirection;
-            if (!track_block_get_previous_from_zero(_currentTrackBegin, ride, direction, &trackBeginEnd))
+            if (!track_block_get_previous_from_zero(_currentTrackBegin, *ride, direction, &trackBeginEnd))
             {
                 ride_construction_reset_current_piece();
                 return;
@@ -695,7 +695,7 @@ void ride_construction_set_default_next_piece()
             break;
         case RideConstructionState::Back:
             direction = DirectionReverse(_currentTrackPieceDirection);
-            if (!track_block_get_next_from_zero(_currentTrackBegin, ride, direction, &xyElement, &z, &direction, false))
+            if (!track_block_get_next_from_zero(_currentTrackBegin, *ride, direction, &xyElement, &z, &direction, false))
             {
                 ride_construction_reset_current_piece();
                 return;
@@ -905,7 +905,7 @@ static bool ride_modify_entrance_or_exit(const CoordsXYE& tileElement)
     auto constructionWindow = window_find_by_class(WindowClass::RideConstruction);
     if (constructionWindow == nullptr)
     {
-        if (!ride_initialise_construction_window(ride))
+        if (!ride_initialise_construction_window(*ride))
             return false;
 
         constructionWindow = window_find_by_class(WindowClass::RideConstruction);
@@ -1001,7 +1001,7 @@ bool ride_modify(const CoordsXYE& input)
     }
 
     auto rideEntry = ride->GetRideEntry();
-    if (rideEntry == nullptr || !ride_check_if_construction_allowed(ride))
+    if (rideEntry == nullptr || !ride_check_if_construction_allowed(*ride))
         return false;
 
     if (ride->lifecycle_flags & RIDE_LIFECYCLE_INDESTRUCTIBLE)
@@ -1096,7 +1096,7 @@ bool ride_modify(const CoordsXYE& input)
  *
  *  rct2: 0x006CC3FB
  */
-int32_t ride_initialise_construction_window(Ride* ride)
+int32_t ride_initialise_construction_window(Ride& ride)
 {
     rct_window* w;
 
@@ -1106,24 +1106,20 @@ int32_t ride_initialise_construction_window(Ride* ride)
         return 0;
 
     ride_clear_for_construction(ride);
-    ride->RemovePeeps();
+    ride.RemovePeeps();
 
-    w = ride_create_or_find_construction_window(ride->id);
+    w = ride_create_or_find_construction_window(ride.id);
 
     tool_set(*w, WC_RIDE_CONSTRUCTION__WIDX_CONSTRUCT, Tool::Crosshair);
     input_set_flag(INPUT_FLAG_6, true);
 
-    ride = get_ride(_currentRideIndex);
-    if (ride == nullptr)
-        return 0;
-
-    _currentTrackCurve = ride->GetRideTypeDescriptor().StartTrackPiece | RideConstructionSpecialPieceSelected;
+    _currentTrackCurve = ride.GetRideTypeDescriptor().StartTrackPiece | RideConstructionSpecialPieceSelected;
     _currentTrackSlopeEnd = 0;
     _currentTrackBankEnd = 0;
     _currentTrackLiftHill = 0;
     _currentTrackAlternative = RIDE_TYPE_NO_ALTERNATIVES;
 
-    if (ride->GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_START_CONSTRUCTION_INVERTED))
+    if (ride.GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_START_CONSTRUCTION_INVERTED))
         _currentTrackAlternative |= RIDE_TYPE_ALTERNATIVE_TRACK_TYPE;
 
     _previousTrackBankEnd = 0;
@@ -1141,7 +1137,7 @@ int32_t ride_initialise_construction_window(Ride* ride)
  *
  *  rct2: 0x006CB7FB
  */
-int32_t ride_get_refund_price(const Ride* ride)
+int32_t ride_get_refund_price(const Ride& ride)
 {
     CoordsXYE trackElement;
     money32 cost = 0;
@@ -1598,7 +1594,7 @@ bool ride_select_backwards_from_front()
     {
         ride_construction_invalidate_current_track();
         track_begin_end trackBeginEnd;
-        if (track_block_get_previous_from_zero(_currentTrackBegin, ride, _currentTrackPieceDirection, &trackBeginEnd))
+        if (track_block_get_previous_from_zero(_currentTrackBegin, *ride, _currentTrackPieceDirection, &trackBeginEnd))
         {
             _rideConstructionState = RideConstructionState::Selected;
             _currentTrackBegin.x = trackBeginEnd.begin_x;
@@ -1623,7 +1619,7 @@ bool ride_select_forwards_from_back()
         int32_t z = _currentTrackBegin.z;
         int32_t direction = DirectionReverse(_currentTrackPieceDirection);
         CoordsXYE next_track;
-        if (track_block_get_next_from_zero(_currentTrackBegin, ride, direction, &next_track, &z, &direction, false))
+        if (track_block_get_next_from_zero(_currentTrackBegin, *ride, direction, &next_track, &z, &direction, false))
         {
             _rideConstructionState = RideConstructionState::Selected;
             _currentTrackBegin.x = next_track.x;
@@ -1642,12 +1638,12 @@ bool ride_select_forwards_from_back()
  *
  *  rct2: 0x006B58EF
  */
-ResultWithMessage ride_are_all_possible_entrances_and_exits_built(Ride* ride)
+ResultWithMessage ride_are_all_possible_entrances_and_exits_built(const Ride& ride)
 {
-    if (ride->GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_IS_SHOP_OR_FACILITY))
+    if (ride.GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_IS_SHOP_OR_FACILITY))
         return { true };
 
-    for (auto& station : ride->GetStations())
+    for (auto& station : ride.GetStations())
     {
         if (station.Start.IsNull())
         {
diff --git a/src/openrct2/ride/RideData.h b/src/openrct2/ride/RideData.h
index 01b5ee10bd..0224c390d6 100644
--- a/src/openrct2/ride/RideData.h
+++ b/src/openrct2/ride/RideData.h
@@ -38,7 +38,7 @@
 
 enum class ResearchCategory : uint8_t;
 
-using ride_ratings_calculation = void (*)(Ride* ride, RideRatingUpdateState& state);
+using ride_ratings_calculation = void (*)(Ride& ride, RideRatingUpdateState& state);
 
 struct RideComponentName
 {
@@ -158,15 +158,15 @@ struct UpkeepCostsDescriptor
 
 using RideTrackGroup = OpenRCT2::BitSet<TRACK_GROUP_COUNT>;
 using UpdateRideApproachVehicleWaypointsFunction = void (*)(Guest&, const CoordsXY&, int16_t&);
-using RideMusicUpdateFunction = void (*)(Ride*);
-using PeepUpdateRideLeaveEntranceFunc = void (*)(Guest*, Ride*, CoordsXYZD&);
+using RideMusicUpdateFunction = void (*)(Ride&);
+using PeepUpdateRideLeaveEntranceFunc = void (*)(Guest*, Ride&, CoordsXYZD&);
 using StartRideMusicFunction = void (*)(const OpenRCT2::RideAudio::ViewportRideMusicInstance&);
 using LightFXAddLightsMagicVehicleFunction = void (*)(const Vehicle* vehicle);
 using RideLocationFunction = CoordsXY (*)(const Vehicle& vehicle, const Ride& ride, const StationIndex& CurrentRideStation);
 using RideUpdateFunction = void (*)(Ride& ride);
-using RideUpdateMeasurementsSpecialElementsFunc = void (*)(Ride* ride, const track_type_t trackType);
+using RideUpdateMeasurementsSpecialElementsFunc = void (*)(Ride& ride, const track_type_t trackType);
 using MusicTrackOffsetLengthFunc = std::pair<size_t, size_t> (*)(const Ride& ride);
-using SpecialElementRatingAdjustmentFunc = void (*)(const Ride* ride, int32_t& excitement, int32_t& intensity, int32_t& nausea);
+using SpecialElementRatingAdjustmentFunc = void (*)(const Ride& ride, int32_t& excitement, int32_t& intensity, int32_t& nausea);
 
 using UpdateRotatingFunction = void (*)(Vehicle& vehicle);
 enum class RideConstructionWindowContext : uint8_t
diff --git a/src/openrct2/ride/RideRatings.cpp b/src/openrct2/ride/RideRatings.cpp
index 173b524808..7b3a0bf37f 100644
--- a/src/openrct2/ride/RideRatings.cpp
+++ b/src/openrct2/ride/RideRatings.cpp
@@ -87,8 +87,8 @@ static void ride_ratings_update_state_3(RideRatingUpdateState& state);
 static void ride_ratings_update_state_4(RideRatingUpdateState& state);
 static void ride_ratings_update_state_5(RideRatingUpdateState& state);
 static void ride_ratings_begin_proximity_loop(RideRatingUpdateState& state);
-static void ride_ratings_calculate(RideRatingUpdateState& state, Ride* ride);
-static void ride_ratings_calculate_value(Ride* ride);
+static void ride_ratings_calculate(RideRatingUpdateState& state, Ride& ride);
+static void ride_ratings_calculate_value(Ride& ride);
 static void ride_ratings_score_close_proximity(RideRatingUpdateState& state, TileElement* inputTileElement);
 
 static void ride_ratings_add(RatingTuple* rating, int32_t excitement, int32_t intensity, int32_t nausea);
@@ -303,8 +303,8 @@ static void ride_ratings_update_state_3(RideRatingUpdateState& state)
         return;
     }
 
-    ride_ratings_calculate(state, ride);
-    ride_ratings_calculate_value(ride);
+    ride_ratings_calculate(state, *ride);
+    ride_ratings_calculate_value(*ride);
 
     window_invalidate_by_number(WindowClass::Ride, state.CurrentRide.ToUnderlying());
     state.State = RIDE_RATINGS_STATE_FIND_NEXT_RIDE;
@@ -742,39 +742,39 @@ static void ride_ratings_score_close_proximity(RideRatingUpdateState& state, Til
     }
 }
 
-static void ride_ratings_calculate(RideRatingUpdateState& state, Ride* ride)
+static void ride_ratings_calculate(RideRatingUpdateState& state, Ride& ride)
 {
-    auto calcFunc = ride_ratings_get_calculate_func(ride->type);
+    auto calcFunc = ride_ratings_get_calculate_func(ride.type);
     if (calcFunc != nullptr)
     {
         calcFunc(ride, state);
     }
 
 #ifdef ORIGINAL_RATINGS
-    if (ride->ratings.excitement != -1)
+    if (ride.ratings.excitement != -1)
     {
         // Address underflows allowed by original RCT2 code
-        ride->ratings.excitement = max(0, ride->ratings.excitement);
-        ride->ratings.intensity = max(0, ride->ratings.intensity);
-        ride->ratings.nausea = max(0, ride->ratings.nausea);
+        ride.ratings.excitement = max(0, ride.ratings.excitement);
+        ride.ratings.intensity = max(0, ride.ratings.intensity);
+        ride.ratings.nausea = max(0, ride.ratings.nausea);
     }
 #endif
 
 #ifdef ENABLE_SCRIPTING
     // Only call the 'ride.ratings.calculate' API hook if testing of the ride is complete
-    if (ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED)
+    if (ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED)
     {
         auto& hookEngine = GetContext()->GetScriptEngine().GetHookEngine();
         if (hookEngine.HasSubscriptions(HOOK_TYPE::RIDE_RATINGS_CALCULATE))
         {
             auto ctx = GetContext()->GetScriptEngine().GetContext();
-            auto originalExcitement = ride->excitement;
-            auto originalIntensity = ride->intensity;
-            auto originalNausea = ride->nausea;
+            auto originalExcitement = ride.excitement;
+            auto originalIntensity = ride.intensity;
+            auto originalNausea = ride.nausea;
 
             // Create event args object
             auto obj = DukObject(ctx);
-            obj.Set("rideId", ride->id.ToUnderlying());
+            obj.Set("rideId", ride.id.ToUnderlying());
             obj.Set("excitement", originalExcitement);
             obj.Set("intensity", originalIntensity);
             obj.Set("nausea", originalNausea);
@@ -787,15 +787,15 @@ static void ride_ratings_calculate(RideRatingUpdateState& state, Ride* ride)
             auto scriptIntensity = AsOrDefault(e["intensity"], static_cast<int32_t>(originalIntensity));
             auto scriptNausea = AsOrDefault(e["nausea"], static_cast<int32_t>(originalNausea));
 
-            ride->excitement = std::clamp<int32_t>(scriptExcitement, 0, INT16_MAX);
-            ride->intensity = std::clamp<int32_t>(scriptIntensity, 0, INT16_MAX);
-            ride->nausea = std::clamp<int32_t>(scriptNausea, 0, INT16_MAX);
+            ride.excitement = std::clamp<int32_t>(scriptExcitement, 0, INT16_MAX);
+            ride.intensity = std::clamp<int32_t>(scriptIntensity, 0, INT16_MAX);
+            ride.nausea = std::clamp<int32_t>(scriptNausea, 0, INT16_MAX);
         }
     }
 #endif
 }
 
-static void ride_ratings_calculate_value(Ride* ride)
+static void ride_ratings_calculate_value(Ride& ride)
 {
     struct row
     {
@@ -835,15 +835,15 @@ static void ride_ratings_calculate_value(Ride* ride)
     }
 
     // Start with the base ratings, multiplied by the ride type specific weights for excitement, intensity and nausea.
-    const auto& ratingsMultipliers = ride->GetRideTypeDescriptor().RatingsMultipliers;
-    int32_t value = (((ride->excitement * ratingsMultipliers.Excitement) * 32) >> 15)
-        + (((ride->intensity * ratingsMultipliers.Intensity) * 32) >> 15)
-        + (((ride->nausea * ratingsMultipliers.Nausea) * 32) >> 15);
+    const auto& ratingsMultipliers = ride.GetRideTypeDescriptor().RatingsMultipliers;
+    int32_t value = (((ride.excitement * ratingsMultipliers.Excitement) * 32) >> 15)
+        + (((ride.intensity * ratingsMultipliers.Intensity) * 32) >> 15)
+        + (((ride.nausea * ratingsMultipliers.Nausea) * 32) >> 15);
 
     int32_t monthsOld = 0;
     if (!gCheatsDisableRideValueAging)
     {
-        monthsOld = ride->GetAge();
+        monthsOld = ride.GetAge();
     }
 
     const row* ageTable = ageTableNew;
@@ -878,13 +878,14 @@ static void ride_ratings_calculate_value(Ride* ride)
 
     // Other ride of same type penalty
     const auto& rideManager = GetRideManager();
-    auto otherRidesOfSameType = std::count_if(rideManager.begin(), rideManager.end(), [ride](const Ride& r) {
-        return r.status == RideStatus::Open && r.type == ride->type;
+    auto rideType = ride.type;
+    auto otherRidesOfSameType = std::count_if(rideManager.begin(), rideManager.end(), [rideType](const Ride& r) {
+        return r.status == RideStatus::Open && r.type == rideType;
     });
     if (otherRidesOfSameType > 1)
         value -= value / 4;
 
-    ride->value = std::max(0, value);
+    ride.value = std::max(0, value);
 }
 
 /**
@@ -893,28 +894,28 @@ static void ride_ratings_calculate_value(Ride* ride)
  * inputs
  * - edi: ride ptr
  */
-static uint16_t ride_compute_upkeep(RideRatingUpdateState& state, Ride* ride)
+static uint16_t ride_compute_upkeep(RideRatingUpdateState& state, const Ride& ride)
 {
     // data stored at 0x0057E3A8, incrementing 18 bytes at a time
-    uint16_t upkeep = ride->GetRideTypeDescriptor().UpkeepCosts.BaseCost;
+    uint16_t upkeep = ride.GetRideTypeDescriptor().UpkeepCosts.BaseCost;
 
-    uint16_t trackCost = ride->GetRideTypeDescriptor().UpkeepCosts.CostPerTrackPiece;
-    uint8_t dropFactor = ride->drops;
+    uint16_t trackCost = ride.GetRideTypeDescriptor().UpkeepCosts.CostPerTrackPiece;
+    uint8_t dropFactor = ride.drops;
 
     dropFactor >>= 6;
     dropFactor &= 3;
     upkeep += trackCost * dropFactor;
 
-    uint32_t totalLength = ride->GetTotalLength() >> 16;
+    uint32_t totalLength = ride.GetTotalLength() >> 16;
 
     // The data originally here was 20's and 0's. The 20's all represented
     // rides that had tracks. The 0's were fixed rides like crooked house or
     // dodgems.
     // Data source is 0x0097E3AC
-    totalLength *= ride->GetRideTypeDescriptor().UpkeepCosts.TrackLengthMultiplier;
+    totalLength *= ride.GetRideTypeDescriptor().UpkeepCosts.TrackLengthMultiplier;
     upkeep += static_cast<uint16_t>(totalLength >> 10);
 
-    if (ride->lifecycle_flags & RIDE_LIFECYCLE_ON_RIDE_PHOTO)
+    if (ride.lifecycle_flags & RIDE_LIFECYCLE_ON_RIDE_PHOTO)
     {
         // The original code read from a table starting at 0x0097E3AE and
         // incrementing by 0x12 bytes between values. However, all of these
@@ -933,26 +934,26 @@ static uint16_t ride_compute_upkeep(RideRatingUpdateState& state, Ride* ride)
     // various variables set on the ride itself.
 
     // https://gist.github.com/kevinburke/e19b803cd2769d96c540
-    upkeep += ride->GetRideTypeDescriptor().UpkeepCosts.CostPerTrain * ride->NumTrains;
-    upkeep += ride->GetRideTypeDescriptor().UpkeepCosts.CostPerCar * ride->num_cars_per_train;
+    upkeep += ride.GetRideTypeDescriptor().UpkeepCosts.CostPerTrain * ride.NumTrains;
+    upkeep += ride.GetRideTypeDescriptor().UpkeepCosts.CostPerCar * ride.num_cars_per_train;
 
     // slight upkeep boosts for some rides - 5 for mini railway, 10 for log
     // flume/rapids, 10 for roller coaster, 28 for giga coaster
-    upkeep += ride->GetRideTypeDescriptor().UpkeepCosts.CostPerStation * ride->num_stations;
+    upkeep += ride.GetRideTypeDescriptor().UpkeepCosts.CostPerStation * ride.num_stations;
 
-    if (ride->mode == RideMode::ReverseInclineLaunchedShuttle)
+    if (ride.mode == RideMode::ReverseInclineLaunchedShuttle)
     {
         upkeep += 30;
     }
-    else if (ride->mode == RideMode::PoweredLaunchPasstrough)
+    else if (ride.mode == RideMode::PoweredLaunchPasstrough)
     {
         upkeep += 160;
     }
-    else if (ride->mode == RideMode::LimPoweredLaunch)
+    else if (ride.mode == RideMode::LimPoweredLaunch)
     {
         upkeep += 320;
     }
-    else if (ride->mode == RideMode::PoweredLaunch || ride->mode == RideMode::PoweredLaunchBlockSectioned)
+    else if (ride.mode == RideMode::PoweredLaunch || ride.mode == RideMode::PoweredLaunchBlockSectioned)
     {
         upkeep += 220;
     }
@@ -973,9 +974,9 @@ static uint16_t ride_compute_upkeep(RideRatingUpdateState& state, Ride* ride)
  * - bp: nausea
  * - edi: ride ptr
  */
-static void ride_ratings_apply_adjustments(Ride* ride, RatingTuple* ratings)
+static void ride_ratings_apply_adjustments(const Ride& ride, RatingTuple* ratings)
 {
-    rct_ride_entry* rideEntry = get_ride_entry(ride->subtype);
+    rct_ride_entry* rideEntry = get_ride_entry(ride.subtype);
 
     if (rideEntry == nullptr)
     {
@@ -990,9 +991,9 @@ static void ride_ratings_apply_adjustments(Ride* ride, RatingTuple* ratings)
 
     // Apply total air time
 #ifdef ORIGINAL_RATINGS
-    if (ride->GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_HAS_AIR_TIME))
+    if (ride.GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_HAS_AIR_TIME))
     {
-        uint16_t totalAirTime = ride->total_air_time;
+        uint16_t totalAirTime = ride.total_air_time;
         if (rideEntry->flags & RIDE_ENTRY_FLAG_LIMIT_AIRTIME_BONUS)
         {
             if (totalAirTime >= 96)
@@ -1009,19 +1010,19 @@ static void ride_ratings_apply_adjustments(Ride* ride, RatingTuple* ratings)
         }
     }
 #else
-    if (ride->GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_HAS_AIR_TIME))
+    if (ride.GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_HAS_AIR_TIME))
     {
         int32_t excitementModifier;
         if (rideEntry->flags & RIDE_ENTRY_FLAG_LIMIT_AIRTIME_BONUS)
         {
             // Limit airtime bonus for heartline twister coaster (see issues #2031 and #2064)
-            excitementModifier = std::min<uint16_t>(ride->total_air_time, 96) / 8;
+            excitementModifier = std::min<uint16_t>(ride.total_air_time, 96) / 8;
         }
         else
         {
-            excitementModifier = ride->total_air_time / 8;
+            excitementModifier = ride.total_air_time / 8;
         }
-        int32_t nauseaModifier = ride->total_air_time / 16;
+        int32_t nauseaModifier = ride.total_air_time / 16;
 
         ride_ratings_add(ratings, excitementModifier, 0, nauseaModifier);
     }
@@ -1050,11 +1051,11 @@ static void ride_ratings_apply_intensity_penalty(RatingTuple* ratings)
  *
  *  rct2: 0x00655FD6
  */
-static void set_unreliability_factor(Ride* ride)
+static void set_unreliability_factor(Ride& ride)
 {
     // The bigger the difference in lift speed and minimum the higher the unreliability
-    uint8_t minLiftSpeed = ride->GetRideTypeDescriptor().LiftData.minimum_speed;
-    ride->unreliability_factor += (ride->lift_hill_speed - minLiftSpeed) * 2;
+    uint8_t minLiftSpeed = ride.GetRideTypeDescriptor().LiftData.minimum_speed;
+    ride.unreliability_factor += (ride.lift_hill_speed - minLiftSpeed) * 2;
 }
 
 static uint32_t get_proximity_score_helper_1(uint16_t x, uint16_t max, uint32_t multiplier)
@@ -1117,10 +1118,10 @@ static uint32_t ride_ratings_get_proximity_score(RideRatingUpdateState& state)
  * Calculates how much of the track is sheltered in eighths.
  *  rct2: 0x0065E72D
  */
-static ShelteredEights get_num_of_sheltered_eighths(Ride* ride)
+static ShelteredEights get_num_of_sheltered_eighths(const Ride& ride)
 {
-    int32_t totalLength = ride->GetTotalLength();
-    int32_t shelteredLength = ride->sheltered_length;
+    int32_t totalLength = ride.GetTotalLength();
+    int32_t shelteredLength = ride.sheltered_length;
     int32_t lengthEighth = totalLength / 8;
     int32_t lengthCounter = lengthEighth;
     uint8_t numShelteredEighths = 0;
@@ -1134,7 +1135,7 @@ static ShelteredEights get_num_of_sheltered_eighths(Ride* ride)
     }
 
     uint8_t trackShelteredEighths = numShelteredEighths;
-    rct_ride_entry* rideType = get_ride_entry(ride->subtype);
+    rct_ride_entry* rideType = get_ride_entry(ride.subtype);
     if (rideType == nullptr)
     {
         return { 0, 0 };
@@ -1145,7 +1146,7 @@ static ShelteredEights get_num_of_sheltered_eighths(Ride* ride)
     return { trackShelteredEighths, numShelteredEighths };
 }
 
-static RatingTuple get_flat_turns_rating(Ride* ride)
+static RatingTuple get_flat_turns_rating(const Ride& ride)
 {
     int32_t num3PlusTurns = get_turn_count_3_elements(ride, 0);
     int32_t num2Turns = get_turn_count_2_elements(ride, 0);
@@ -1171,7 +1172,7 @@ static RatingTuple get_flat_turns_rating(Ride* ride)
  *
  *  rct2: 0x0065DF72
  */
-static RatingTuple get_banked_turns_rating(Ride* ride)
+static RatingTuple get_banked_turns_rating(const Ride& ride)
 {
     int32_t num3PlusTurns = get_turn_count_3_elements(ride, 1);
     int32_t num2Turns = get_turn_count_2_elements(ride, 1);
@@ -1197,7 +1198,7 @@ static RatingTuple get_banked_turns_rating(Ride* ride)
  *
  *  rct2: 0x0065E047
  */
-static RatingTuple get_sloped_turns_rating(Ride* ride)
+static RatingTuple get_sloped_turns_rating(const Ride& ride)
 {
     RatingTuple rating;
 
@@ -1231,20 +1232,20 @@ static RatingTuple get_inversions_ratings(uint16_t inversions)
     return rating;
 }
 
-void SpecialTrackElementRatingsAjustment_Default(const Ride* ride, int32_t& excitement, int32_t& intensity, int32_t& nausea)
+void SpecialTrackElementRatingsAjustment_Default(const Ride& ride, int32_t& excitement, int32_t& intensity, int32_t& nausea)
 {
-    if (ride->HasWaterSplash())
+    if (ride.HasWaterSplash())
     {
         excitement += 50;
         intensity += 30;
         nausea += 20;
     }
-    if (ride->HasWaterfall())
+    if (ride.HasWaterfall())
     {
         excitement += 55;
         intensity += 30;
     }
-    if (ride->HasWhirlpool())
+    if (ride.HasWhirlpool())
     {
         excitement += 35;
         intensity += 20;
@@ -1252,9 +1253,9 @@ void SpecialTrackElementRatingsAjustment_Default(const Ride* ride, int32_t& exci
     }
 }
 
-void SpecialTrackElementRatingsAjustment_GhostTrain(const Ride* ride, int32_t& excitement, int32_t& intensity, int32_t& nausea)
+void SpecialTrackElementRatingsAjustment_GhostTrain(const Ride& ride, int32_t& excitement, int32_t& intensity, int32_t& nausea)
 {
-    if (ride->HasSpinningTunnel())
+    if (ride.HasSpinningTunnel())
     {
         excitement += 40;
         intensity += 25;
@@ -1262,9 +1263,9 @@ void SpecialTrackElementRatingsAjustment_GhostTrain(const Ride* ride, int32_t& e
     }
 }
 
-void SpecialTrackElementRatingsAjustment_LogFlume(const Ride* ride, int32_t& excitement, int32_t& intensity, int32_t& nausea)
+void SpecialTrackElementRatingsAjustment_LogFlume(const Ride& ride, int32_t& excitement, int32_t& intensity, int32_t& nausea)
 {
-    if (ride->HasLogReverser())
+    if (ride.HasLogReverser())
     {
         excitement += 48;
         intensity += 55;
@@ -1272,10 +1273,10 @@ void SpecialTrackElementRatingsAjustment_LogFlume(const Ride* ride, int32_t& exc
     }
 }
 
-static RatingTuple GetSpecialTrackElementsRating(uint8_t type, Ride* ride)
+static RatingTuple GetSpecialTrackElementsRating(uint8_t type, const Ride& ride)
 {
     int32_t excitement = 0, intensity = 0, nausea = 0;
-    const auto& rtd = ride->GetRideTypeDescriptor();
+    const auto& rtd = ride.GetRideTypeDescriptor();
     rtd.SpecialElementRatingAdjustment(ride, excitement, intensity, nausea);
 
     uint8_t helixSections = ride_get_helix_sections(ride);
@@ -1298,11 +1299,11 @@ static RatingTuple GetSpecialTrackElementsRating(uint8_t type, Ride* ride)
  *
  *  rct2: 0x0065DDD1
  */
-static RatingTuple ride_ratings_get_turns_ratings(Ride* ride)
+static RatingTuple ride_ratings_get_turns_ratings(const Ride& ride)
 {
     int32_t excitement = 0, intensity = 0, nausea = 0;
 
-    RatingTuple specialTrackElementsRating = GetSpecialTrackElementsRating(ride->type, ride);
+    RatingTuple specialTrackElementsRating = GetSpecialTrackElementsRating(ride.type, ride);
     excitement += specialTrackElementsRating.Excitement;
     intensity += specialTrackElementsRating.Intensity;
     nausea += specialTrackElementsRating.Nausea;
@@ -1322,7 +1323,7 @@ static RatingTuple ride_ratings_get_turns_ratings(Ride* ride)
     intensity += slopedTurnsRating.Intensity;
     nausea += slopedTurnsRating.Nausea;
 
-    auto inversions = (ride->type == RIDE_TYPE_MINI_GOLF) ? ride->holes : ride->inversions;
+    auto inversions = (ride.type == RIDE_TYPE_MINI_GOLF) ? ride.holes : ride.inversions;
     RatingTuple inversionsRating = get_inversions_ratings(inversions);
     excitement += inversionsRating.Excitement;
     intensity += inversionsRating.Intensity;
@@ -1337,9 +1338,9 @@ static RatingTuple ride_ratings_get_turns_ratings(Ride* ride)
  *
  *  rct2: 0x0065E1C2
  */
-static RatingTuple ride_ratings_get_sheltered_ratings(Ride* ride)
+static RatingTuple ride_ratings_get_sheltered_ratings(const Ride& ride)
 {
-    int32_t shelteredLengthShifted = (ride->sheltered_length) >> 16;
+    int32_t shelteredLengthShifted = (ride.sheltered_length) >> 16;
 
     uint32_t shelteredLengthUpTo1000 = std::min(shelteredLengthShifted, 1000);
     uint32_t shelteredLengthUpTo2000 = std::min(shelteredLengthShifted, 2000);
@@ -1348,22 +1349,22 @@ static RatingTuple ride_ratings_get_sheltered_ratings(Ride* ride)
     int32_t intensity = (shelteredLengthUpTo2000 * 0x2666) >> 16;
     int32_t nausea = (shelteredLengthUpTo1000 * 0x4000) >> 16;
 
-    /*eax = (ride->var_11C * 30340) >> 16;*/
+    /*eax = (ride.var_11C * 30340) >> 16;*/
     /*nausea += eax;*/
 
-    if (ride->num_sheltered_sections & ShelteredSectionsBits::BankingWhileSheltered)
+    if (ride.num_sheltered_sections & ShelteredSectionsBits::BankingWhileSheltered)
     {
         excitement += 20;
         nausea += 15;
     }
 
-    if (ride->num_sheltered_sections & ShelteredSectionsBits::RotatingWhileSheltered)
+    if (ride.num_sheltered_sections & ShelteredSectionsBits::RotatingWhileSheltered)
     {
         excitement += 20;
         nausea += 15;
     }
 
-    uint8_t lowerVal = ride->GetNumShelteredSections();
+    uint8_t lowerVal = ride.GetNumShelteredSections();
     lowerVal = std::min<uint8_t>(lowerVal, 11);
     excitement += (lowerVal * 774516) >> 16;
 
@@ -1376,7 +1377,7 @@ static RatingTuple ride_ratings_get_sheltered_ratings(Ride* ride)
  *
  *  rct2: 0x0065DCDC
  */
-static RatingTuple ride_ratings_get_gforce_ratings(Ride* ride)
+static RatingTuple ride_ratings_get_gforce_ratings(const Ride& ride)
 {
     RatingTuple result = {
         /* .excitement = */ 0,
@@ -1385,29 +1386,29 @@ static RatingTuple ride_ratings_get_gforce_ratings(Ride* ride)
     };
 
     // Apply maximum positive G force factor
-    result.Excitement += (ride->max_positive_vertical_g * 5242) >> 16;
-    result.Intensity += (ride->max_positive_vertical_g * 52428) >> 16;
-    result.Nausea += (ride->max_positive_vertical_g * 17039) >> 16;
+    result.Excitement += (ride.max_positive_vertical_g * 5242) >> 16;
+    result.Intensity += (ride.max_positive_vertical_g * 52428) >> 16;
+    result.Nausea += (ride.max_positive_vertical_g * 17039) >> 16;
 
     // Apply maximum negative G force factor
-    fixed16_2dp gforce = ride->max_negative_vertical_g;
+    fixed16_2dp gforce = ride.max_negative_vertical_g;
     result.Excitement += (std::clamp<fixed16_2dp>(gforce, -FIXED_2DP(2, 50), FIXED_2DP(0, 00)) * -15728) >> 16;
     result.Intensity += ((gforce - FIXED_2DP(1, 00)) * -52428) >> 16;
     result.Nausea += ((gforce - FIXED_2DP(1, 00)) * -14563) >> 16;
 
     // Apply lateral G force factor
-    result.Excitement += (std::min<fixed16_2dp>(FIXED_2DP(1, 50), ride->max_lateral_g) * 26214) >> 16;
-    result.Intensity += ride->max_lateral_g;
-    result.Nausea += (ride->max_lateral_g * 21845) >> 16;
+    result.Excitement += (std::min<fixed16_2dp>(FIXED_2DP(1, 50), ride.max_lateral_g) * 26214) >> 16;
+    result.Intensity += ride.max_lateral_g;
+    result.Nausea += (ride.max_lateral_g * 21845) >> 16;
 
 // Very high lateral G force penalty
 #ifdef ORIGINAL_RATINGS
-    if (ride->max_lateral_g > FIXED_2DP(2, 80))
+    if (ride.max_lateral_g > FIXED_2DP(2, 80))
     {
         result.intensity += FIXED_2DP(3, 75);
         result.nausea += FIXED_2DP(2, 00);
     }
-    if (ride->max_lateral_g > FIXED_2DP(3, 10))
+    if (ride.max_lateral_g > FIXED_2DP(3, 10))
     {
         result.excitement /= 2;
         result.intensity += FIXED_2DP(8, 50);
@@ -1422,7 +1423,7 @@ static RatingTuple ride_ratings_get_gforce_ratings(Ride* ride)
  *
  *  rct2: 0x0065E139
  */
-static RatingTuple ride_ratings_get_drop_ratings(Ride* ride)
+static RatingTuple ride_ratings_get_drop_ratings(const Ride& ride)
 {
     RatingTuple result = {
         /* .excitement = */ 0,
@@ -1431,15 +1432,15 @@ static RatingTuple ride_ratings_get_drop_ratings(Ride* ride)
     };
 
     // Apply number of drops factor
-    int32_t drops = ride->drops & 0x3F;
+    int32_t drops = ride.drops & 0x3F;
     result.Excitement += (std::min(9, drops) * 728177) >> 16;
     result.Intensity += (drops * 928426) >> 16;
     result.Nausea += (drops * 655360) >> 16;
 
     // Apply highest drop factor
     ride_ratings_add(
-        &result, ((ride->highest_drop_height * 2) * 16000) >> 16, ((ride->highest_drop_height * 2) * 32000) >> 16,
-        ((ride->highest_drop_height * 2) * 10240) >> 16);
+        &result, ((ride.highest_drop_height * 2) * 16000) >> 16, ((ride.highest_drop_height * 2) * 32000) >> 16,
+        ((ride.highest_drop_height * 2) * 10240) >> 16);
 
     return result;
 }
@@ -1448,7 +1449,7 @@ static RatingTuple ride_ratings_get_drop_ratings(Ride* ride)
  * Calculates a score based on the surrounding scenery.
  *  rct2: 0x0065E557
  */
-static int32_t ride_ratings_get_scenery_score(Ride* ride)
+static int32_t ride_ratings_get_scenery_score(const Ride& ride)
 {
     auto stationIndex = ride_get_first_valid_station_start(ride);
     CoordsXY location;
@@ -1458,20 +1459,20 @@ static int32_t ride_ratings_get_scenery_score(Ride* ride)
         return 0;
     }
 
-    const auto& rtd = ride->GetRideTypeDescriptor();
+    const auto& rtd = ride.GetRideTypeDescriptor();
     if (rtd.HasFlag(RIDE_TYPE_FLAG_IS_MAZE))
     {
-        location = ride->GetStation().Entrance.ToCoordsXY();
+        location = ride.GetStation().Entrance.ToCoordsXY();
     }
     else
     {
-        location = ride->GetStation(stationIndex).Start;
+        location = ride.GetStation(stationIndex).Start;
     }
 
     int32_t z = TileElementHeight(location);
 
     // Check if station is underground, returns a fixed mediocre score since you can't have scenery underground
-    if (z > ride->GetStation(stationIndex).GetBaseZ())
+    if (z > ride.GetStation(stationIndex).GetBaseZ())
     {
         return 40;
     }
@@ -1525,47 +1526,48 @@ static void ride_ratings_add(RatingTuple* rating, int32_t excitement, int32_t in
     rating->Nausea = std::clamp<int32_t>(newNausea, 0, INT16_MAX);
 }
 
-static void ride_ratings_apply_length(RatingTuple* ratings, Ride* ride, int32_t maxLength, int32_t excitementMultiplier)
+static void ride_ratings_apply_length(RatingTuple* ratings, const Ride& ride, int32_t maxLength, int32_t excitementMultiplier)
 {
-    ride_ratings_add(ratings, (std::min(ride->GetTotalLength() >> 16, maxLength) * excitementMultiplier) >> 16, 0, 0);
+    ride_ratings_add(ratings, (std::min(ride.GetTotalLength() >> 16, maxLength) * excitementMultiplier) >> 16, 0, 0);
 }
 
-static void ride_ratings_apply_synchronisation(RatingTuple* ratings, Ride* ride, int32_t excitement, int32_t intensity)
+static void ride_ratings_apply_synchronisation(RatingTuple* ratings, const Ride& ride, int32_t excitement, int32_t intensity)
 {
-    if ((ride->depart_flags & RIDE_DEPART_SYNCHRONISE_WITH_ADJACENT_STATIONS) && ride_has_adjacent_station(ride))
+    if ((ride.depart_flags & RIDE_DEPART_SYNCHRONISE_WITH_ADJACENT_STATIONS) && ride_has_adjacent_station(ride))
     {
         ride_ratings_add(ratings, excitement, intensity, 0);
     }
 }
 
-static void ride_ratings_apply_train_length(RatingTuple* ratings, Ride* ride, int32_t excitementMultiplier)
+static void ride_ratings_apply_train_length(RatingTuple* ratings, const Ride& ride, int32_t excitementMultiplier)
 {
-    ride_ratings_add(ratings, ((ride->num_cars_per_train - 1) * excitementMultiplier) >> 16, 0, 0);
+    ride_ratings_add(ratings, ((ride.num_cars_per_train - 1) * excitementMultiplier) >> 16, 0, 0);
 }
 
 static void ride_ratings_apply_max_speed(
-    RatingTuple* ratings, Ride* ride, int32_t excitementMultiplier, int32_t intensityMultiplier, int32_t nauseaMultiplier)
+    RatingTuple* ratings, const Ride& ride, int32_t excitementMultiplier, int32_t intensityMultiplier, int32_t nauseaMultiplier)
 {
-    int32_t modifier = ride->max_speed >> 16;
+    int32_t modifier = ride.max_speed >> 16;
     ride_ratings_add(
         ratings, (modifier * excitementMultiplier) >> 16, (modifier * intensityMultiplier) >> 16,
         (modifier * nauseaMultiplier) >> 16);
 }
 
 static void ride_ratings_apply_average_speed(
-    RatingTuple* ratings, Ride* ride, int32_t excitementMultiplier, int32_t intensityMultiplier)
+    RatingTuple* ratings, const Ride& ride, int32_t excitementMultiplier, int32_t intensityMultiplier)
 {
-    int32_t modifier = ride->average_speed >> 16;
+    int32_t modifier = ride.average_speed >> 16;
     ride_ratings_add(ratings, (modifier * excitementMultiplier) >> 16, (modifier * intensityMultiplier) >> 16, 0);
 }
 
-static void ride_ratings_apply_duration(RatingTuple* ratings, Ride* ride, int32_t maxDuration, int32_t excitementMultiplier)
+static void ride_ratings_apply_duration(
+    RatingTuple* ratings, const Ride& ride, int32_t maxDuration, int32_t excitementMultiplier)
 {
-    ride_ratings_add(ratings, (std::min(ride->GetTotalTime(), maxDuration) * excitementMultiplier) >> 16, 0, 0);
+    ride_ratings_add(ratings, (std::min(ride.GetTotalTime(), maxDuration) * excitementMultiplier) >> 16, 0, 0);
 }
 
 static void ride_ratings_apply_gforces(
-    RatingTuple* ratings, Ride* ride, int32_t excitementMultiplier, int32_t intensityMultiplier, int32_t nauseaMultiplier)
+    RatingTuple* ratings, const Ride& ride, int32_t excitementMultiplier, int32_t intensityMultiplier, int32_t nauseaMultiplier)
 {
     RatingTuple subRating = ride_ratings_get_gforce_ratings(ride);
     ride_ratings_add(
@@ -1574,7 +1576,7 @@ static void ride_ratings_apply_gforces(
 }
 
 static void ride_ratings_apply_turns(
-    RatingTuple* ratings, Ride* ride, int32_t excitementMultiplier, int32_t intensityMultiplier, int32_t nauseaMultiplier)
+    RatingTuple* ratings, const Ride& ride, int32_t excitementMultiplier, int32_t intensityMultiplier, int32_t nauseaMultiplier)
 {
     RatingTuple subRating = ride_ratings_get_turns_ratings(ride);
     ride_ratings_add(
@@ -1583,7 +1585,7 @@ static void ride_ratings_apply_turns(
 }
 
 static void ride_ratings_apply_drops(
-    RatingTuple* ratings, Ride* ride, int32_t excitementMultiplier, int32_t intensityMultiplier, int32_t nauseaMultiplier)
+    RatingTuple* ratings, const Ride& ride, int32_t excitementMultiplier, int32_t intensityMultiplier, int32_t nauseaMultiplier)
 {
     RatingTuple subRating = ride_ratings_get_drop_ratings(ride);
     ride_ratings_add(
@@ -1592,7 +1594,7 @@ static void ride_ratings_apply_drops(
 }
 
 static void ride_ratings_apply_sheltered_ratings(
-    RatingTuple* ratings, Ride* ride, int32_t excitementMultiplier, int32_t intensityMultiplier, int32_t nauseaMultiplier)
+    RatingTuple* ratings, const Ride& ride, int32_t excitementMultiplier, int32_t intensityMultiplier, int32_t nauseaMultiplier)
 {
     RatingTuple subRating = ride_ratings_get_sheltered_ratings(ride);
     ride_ratings_add(
@@ -1601,19 +1603,19 @@ static void ride_ratings_apply_sheltered_ratings(
 }
 
 static void ride_ratings_apply_operation_option(
-    RatingTuple* ratings, Ride* ride, int32_t excitementMultiplier, int32_t intensityMultiplier, int32_t nauseaMultiplier)
+    RatingTuple* ratings, const Ride& ride, int32_t excitementMultiplier, int32_t intensityMultiplier, int32_t nauseaMultiplier)
 {
     ride_ratings_add(
-        ratings, (ride->operation_option * excitementMultiplier) >> 16, (ride->operation_option * intensityMultiplier) >> 16,
-        (ride->operation_option * nauseaMultiplier) >> 16);
+        ratings, (ride.operation_option * excitementMultiplier) >> 16, (ride.operation_option * intensityMultiplier) >> 16,
+        (ride.operation_option * nauseaMultiplier) >> 16);
 }
 
 static void ride_ratings_apply_rotations(
-    RatingTuple* ratings, Ride* ride, int32_t excitementMultiplier, int32_t intensityMultiplier, int32_t nauseaMultiplier)
+    RatingTuple* ratings, const Ride& ride, int32_t excitementMultiplier, int32_t intensityMultiplier, int32_t nauseaMultiplier)
 {
     ride_ratings_add(
-        ratings, ride->rotations * excitementMultiplier, ride->rotations * intensityMultiplier,
-        ride->rotations * nauseaMultiplier);
+        ratings, ride.rotations * excitementMultiplier, ride.rotations * intensityMultiplier,
+        ride.rotations * nauseaMultiplier);
 }
 
 static void ride_ratings_apply_proximity(RideRatingUpdateState& state, RatingTuple* ratings, int32_t excitementMultiplier)
@@ -1621,16 +1623,16 @@ static void ride_ratings_apply_proximity(RideRatingUpdateState& state, RatingTup
     ride_ratings_add(ratings, (ride_ratings_get_proximity_score(state) * excitementMultiplier) >> 16, 0, 0);
 }
 
-static void ride_ratings_apply_scenery(RatingTuple* ratings, Ride* ride, int32_t excitementMultiplier)
+static void ride_ratings_apply_scenery(RatingTuple* ratings, const Ride& ride, int32_t excitementMultiplier)
 {
     ride_ratings_add(ratings, (ride_ratings_get_scenery_score(ride) * excitementMultiplier) >> 16, 0, 0);
 }
 
 static void ride_ratings_apply_highest_drop_height_penalty(
-    RatingTuple* ratings, Ride* ride, int32_t minHighestDropHeight, int32_t excitementPenalty, int32_t intensityPenalty,
+    RatingTuple* ratings, const Ride& ride, int32_t minHighestDropHeight, int32_t excitementPenalty, int32_t intensityPenalty,
     int32_t nauseaPenalty)
 {
-    if (ride->highest_drop_height < minHighestDropHeight)
+    if (ride.highest_drop_height < minHighestDropHeight)
     {
         ratings->Excitement /= excitementPenalty;
         ratings->Intensity /= intensityPenalty;
@@ -1639,10 +1641,10 @@ static void ride_ratings_apply_highest_drop_height_penalty(
 }
 
 static void ride_ratings_apply_max_speed_penalty(
-    RatingTuple* ratings, Ride* ride, int32_t minMaxSpeed, int32_t excitementPenalty, int32_t intensityPenalty,
+    RatingTuple* ratings, const Ride& ride, int32_t minMaxSpeed, int32_t excitementPenalty, int32_t intensityPenalty,
     int32_t nauseaPenalty)
 {
-    if (ride->max_speed < minMaxSpeed)
+    if (ride.max_speed < minMaxSpeed)
     {
         ratings->Excitement /= excitementPenalty;
         ratings->Intensity /= intensityPenalty;
@@ -1651,10 +1653,10 @@ static void ride_ratings_apply_max_speed_penalty(
 }
 
 static void ride_ratings_apply_num_drops_penalty(
-    RatingTuple* ratings, Ride* ride, int32_t minNumDrops, int32_t excitementPenalty, int32_t intensityPenalty,
+    RatingTuple* ratings, const Ride& ride, int32_t minNumDrops, int32_t excitementPenalty, int32_t intensityPenalty,
     int32_t nauseaPenalty)
 {
-    if ((ride->drops & 0x3F) < minNumDrops)
+    if ((ride.drops & 0x3F) < minNumDrops)
     {
         ratings->Excitement /= excitementPenalty;
         ratings->Intensity /= intensityPenalty;
@@ -1663,10 +1665,10 @@ static void ride_ratings_apply_num_drops_penalty(
 }
 
 static void ride_ratings_apply_max_negative_g_penalty(
-    RatingTuple* ratings, Ride* ride, int32_t maxMaxNegativeVerticalG, int32_t excitementPenalty, int32_t intensityPenalty,
-    int32_t nauseaPenalty)
+    RatingTuple* ratings, const Ride& ride, int32_t maxMaxNegativeVerticalG, int32_t excitementPenalty,
+    int32_t intensityPenalty, int32_t nauseaPenalty)
 {
-    if (ride->max_negative_vertical_g >= maxMaxNegativeVerticalG)
+    if (ride.max_negative_vertical_g >= maxMaxNegativeVerticalG)
     {
         ratings->Excitement /= excitementPenalty;
         ratings->Intensity /= intensityPenalty;
@@ -1675,10 +1677,10 @@ static void ride_ratings_apply_max_negative_g_penalty(
 }
 
 static void ride_ratings_apply_max_lateral_g_penalty(
-    RatingTuple* ratings, Ride* ride, int32_t minMaxLateralG, int32_t excitementPenalty, int32_t intensityPenalty,
+    RatingTuple* ratings, const Ride& ride, int32_t minMaxLateralG, int32_t excitementPenalty, int32_t intensityPenalty,
     int32_t nauseaPenalty)
 {
-    if (ride->max_lateral_g < minMaxLateralG)
+    if (ride.max_lateral_g < minMaxLateralG)
     {
         ratings->Excitement /= excitementPenalty;
         ratings->Intensity /= intensityPenalty;
@@ -1686,26 +1688,26 @@ static void ride_ratings_apply_max_lateral_g_penalty(
     }
 }
 
-static RatingTuple ride_ratings_get_excessive_lateral_g_penalty(Ride* ride)
+static RatingTuple ride_ratings_get_excessive_lateral_g_penalty(const Ride& ride)
 {
     RatingTuple result{};
-    if (ride->max_lateral_g > FIXED_2DP(2, 80))
+    if (ride.max_lateral_g > FIXED_2DP(2, 80))
     {
         result.Intensity = FIXED_2DP(3, 75);
         result.Nausea = FIXED_2DP(2, 00);
     }
 
-    if (ride->max_lateral_g > FIXED_2DP(3, 10))
+    if (ride.max_lateral_g > FIXED_2DP(3, 10))
     {
         // Remove half of the ride_ratings_get_gforce_ratings
-        result.Excitement = (ride->max_positive_vertical_g * 5242) >> 16;
+        result.Excitement = (ride.max_positive_vertical_g * 5242) >> 16;
 
         // Apply maximum negative G force factor
-        fixed16_2dp gforce = ride->max_negative_vertical_g;
+        fixed16_2dp gforce = ride.max_negative_vertical_g;
         result.Excitement += (std::clamp<fixed16_2dp>(gforce, -FIXED_2DP(2, 50), FIXED_2DP(0, 00)) * -15728) >> 16;
 
         // Apply lateral G force factor
-        result.Excitement += (std::min<fixed16_2dp>(FIXED_2DP(1, 50), ride->max_lateral_g) * 26214) >> 16;
+        result.Excitement += (std::min<fixed16_2dp>(FIXED_2DP(1, 50), ride.max_lateral_g) * 26214) >> 16;
 
         // Remove half of the ride_ratings_get_gforce_ratings
         result.Excitement /= 2;
@@ -1717,7 +1719,7 @@ static RatingTuple ride_ratings_get_excessive_lateral_g_penalty(Ride* ride)
 }
 
 static void ride_ratings_apply_excessive_lateral_g_penalty(
-    RatingTuple* ratings, Ride* ride, int32_t excitementMultiplier, int32_t intensityMultiplier, int32_t nauseaMultiplier)
+    RatingTuple* ratings, const Ride& ride, int32_t excitementMultiplier, int32_t intensityMultiplier, int32_t nauseaMultiplier)
 {
 #ifndef ORIGINAL_RATINGS
     RatingTuple subRating = ride_ratings_get_excessive_lateral_g_penalty(ride);
@@ -1728,10 +1730,10 @@ static void ride_ratings_apply_excessive_lateral_g_penalty(
 }
 
 static void ride_ratings_apply_first_length_penalty(
-    RatingTuple* ratings, Ride* ride, int32_t minFirstLength, int32_t excitementPenalty, int32_t intensityPenalty,
+    RatingTuple* ratings, const Ride& ride, int32_t minFirstLength, int32_t excitementPenalty, int32_t intensityPenalty,
     int32_t nauseaPenalty)
 {
-    if (ride->GetStation().SegmentLength < minFirstLength)
+    if (ride.GetStation().SegmentLength < minFirstLength)
     {
         ratings->Excitement /= excitementPenalty;
         ratings->Intensity /= intensityPenalty;
@@ -1743,12 +1745,12 @@ static void ride_ratings_apply_first_length_penalty(
 
 #pragma region Ride rating calculation functions
 
-void ride_ratings_calculate_spiral_roller_coaster(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_spiral_roller_coaster(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 14;
+    ride.unreliability_factor = 14;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -1766,12 +1768,12 @@ void ride_ratings_calculate_spiral_roller_coaster(Ride* ride, RideRatingUpdateSt
     ride_ratings_apply_proximity(state, &ratings, 20130);
     ride_ratings_apply_scenery(&ratings, ride, 6693);
 
-    if (ride->inversions == 0)
+    if (ride.inversions == 0)
         ride_ratings_apply_highest_drop_height_penalty(&ratings, ride, 12, 2, 2, 2);
 
     ride_ratings_apply_max_speed_penalty(&ratings, ride, 0xA0000, 2, 2, 2);
 
-    if (ride->inversions == 0)
+    if (ride.inversions == 0)
     {
         ride_ratings_apply_max_negative_g_penalty(&ratings, ride, FIXED_2DP(0, 40), 2, 2, 2);
         ride_ratings_apply_num_drops_penalty(&ratings, ride, 2, 2, 2, 2);
@@ -1781,20 +1783,20 @@ void ride_ratings_calculate_spiral_roller_coaster(Ride* ride, RideRatingUpdateSt
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
+    ride.sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
 }
 
-void ride_ratings_calculate_stand_up_roller_coaster(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_stand_up_roller_coaster(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 17;
+    ride.unreliability_factor = 17;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -1819,20 +1821,20 @@ void ride_ratings_calculate_stand_up_roller_coaster(Ride* ride, RideRatingUpdate
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
+    ride.sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
 }
 
-void ride_ratings_calculate_suspended_swinging_coaster(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_suspended_swinging_coaster(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 18;
+    ride.unreliability_factor = 18;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -1859,20 +1861,20 @@ void ride_ratings_calculate_suspended_swinging_coaster(Ride* ride, RideRatingUpd
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
+    ride.sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
 }
 
-void ride_ratings_calculate_inverted_roller_coaster(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_inverted_roller_coaster(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 17;
+    ride.unreliability_factor = 17;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -1890,32 +1892,32 @@ void ride_ratings_calculate_inverted_roller_coaster(Ride* ride, RideRatingUpdate
     ride_ratings_apply_proximity(state, &ratings, 15657);
     ride_ratings_apply_scenery(&ratings, ride, 8366);
 
-    if (ride->inversions == 0)
+    if (ride.inversions == 0)
         ride_ratings_apply_highest_drop_height_penalty(&ratings, ride, 12, 2, 2, 2);
 
     ride_ratings_apply_max_speed_penalty(&ratings, ride, 0xA0000, 2, 2, 2);
 
-    if (ride->inversions == 0)
+    if (ride.inversions == 0)
         ride_ratings_apply_max_negative_g_penalty(&ratings, ride, FIXED_2DP(0, 30), 2, 2, 2);
 
     ride_ratings_apply_excessive_lateral_g_penalty(&ratings, ride, 24576, 29789, 55606);
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
+    ride.sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
 }
 
-void ride_ratings_calculate_junior_roller_coaster(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_junior_roller_coaster(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 13;
+    ride.unreliability_factor = 13;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -1940,20 +1942,20 @@ void ride_ratings_calculate_junior_roller_coaster(Ride* ride, RideRatingUpdateSt
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
+    ride.sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
 }
 
-void ride_ratings_calculate_miniature_railway(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_miniature_railway(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 11;
+    ride.unreliability_factor = 11;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -1971,24 +1973,24 @@ void ride_ratings_calculate_miniature_railway(Ride* ride, RideRatingUpdateState&
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
     auto shelteredEighths = get_num_of_sheltered_eighths(ride);
     if (shelteredEighths.TrackShelteredEighths >= 4)
-        ride->excitement /= 4;
+        ride.excitement /= 4;
 
-    ride->sheltered_eighths = shelteredEighths.TotalShelteredEighths;
+    ride.sheltered_eighths = shelteredEighths.TotalShelteredEighths;
 }
 
-void ride_ratings_calculate_monorail(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_monorail(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 14;
+    ride.unreliability_factor = 14;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -2006,24 +2008,24 @@ void ride_ratings_calculate_monorail(Ride* ride, RideRatingUpdateState& state)
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
     auto shelteredEighths = get_num_of_sheltered_eighths(ride);
     if (shelteredEighths.TrackShelteredEighths >= 4)
-        ride->excitement /= 4;
+        ride.excitement /= 4;
 
-    ride->sheltered_eighths = shelteredEighths.TotalShelteredEighths;
+    ride.sheltered_eighths = shelteredEighths.TotalShelteredEighths;
 }
 
-void ride_ratings_calculate_mini_suspended_coaster(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_mini_suspended_coaster(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 15;
+    ride.unreliability_factor = 15;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -2049,17 +2051,17 @@ void ride_ratings_calculate_mini_suspended_coaster(Ride* ride, RideRatingUpdateS
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
+    ride.sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
 }
 
-void ride_ratings_calculate_boat_hire(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_boat_hire(Ride& ride, RideRatingUpdateState& state)
 {
-    ride->unreliability_factor = 7;
+    ride.unreliability_factor = 7;
     set_unreliability_factor(ride);
 
     // NOTE In the original game, the ratings were zeroed before calling set_unreliability_factor which is unusual as rest
@@ -2070,7 +2072,7 @@ void ride_ratings_calculate_boat_hire(Ride* ride, RideRatingUpdateState& state)
     ride_ratings_set(&ratings, RIDE_RATING(1, 90), RIDE_RATING(0, 80), RIDE_RATING(0, 90));
 
     // Most likely checking if the ride has does not have a circuit
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
     {
         ride_ratings_add(&ratings, RIDE_RATING(0, 20), 0, 0);
     }
@@ -2081,20 +2083,20 @@ void ride_ratings_calculate_boat_hire(Ride* ride, RideRatingUpdateState& state)
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = 0;
+    ride.sheltered_eighths = 0;
 }
 
-void ride_ratings_calculate_wooden_wild_mouse(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_wooden_wild_mouse(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 14;
+    ride.unreliability_factor = 14;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -2122,20 +2124,20 @@ void ride_ratings_calculate_wooden_wild_mouse(Ride* ride, RideRatingUpdateState&
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
+    ride.sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
 }
 
-void ride_ratings_calculate_steeplechase(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_steeplechase(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 14;
+    ride.unreliability_factor = 14;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -2162,20 +2164,20 @@ void ride_ratings_calculate_steeplechase(Ride* ride, RideRatingUpdateState& stat
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
+    ride.sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
 }
 
-void ride_ratings_calculate_car_ride(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_car_ride(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 12;
+    ride.unreliability_factor = 12;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -2196,38 +2198,38 @@ void ride_ratings_calculate_car_ride(Ride* ride, RideRatingUpdateState& state)
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
+    ride.sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
 }
 
-void ride_ratings_calculate_launched_freefall(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_launched_freefall(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 16;
+    ride.unreliability_factor = 16;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
     ride_ratings_set(&ratings, RIDE_RATING(2, 70), RIDE_RATING(3, 00), RIDE_RATING(3, 50));
 
-    if (ride->mode == RideMode::DownwardLaunch)
+    if (ride.mode == RideMode::DownwardLaunch)
     {
         ride_ratings_add(&ratings, RIDE_RATING(0, 30), RIDE_RATING(0, 65), RIDE_RATING(0, 45));
     }
 
-    int32_t excitementModifier = ((ride->GetTotalLength() >> 16) * 32768) >> 16;
+    int32_t excitementModifier = ((ride.GetTotalLength() >> 16) * 32768) >> 16;
     ride_ratings_add(&ratings, excitementModifier, 0, 0);
 
 #ifdef ORIGINAL_RATINGS
     ride_ratings_apply_operation_option(&ratings, ride, 0, 1355917, 451972);
 #else
     // Only apply "launch speed" effects when the setting can be modified
-    if (ride->mode == RideMode::UpwardLaunch)
+    if (ride.mode == RideMode::UpwardLaunch)
     {
         ride_ratings_apply_operation_option(&ratings, ride, 0, 1355917, 451972);
     }
@@ -2236,7 +2238,7 @@ void ride_ratings_calculate_launched_freefall(Ride* ride, RideRatingUpdateState&
         // Fix #3282: When the ride mode is in downward launch mode, the intensity and
         //            nausea were fixed regardless of how high the ride is. The following
         //            calculation is based on roto-drop which is a similar mechanic.
-        int32_t lengthFactor = ((ride->GetTotalLength() >> 16) * 209715) >> 16;
+        int32_t lengthFactor = ((ride.GetTotalLength() >> 16) * 209715) >> 16;
         ride_ratings_add(&ratings, lengthFactor, lengthFactor * 2, lengthFactor * 2);
     }
 #endif
@@ -2247,20 +2249,20 @@ void ride_ratings_calculate_launched_freefall(Ride* ride, RideRatingUpdateState&
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
+    ride.sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
 }
 
-void ride_ratings_calculate_bobsleigh_coaster(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_bobsleigh_coaster(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 16;
+    ride.unreliability_factor = 16;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -2285,50 +2287,49 @@ void ride_ratings_calculate_bobsleigh_coaster(Ride* ride, RideRatingUpdateState&
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
+    ride.sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
 }
 
-void ride_ratings_calculate_observation_tower(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_observation_tower(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 15;
+    ride.unreliability_factor = 15;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
     ride_ratings_set(&ratings, RIDE_RATING(1, 50), RIDE_RATING(0, 00), RIDE_RATING(0, 10));
-    ride_ratings_add(
-        &ratings, ((ride->GetTotalLength() >> 16) * 45875) >> 16, 0, ((ride->GetTotalLength() >> 16) * 26214) >> 16);
+    ride_ratings_add(&ratings, ((ride.GetTotalLength() >> 16) * 45875) >> 16, 0, ((ride.GetTotalLength() >> 16) * 26214) >> 16);
     ride_ratings_apply_proximity(state, &ratings, 20130);
     ride_ratings_apply_scenery(&ratings, ride, 83662);
 
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = 7;
+    ride.sheltered_eighths = 7;
 
     auto shelteredEighths = get_num_of_sheltered_eighths(ride);
     if (shelteredEighths.TrackShelteredEighths >= 5)
-        ride->excitement /= 4;
+        ride.excitement /= 4;
 }
 
-void ride_ratings_calculate_looping_roller_coaster(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_looping_roller_coaster(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = ride->IsPoweredLaunched() ? 20 : 15;
+    ride.unreliability_factor = ride.IsPoweredLaunched() ? 20 : 15;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -2346,12 +2347,12 @@ void ride_ratings_calculate_looping_roller_coaster(Ride* ride, RideRatingUpdateS
     ride_ratings_apply_proximity(state, &ratings, 20130);
     ride_ratings_apply_scenery(&ratings, ride, 6693);
 
-    if (ride->inversions == 0)
+    if (ride.inversions == 0)
         ride_ratings_apply_highest_drop_height_penalty(&ratings, ride, 14, 2, 2, 2);
 
     ride_ratings_apply_max_speed_penalty(&ratings, ride, 0xA0000, 2, 2, 2);
 
-    if (ride->inversions == 0)
+    if (ride.inversions == 0)
     {
         ride_ratings_apply_max_negative_g_penalty(&ratings, ride, FIXED_2DP(0, 10), 2, 2, 2);
         ride_ratings_apply_num_drops_penalty(&ratings, ride, 2, 2, 2, 2);
@@ -2361,20 +2362,20 @@ void ride_ratings_calculate_looping_roller_coaster(Ride* ride, RideRatingUpdateS
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
+    ride.sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
 }
 
-void ride_ratings_calculate_dinghy_slide(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_dinghy_slide(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 13;
+    ride.unreliability_factor = 13;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -2399,20 +2400,20 @@ void ride_ratings_calculate_dinghy_slide(Ride* ride, RideRatingUpdateState& stat
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
+    ride.sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
 }
 
-void ride_ratings_calculate_mine_train_coaster(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_mine_train_coaster(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 16;
+    ride.unreliability_factor = 16;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -2439,20 +2440,20 @@ void ride_ratings_calculate_mine_train_coaster(Ride* ride, RideRatingUpdateState
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
+    ride.sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
 }
 
-void ride_ratings_calculate_chairlift(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_chairlift(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 14 + (ride->speed * 2);
+    ride.unreliability_factor = 14 + (ride.speed * 2);
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -2471,30 +2472,30 @@ void ride_ratings_calculate_chairlift(Ride* ride, RideRatingUpdateState& state)
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    if (ride->num_stations <= 1)
+    if (ride.num_stations <= 1)
     {
         ratings.Excitement = 0;
         ratings.Intensity /= 2;
     }
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
     auto shelteredEighths = get_num_of_sheltered_eighths(ride);
     if (shelteredEighths.TrackShelteredEighths >= 4)
-        ride->excitement /= 4;
+        ride.excitement /= 4;
 
-    ride->sheltered_eighths = shelteredEighths.TotalShelteredEighths;
+    ride.sheltered_eighths = shelteredEighths.TotalShelteredEighths;
 }
 
-void ride_ratings_calculate_corkscrew_roller_coaster(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_corkscrew_roller_coaster(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 16;
+    ride.unreliability_factor = 16;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -2512,12 +2513,12 @@ void ride_ratings_calculate_corkscrew_roller_coaster(Ride* ride, RideRatingUpdat
     ride_ratings_apply_proximity(state, &ratings, 20130);
     ride_ratings_apply_scenery(&ratings, ride, 6693);
 
-    if (ride->inversions == 0)
+    if (ride.inversions == 0)
         ride_ratings_apply_highest_drop_height_penalty(&ratings, ride, 12, 2, 2, 2);
 
     ride_ratings_apply_max_speed_penalty(&ratings, ride, 0xA0000, 2, 2, 2);
 
-    if (ride->inversions == 0)
+    if (ride.inversions == 0)
     {
         ride_ratings_apply_max_negative_g_penalty(&ratings, ride, FIXED_2DP(0, 40), 2, 2, 2);
         ride_ratings_apply_num_drops_penalty(&ratings, ride, 2, 2, 2, 2);
@@ -2527,25 +2528,25 @@ void ride_ratings_calculate_corkscrew_roller_coaster(Ride* ride, RideRatingUpdat
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
+    ride.sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
 }
 
-void ride_ratings_calculate_maze(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_maze(Ride& ride, RideRatingUpdateState& state)
 {
-    ride->lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
-    ride->lifecycle_flags |= RIDE_LIFECYCLE_NO_RAW_STATS;
-    ride->unreliability_factor = 8;
+    ride.lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
+    ride.lifecycle_flags |= RIDE_LIFECYCLE_NO_RAW_STATS;
+    ride.unreliability_factor = 8;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
     ride_ratings_set(&ratings, RIDE_RATING(1, 30), RIDE_RATING(0, 50), RIDE_RATING(0, 00));
 
-    int32_t size = std::min<uint16_t>(ride->maze_tiles, 100);
+    int32_t size = std::min<uint16_t>(ride.maze_tiles, 100);
     ride_ratings_add(&ratings, size, size * 2, 0);
 
     ride_ratings_apply_scenery(&ratings, ride, 22310);
@@ -2553,26 +2554,26 @@ void ride_ratings_calculate_maze(Ride* ride, RideRatingUpdateState& state)
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = 0;
+    ride.sheltered_eighths = 0;
 }
 
-void ride_ratings_calculate_spiral_slide(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_spiral_slide(Ride& ride, RideRatingUpdateState& state)
 {
-    ride->lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
-    ride->lifecycle_flags |= RIDE_LIFECYCLE_NO_RAW_STATS;
-    ride->unreliability_factor = 8;
+    ride.lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
+    ride.lifecycle_flags |= RIDE_LIFECYCLE_NO_RAW_STATS;
+    ride.unreliability_factor = 8;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
     ride_ratings_set(&ratings, RIDE_RATING(1, 50), RIDE_RATING(1, 40), RIDE_RATING(0, 90));
 
     // Unlimited slides boost
-    if (ride->mode == RideMode::UnlimitedRidesPerAdmission)
+    if (ride.mode == RideMode::UnlimitedRidesPerAdmission)
     {
         ride_ratings_add(&ratings, RIDE_RATING(0, 40), RIDE_RATING(0, 20), RIDE_RATING(0, 25));
     }
@@ -2582,31 +2583,31 @@ void ride_ratings_calculate_spiral_slide(Ride* ride, RideRatingUpdateState& stat
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = 2;
+    ride.sheltered_eighths = 2;
 }
 
-void ride_ratings_calculate_go_karts(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_go_karts(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 16;
+    ride.unreliability_factor = 16;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
     ride_ratings_set(&ratings, RIDE_RATING(1, 42), RIDE_RATING(1, 73), RIDE_RATING(0, 40));
     ride_ratings_apply_length(&ratings, ride, 700, 32768);
 
-    if (ride->mode == RideMode::Race && ride->NumTrains >= 4)
+    if (ride.mode == RideMode::Race && ride.NumTrains >= 4)
     {
         ride_ratings_add(&ratings, RIDE_RATING(1, 40), RIDE_RATING(0, 50), 0);
 
-        int32_t lapsFactor = (ride->NumLaps - 1) * 30;
+        int32_t lapsFactor = (ride.NumLaps - 1) * 30;
         ride_ratings_add(&ratings, lapsFactor, lapsFactor / 2, 0);
     }
 
@@ -2619,24 +2620,24 @@ void ride_ratings_calculate_go_karts(Ride* ride, RideRatingUpdateState& state)
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
     auto shelteredEighths = get_num_of_sheltered_eighths(ride);
-    ride->sheltered_eighths = shelteredEighths.TotalShelteredEighths;
+    ride.sheltered_eighths = shelteredEighths.TotalShelteredEighths;
 
     if (shelteredEighths.TrackShelteredEighths >= 6)
-        ride->excitement /= 2;
+        ride.excitement /= 2;
 }
 
-void ride_ratings_calculate_log_flume(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_log_flume(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 15;
+    ride.unreliability_factor = 15;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -2655,20 +2656,20 @@ void ride_ratings_calculate_log_flume(Ride* ride, RideRatingUpdateState& state)
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
+    ride.sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
 }
 
-void ride_ratings_calculate_river_rapids(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_river_rapids(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 16;
+    ride.unreliability_factor = 16;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -2688,32 +2689,32 @@ void ride_ratings_calculate_river_rapids(Ride* ride, RideRatingUpdateState& stat
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
+    ride.sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
 }
 
-void ride_ratings_calculate_dodgems(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_dodgems(Ride& ride, RideRatingUpdateState& state)
 {
-    ride->lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
-    ride->lifecycle_flags |= RIDE_LIFECYCLE_NO_RAW_STATS;
-    ride->unreliability_factor = 16;
+    ride.lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
+    ride.lifecycle_flags |= RIDE_LIFECYCLE_NO_RAW_STATS;
+    ride.unreliability_factor = 16;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
     ride_ratings_set(&ratings, RIDE_RATING(1, 30), RIDE_RATING(0, 50), RIDE_RATING(0, 35));
 
-    if (ride->NumTrains >= 4)
+    if (ride.NumTrains >= 4)
     {
         ride_ratings_add(&ratings, RIDE_RATING(0, 40), 0, 0);
     }
 
-    ride_ratings_add(&ratings, ride->operation_option, ride->operation_option / 2, 0);
+    ride_ratings_add(&ratings, ride.operation_option, ride.operation_option / 2, 0);
 
-    if (ride->NumTrains >= 4)
+    if (ride.NumTrains >= 4)
     {
         ride_ratings_add(&ratings, RIDE_RATING(0, 40), 0, 0);
     }
@@ -2723,87 +2724,87 @@ void ride_ratings_calculate_dodgems(Ride* ride, RideRatingUpdateState& state)
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = 7;
+    ride.sheltered_eighths = 7;
 }
 
-void ride_ratings_calculate_swinging_ship(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_swinging_ship(Ride& ride, RideRatingUpdateState& state)
 {
-    ride->lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
-    ride->lifecycle_flags |= RIDE_LIFECYCLE_NO_RAW_STATS;
-    ride->unreliability_factor = 10;
+    ride.lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
+    ride.lifecycle_flags |= RIDE_LIFECYCLE_NO_RAW_STATS;
+    ride.unreliability_factor = 10;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
     ride_ratings_set(&ratings, RIDE_RATING(1, 50), RIDE_RATING(1, 90), RIDE_RATING(1, 41));
 
-    ride_ratings_add(&ratings, ride->operation_option * 5, ride->operation_option * 5, ride->operation_option * 10);
+    ride_ratings_add(&ratings, ride.operation_option * 5, ride.operation_option * 5, ride.operation_option * 10);
 
     ride_ratings_apply_scenery(&ratings, ride, 16732);
 
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = 0;
+    ride.sheltered_eighths = 0;
 }
 
-void ride_ratings_calculate_inverter_ship(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_inverter_ship(Ride& ride, RideRatingUpdateState& state)
 {
-    ride->lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
-    ride->lifecycle_flags |= RIDE_LIFECYCLE_NO_RAW_STATS;
-    ride->unreliability_factor = 16;
+    ride.lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
+    ride.lifecycle_flags |= RIDE_LIFECYCLE_NO_RAW_STATS;
+    ride.unreliability_factor = 16;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
     ride_ratings_set(&ratings, RIDE_RATING(2, 50), RIDE_RATING(2, 70), RIDE_RATING(2, 74));
 
-    ride_ratings_add(&ratings, ride->operation_option * 11, ride->operation_option * 22, ride->operation_option * 22);
+    ride_ratings_add(&ratings, ride.operation_option * 11, ride.operation_option * 22, ride.operation_option * 22);
 
     ride_ratings_apply_scenery(&ratings, ride, 11155);
 
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = 0;
+    ride.sheltered_eighths = 0;
 }
 
-void ride_ratings_calculate_food_stall(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_food_stall(Ride& ride, RideRatingUpdateState& state)
 {
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 }
 
-void ride_ratings_calculate_drink_stall(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_drink_stall(Ride& ride, RideRatingUpdateState& state)
 {
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 }
 
-void ride_ratings_calculate_shop(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_shop(Ride& ride, RideRatingUpdateState& state)
 {
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 }
 
-void ride_ratings_calculate_merry_go_round(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_merry_go_round(Ride& ride, RideRatingUpdateState& state)
 {
-    ride->lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
-    ride->lifecycle_flags |= RIDE_LIFECYCLE_NO_RAW_STATS;
-    ride->unreliability_factor = 16;
+    ride.lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
+    ride.lifecycle_flags |= RIDE_LIFECYCLE_NO_RAW_STATS;
+    ride.unreliability_factor = 16;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -2813,31 +2814,31 @@ void ride_ratings_calculate_merry_go_round(Ride* ride, RideRatingUpdateState& st
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = 7;
+    ride.sheltered_eighths = 7;
 }
 
-void ride_ratings_calculate_information_kiosk(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_information_kiosk(Ride& ride, RideRatingUpdateState& state)
 {
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 }
 
-void ride_ratings_calculate_toilets(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_toilets(Ride& ride, RideRatingUpdateState& state)
 {
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 }
 
-void ride_ratings_calculate_ferris_wheel(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_ferris_wheel(Ride& ride, RideRatingUpdateState& state)
 {
-    ride->lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
-    ride->lifecycle_flags |= RIDE_LIFECYCLE_NO_RAW_STATS;
-    ride->unreliability_factor = 16;
+    ride.lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
+    ride.lifecycle_flags |= RIDE_LIFECYCLE_NO_RAW_STATS;
+    ride.unreliability_factor = 16;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -2847,24 +2848,24 @@ void ride_ratings_calculate_ferris_wheel(Ride* ride, RideRatingUpdateState& stat
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = 0;
+    ride.sheltered_eighths = 0;
 }
 
-void ride_ratings_calculate_motion_simulator(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_motion_simulator(Ride& ride, RideRatingUpdateState& state)
 {
-    ride->lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
-    ride->lifecycle_flags |= RIDE_LIFECYCLE_NO_RAW_STATS;
-    ride->unreliability_factor = 21;
+    ride.lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
+    ride.lifecycle_flags |= RIDE_LIFECYCLE_NO_RAW_STATS;
+    ride.unreliability_factor = 21;
     set_unreliability_factor(ride);
 
     // Base ratings
     RatingTuple ratings;
-    if (ride->mode == RideMode::FilmThrillRiders)
+    if (ride.mode == RideMode::FilmThrillRiders)
     {
         ratings.Excitement = RIDE_RATING(3, 25);
         ratings.Intensity = RIDE_RATING(4, 10);
@@ -2880,24 +2881,24 @@ void ride_ratings_calculate_motion_simulator(Ride* ride, RideRatingUpdateState&
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = 7;
+    ride.sheltered_eighths = 7;
 }
 
-void ride_ratings_calculate_3d_cinema(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_3d_cinema(Ride& ride, RideRatingUpdateState& state)
 {
-    ride->lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
-    ride->lifecycle_flags |= RIDE_LIFECYCLE_NO_RAW_STATS;
-    ride->unreliability_factor = 21;
+    ride.lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
+    ride.lifecycle_flags |= RIDE_LIFECYCLE_NO_RAW_STATS;
+    ride.unreliability_factor = 21;
     set_unreliability_factor(ride);
 
     // Base ratings
     RatingTuple ratings;
-    switch (ride->mode)
+    switch (ride.mode)
     {
         default:
         case RideMode::MouseTails3DFilm:
@@ -2920,24 +2921,24 @@ void ride_ratings_calculate_3d_cinema(Ride* ride, RideRatingUpdateState& state)
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths |= 7;
+    ride.sheltered_eighths |= 7;
 }
 
-void ride_ratings_calculate_top_spin(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_top_spin(Ride& ride, RideRatingUpdateState& state)
 {
-    ride->lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
-    ride->lifecycle_flags |= RIDE_LIFECYCLE_NO_RAW_STATS;
-    ride->unreliability_factor = 19;
+    ride.lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
+    ride.lifecycle_flags |= RIDE_LIFECYCLE_NO_RAW_STATS;
+    ride.unreliability_factor = 19;
     set_unreliability_factor(ride);
 
     // Base ratings
     RatingTuple ratings;
-    switch (ride->mode)
+    switch (ride.mode)
     {
         default:
         case RideMode::Beginners:
@@ -2962,19 +2963,19 @@ void ride_ratings_calculate_top_spin(Ride* ride, RideRatingUpdateState& state)
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = 0;
+    ride.sheltered_eighths = 0;
 }
 
-void ride_ratings_calculate_space_rings(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_space_rings(Ride& ride, RideRatingUpdateState& state)
 {
-    ride->lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
-    ride->lifecycle_flags |= RIDE_LIFECYCLE_NO_RAW_STATS;
-    ride->unreliability_factor = 7;
+    ride.lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
+    ride.lifecycle_flags |= RIDE_LIFECYCLE_NO_RAW_STATS;
+    ride.unreliability_factor = 7;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -2984,20 +2985,20 @@ void ride_ratings_calculate_space_rings(Ride* ride, RideRatingUpdateState& state
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = 0;
+    ride.sheltered_eighths = 0;
 }
 
-void ride_ratings_calculate_reverse_freefall_coaster(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_reverse_freefall_coaster(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 25;
+    ride.unreliability_factor = 25;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -3014,26 +3015,26 @@ void ride_ratings_calculate_reverse_freefall_coaster(Ride* ride, RideRatingUpdat
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
+    ride.sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
 }
 
-void ride_ratings_calculate_lift(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_lift(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 15;
+    ride.unreliability_factor = 15;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
     ride_ratings_set(&ratings, RIDE_RATING(1, 11), RIDE_RATING(0, 35), RIDE_RATING(0, 30));
 
-    int32_t totalLength = ride->GetTotalLength() >> 16;
+    int32_t totalLength = ride.GetTotalLength() >> 16;
     ride_ratings_add(&ratings, (totalLength * 45875) >> 16, 0, (totalLength * 26214) >> 16);
 
     ride_ratings_apply_proximity(state, &ratings, 11183);
@@ -3042,23 +3043,23 @@ void ride_ratings_calculate_lift(Ride* ride, RideRatingUpdateState& state)
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = 7;
+    ride.sheltered_eighths = 7;
 
     if ((get_num_of_sheltered_eighths(ride).TrackShelteredEighths) >= 5)
-        ride->excitement /= 4;
+        ride.excitement /= 4;
 }
 
-void ride_ratings_calculate_vertical_drop_roller_coaster(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_vertical_drop_roller_coaster(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 16;
+    ride.unreliability_factor = 16;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -3083,25 +3084,25 @@ void ride_ratings_calculate_vertical_drop_roller_coaster(Ride* ride, RideRatingU
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
+    ride.sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
 }
 
-void ride_ratings_calculate_cash_machine(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_cash_machine(Ride& ride, RideRatingUpdateState& state)
 {
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 }
 
-void ride_ratings_calculate_twist(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_twist(Ride& ride, RideRatingUpdateState& state)
 {
-    ride->lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
-    ride->lifecycle_flags |= RIDE_LIFECYCLE_NO_RAW_STATS;
-    ride->unreliability_factor = 16;
+    ride.lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
+    ride.lifecycle_flags |= RIDE_LIFECYCLE_NO_RAW_STATS;
+    ride.unreliability_factor = 16;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -3111,19 +3112,19 @@ void ride_ratings_calculate_twist(Ride* ride, RideRatingUpdateState& state)
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = 0;
+    ride.sheltered_eighths = 0;
 }
 
-void ride_ratings_calculate_haunted_house(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_haunted_house(Ride& ride, RideRatingUpdateState& state)
 {
-    ride->lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
-    ride->lifecycle_flags |= RIDE_LIFECYCLE_NO_RAW_STATS;
-    ride->unreliability_factor = 8;
+    ride.lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
+    ride.lifecycle_flags |= RIDE_LIFECYCLE_NO_RAW_STATS;
+    ride.unreliability_factor = 8;
     set_unreliability_factor(ride);
 
     RatingTuple ratings = {
@@ -3135,20 +3136,20 @@ void ride_ratings_calculate_haunted_house(Ride* ride, RideRatingUpdateState& sta
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = 7;
+    ride.sheltered_eighths = 7;
 }
 
-void ride_ratings_calculate_flying_roller_coaster(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_flying_roller_coaster(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 17;
+    ride.unreliability_factor = 17;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -3166,12 +3167,12 @@ void ride_ratings_calculate_flying_roller_coaster(Ride* ride, RideRatingUpdateSt
     ride_ratings_apply_proximity(state, &ratings, 20130);
     ride_ratings_apply_scenery(&ratings, ride, 6693);
 
-    if (ride->inversions == 0)
+    if (ride.inversions == 0)
         ratings.Excitement /= 2;
 
     ride_ratings_apply_max_speed_penalty(&ratings, ride, 0xA0000, 2, 1, 1);
 
-    if (ride->inversions == 0)
+    if (ride.inversions == 0)
         ride_ratings_apply_max_negative_g_penalty(&ratings, ride, FIXED_2DP(0, 40), 2, 1, 1);
 
     ride_ratings_apply_num_drops_penalty(&ratings, ride, 2, 2, 1, 1);
@@ -3180,20 +3181,20 @@ void ride_ratings_calculate_flying_roller_coaster(Ride* ride, RideRatingUpdateSt
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
+    ride.sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
 }
 
-void ride_ratings_calculate_virginia_reel(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_virginia_reel(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 19;
+    ride.unreliability_factor = 19;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -3217,20 +3218,20 @@ void ride_ratings_calculate_virginia_reel(Ride* ride, RideRatingUpdateState& sta
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
+    ride.sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
 }
 
-void ride_ratings_calculate_splash_boats(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_splash_boats(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 15;
+    ride.unreliability_factor = 15;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -3249,20 +3250,20 @@ void ride_ratings_calculate_splash_boats(Ride* ride, RideRatingUpdateState& stat
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
+    ride.sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
 }
 
-void ride_ratings_calculate_mini_helicopters(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_mini_helicopters(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 12;
+    ride.unreliability_factor = 12;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -3283,20 +3284,20 @@ void ride_ratings_calculate_mini_helicopters(Ride* ride, RideRatingUpdateState&
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = 6;
+    ride.sheltered_eighths = 6;
 }
 
-void ride_ratings_calculate_lay_down_roller_coaster(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_lay_down_roller_coaster(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 18;
+    ride.unreliability_factor = 18;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -3314,7 +3315,7 @@ void ride_ratings_calculate_lay_down_roller_coaster(Ride* ride, RideRatingUpdate
     ride_ratings_apply_proximity(state, &ratings, 20130);
     ride_ratings_apply_scenery(&ratings, ride, 6693);
 
-    if (ride->inversions == 0)
+    if (ride.inversions == 0)
     {
         ratings.Excitement /= 4;
         ratings.Intensity /= 2;
@@ -3323,7 +3324,7 @@ void ride_ratings_calculate_lay_down_roller_coaster(Ride* ride, RideRatingUpdate
 
     ride_ratings_apply_max_speed_penalty(&ratings, ride, 0xA0000, 2, 2, 2);
 
-    if (ride->inversions == 0)
+    if (ride.inversions == 0)
     {
         ride_ratings_apply_max_negative_g_penalty(&ratings, ride, FIXED_2DP(0, 40), 2, 2, 2);
         ride_ratings_apply_num_drops_penalty(&ratings, ride, 2, 2, 2, 2);
@@ -3333,20 +3334,20 @@ void ride_ratings_calculate_lay_down_roller_coaster(Ride* ride, RideRatingUpdate
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
+    ride.sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
 }
 
-void ride_ratings_calculate_suspended_monorail(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_suspended_monorail(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 14;
+    ride.unreliability_factor = 14;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -3364,24 +3365,24 @@ void ride_ratings_calculate_suspended_monorail(Ride* ride, RideRatingUpdateState
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
     auto shelteredEighths = get_num_of_sheltered_eighths(ride);
     if (shelteredEighths.TrackShelteredEighths >= 4)
-        ride->excitement /= 4;
+        ride.excitement /= 4;
 
-    ride->sheltered_eighths = shelteredEighths.TotalShelteredEighths;
+    ride.sheltered_eighths = shelteredEighths.TotalShelteredEighths;
 }
 
-void ride_ratings_calculate_reverser_roller_coaster(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_reverser_roller_coaster(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 19;
+    ride.unreliability_factor = 19;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -3416,20 +3417,20 @@ void ride_ratings_calculate_reverser_roller_coaster(Ride* ride, RideRatingUpdate
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
+    ride.sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
 }
 
-void ride_ratings_calculate_heartline_twister_coaster(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_heartline_twister_coaster(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 18;
+    ride.unreliability_factor = 18;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -3451,7 +3452,7 @@ void ride_ratings_calculate_heartline_twister_coaster(Ride* ride, RideRatingUpda
     ride_ratings_apply_proximity(state, &ratings, 9841);
     ride_ratings_apply_scenery(&ratings, ride, 3904);
 
-    if (ride->inversions == 0)
+    if (ride.inversions == 0)
         ratings.Excitement /= 4;
 
     ride_ratings_apply_num_drops_penalty(&ratings, ride, 1, 4, 1, 1);
@@ -3460,20 +3461,20 @@ void ride_ratings_calculate_heartline_twister_coaster(Ride* ride, RideRatingUpda
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
+    ride.sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
 }
 
-void ride_ratings_calculate_mini_golf(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_mini_golf(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 0;
+    ride.unreliability_factor = 0;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -3485,10 +3486,10 @@ void ride_ratings_calculate_mini_golf(Ride* ride, RideRatingUpdateState& state)
     ride_ratings_apply_scenery(&ratings, ride, 27887);
 
     // Apply golf holes factor
-    ride_ratings_add(&ratings, (ride->holes) * 5, 0, 0);
+    ride_ratings_add(&ratings, (ride.holes) * 5, 0, 0);
 
     // Apply no golf holes penalty
-    if (ride->holes == 0)
+    if (ride.holes == 0)
     {
         ratings.Excitement /= 8;
         ratings.Intensity /= 2;
@@ -3498,25 +3499,25 @@ void ride_ratings_calculate_mini_golf(Ride* ride, RideRatingUpdateState& state)
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
+    ride.sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
 }
 
-void ride_ratings_calculate_first_aid(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_first_aid(Ride& ride, RideRatingUpdateState& state)
 {
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 }
 
-void ride_ratings_calculate_circus(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_circus(Ride& ride, RideRatingUpdateState& state)
 {
-    ride->lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
-    ride->lifecycle_flags |= RIDE_LIFECYCLE_NO_RAW_STATS;
-    ride->unreliability_factor = 9;
+    ride.lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
+    ride.lifecycle_flags |= RIDE_LIFECYCLE_NO_RAW_STATS;
+    ride.unreliability_factor = 9;
     set_unreliability_factor(ride);
 
     RatingTuple ratings = {
@@ -3528,20 +3529,20 @@ void ride_ratings_calculate_circus(Ride* ride, RideRatingUpdateState& state)
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = 7;
+    ride.sheltered_eighths = 7;
 }
 
-void ride_ratings_calculate_ghost_train(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_ghost_train(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 12;
+    ride.unreliability_factor = 12;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -3561,20 +3562,20 @@ void ride_ratings_calculate_ghost_train(Ride* ride, RideRatingUpdateState& state
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
+    ride.sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
 }
 
-void ride_ratings_calculate_twister_roller_coaster(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_twister_roller_coaster(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 15;
+    ride.unreliability_factor = 15;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -3592,12 +3593,12 @@ void ride_ratings_calculate_twister_roller_coaster(Ride* ride, RideRatingUpdateS
     ride_ratings_apply_proximity(state, &ratings, 20130);
     ride_ratings_apply_scenery(&ratings, ride, 6693);
 
-    if (ride->inversions == 0)
+    if (ride.inversions == 0)
         ride_ratings_apply_highest_drop_height_penalty(&ratings, ride, 12, 2, 2, 2);
 
     ride_ratings_apply_max_speed_penalty(&ratings, ride, 0xA0000, 2, 2, 2);
 
-    if (ride->inversions == 0)
+    if (ride.inversions == 0)
     {
         ride_ratings_apply_max_negative_g_penalty(&ratings, ride, FIXED_2DP(0, 40), 2, 2, 2);
         ride_ratings_apply_num_drops_penalty(&ratings, ride, 2, 2, 2, 2);
@@ -3607,20 +3608,20 @@ void ride_ratings_calculate_twister_roller_coaster(Ride* ride, RideRatingUpdateS
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
+    ride.sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
 }
 
-void ride_ratings_calculate_wooden_roller_coaster(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_wooden_roller_coaster(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 19;
+    ride.unreliability_factor = 19;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -3647,20 +3648,20 @@ void ride_ratings_calculate_wooden_roller_coaster(Ride* ride, RideRatingUpdateSt
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
+    ride.sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
 }
 
-void ride_ratings_calculate_side_friction_roller_coaster(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_side_friction_roller_coaster(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 19;
+    ride.unreliability_factor = 19;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -3686,20 +3687,20 @@ void ride_ratings_calculate_side_friction_roller_coaster(Ride* ride, RideRatingU
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
+    ride.sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
 }
 
-void ride_ratings_calculate_wild_mouse(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_wild_mouse(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 14;
+    ride.unreliability_factor = 14;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -3726,20 +3727,20 @@ void ride_ratings_calculate_wild_mouse(Ride* ride, RideRatingUpdateState& state)
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
+    ride.sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
 }
 
-void ride_ratings_calculate_multi_dimension_roller_coaster(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_multi_dimension_roller_coaster(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 18;
+    ride.unreliability_factor = 18;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -3757,34 +3758,34 @@ void ride_ratings_calculate_multi_dimension_roller_coaster(Ride* ride, RideRatin
     ride_ratings_apply_proximity(state, &ratings, 20130);
     ride_ratings_apply_scenery(&ratings, ride, 6693);
 
-    if (ride->inversions == 0)
+    if (ride.inversions == 0)
         ratings.Excitement /= 4;
 
     ride_ratings_apply_max_speed_penalty(&ratings, ride, 0xA0000, 2, 1, 1);
-    if (ride->inversions == 0)
+    if (ride.inversions == 0)
         ride_ratings_apply_max_negative_g_penalty(&ratings, ride, FIXED_2DP(0, 40), 2, 1, 1);
 
-    if (ride->inversions == 0)
+    if (ride.inversions == 0)
         ride_ratings_apply_num_drops_penalty(&ratings, ride, 2, 2, 1, 1);
 
     ride_ratings_apply_excessive_lateral_g_penalty(&ratings, ride, 24576, 38130, 49648);
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
+    ride.sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
 }
 
-void ride_ratings_calculate_giga_coaster(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_giga_coaster(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 14;
+    ride.unreliability_factor = 14;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -3802,12 +3803,12 @@ void ride_ratings_calculate_giga_coaster(Ride* ride, RideRatingUpdateState& stat
     ride_ratings_apply_proximity(state, &ratings, 20130);
     ride_ratings_apply_scenery(&ratings, ride, 6693);
 
-    if (ride->inversions == 0)
+    if (ride.inversions == 0)
         ride_ratings_apply_highest_drop_height_penalty(&ratings, ride, 16, 2, 2, 2);
 
     ride_ratings_apply_max_speed_penalty(&ratings, ride, 0xA0000, 2, 2, 2);
 
-    if (ride->inversions == 0)
+    if (ride.inversions == 0)
     {
         ride_ratings_apply_max_negative_g_penalty(&ratings, ride, FIXED_2DP(0, 40), 2, 2, 2);
         ride_ratings_apply_num_drops_penalty(&ratings, ride, 2, 2, 2, 2);
@@ -3817,26 +3818,26 @@ void ride_ratings_calculate_giga_coaster(Ride* ride, RideRatingUpdateState& stat
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
+    ride.sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
 }
 
-void ride_ratings_calculate_roto_drop(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_roto_drop(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 24;
+    ride.unreliability_factor = 24;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
     ride_ratings_set(&ratings, RIDE_RATING(2, 80), RIDE_RATING(3, 50), RIDE_RATING(3, 50));
 
-    int32_t lengthFactor = ((ride->GetTotalLength() >> 16) * 209715) >> 16;
+    int32_t lengthFactor = ((ride.GetTotalLength() >> 16) * 209715) >> 16;
     ride_ratings_add(&ratings, lengthFactor, lengthFactor * 2, lengthFactor * 2);
 
     ride_ratings_apply_proximity(state, &ratings, 11183);
@@ -3845,19 +3846,19 @@ void ride_ratings_calculate_roto_drop(Ride* ride, RideRatingUpdateState& state)
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
+    ride.sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
 }
 
-void ride_ratings_calculate_flying_saucers(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_flying_saucers(Ride& ride, RideRatingUpdateState& state)
 {
-    ride->lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
-    ride->lifecycle_flags |= RIDE_LIFECYCLE_NO_RAW_STATS;
-    ride->unreliability_factor = 32;
+    ride.lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
+    ride.lifecycle_flags |= RIDE_LIFECYCLE_NO_RAW_STATS;
+    ride.unreliability_factor = 32;
     set_unreliability_factor(ride);
 
     RatingTuple ratings = {
@@ -3866,14 +3867,14 @@ void ride_ratings_calculate_flying_saucers(Ride* ride, RideRatingUpdateState& st
         /* .nausea =     */ RIDE_RATING(0, 39),
     };
 
-    if (ride->NumTrains >= 4)
+    if (ride.NumTrains >= 4)
     {
         ride_ratings_add(&ratings, RIDE_RATING(0, 40), 0, 0);
     }
 
-    ride_ratings_add(&ratings, ride->time_limit, ride->time_limit / 2, 0);
+    ride_ratings_add(&ratings, ride.time_limit, ride.time_limit / 2, 0);
 
-    if (ride->NumTrains >= 4)
+    if (ride.NumTrains >= 4)
     {
         ride_ratings_add(&ratings, RIDE_RATING(0, 40), 0, 0);
     }
@@ -3883,19 +3884,19 @@ void ride_ratings_calculate_flying_saucers(Ride* ride, RideRatingUpdateState& st
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = 0;
+    ride.sheltered_eighths = 0;
 }
 
-void ride_ratings_calculate_crooked_house(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_crooked_house(Ride& ride, RideRatingUpdateState& state)
 {
-    ride->lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
-    ride->lifecycle_flags |= RIDE_LIFECYCLE_NO_RAW_STATS;
-    ride->unreliability_factor = 5;
+    ride.lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
+    ride.lifecycle_flags |= RIDE_LIFECYCLE_NO_RAW_STATS;
+    ride.unreliability_factor = 5;
     set_unreliability_factor(ride);
 
     RatingTuple ratings = {
@@ -3907,20 +3908,20 @@ void ride_ratings_calculate_crooked_house(Ride* ride, RideRatingUpdateState& sta
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = 7;
+    ride.sheltered_eighths = 7;
 }
 
-void ride_ratings_calculate_monorail_cycles(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_monorail_cycles(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 4;
+    ride.unreliability_factor = 4;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -3941,20 +3942,20 @@ void ride_ratings_calculate_monorail_cycles(Ride* ride, RideRatingUpdateState& s
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
+    ride.sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
 }
 
-void ride_ratings_calculate_compact_inverted_coaster(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_compact_inverted_coaster(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = ride->mode == RideMode::ReverseInclineLaunchedShuttle ? 31 : 21;
+    ride.unreliability_factor = ride.mode == RideMode::ReverseInclineLaunchedShuttle ? 31 : 21;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -3972,32 +3973,32 @@ void ride_ratings_calculate_compact_inverted_coaster(Ride* ride, RideRatingUpdat
     ride_ratings_apply_proximity(state, &ratings, 15657);
     ride_ratings_apply_scenery(&ratings, ride, 8366);
 
-    if (ride->inversions == 0)
+    if (ride.inversions == 0)
         ride_ratings_apply_highest_drop_height_penalty(&ratings, ride, 12, 2, 2, 2);
 
     ride_ratings_apply_max_speed_penalty(&ratings, ride, 0xA0000, 2, 2, 2);
 
-    if (ride->inversions == 0)
+    if (ride.inversions == 0)
         ride_ratings_apply_max_negative_g_penalty(&ratings, ride, FIXED_2DP(0, 30), 2, 2, 2);
 
     ride_ratings_apply_excessive_lateral_g_penalty(&ratings, ride, 24576, 30980, 55606);
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
+    ride.sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
 }
 
-void ride_ratings_calculate_water_coaster(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_water_coaster(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 14;
+    ride.unreliability_factor = 14;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -4022,23 +4023,23 @@ void ride_ratings_calculate_water_coaster(Ride* ride, RideRatingUpdateState& sta
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    if (!(ride->special_track_elements & RIDE_ELEMENT_TUNNEL_SPLASH_OR_RAPIDS))
+    if (!(ride.special_track_elements & RIDE_ELEMENT_TUNNEL_SPLASH_OR_RAPIDS))
         ratings.Excitement /= 8;
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
+    ride.sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
 }
 
-void ride_ratings_calculate_air_powered_vertical_coaster(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_air_powered_vertical_coaster(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 28;
+    ride.unreliability_factor = 28;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -4056,20 +4057,20 @@ void ride_ratings_calculate_air_powered_vertical_coaster(Ride* ride, RideRatingU
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
+    ride.sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
 }
 
-void ride_ratings_calculate_inverted_hairpin_coaster(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_inverted_hairpin_coaster(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 14;
+    ride.unreliability_factor = 14;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -4097,42 +4098,42 @@ void ride_ratings_calculate_inverted_hairpin_coaster(Ride* ride, RideRatingUpdat
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
+    ride.sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
 }
 
-void ride_ratings_calculate_magic_carpet(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_magic_carpet(Ride& ride, RideRatingUpdateState& state)
 {
-    ride->lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
-    ride->lifecycle_flags |= RIDE_LIFECYCLE_NO_RAW_STATS;
-    ride->unreliability_factor = 16;
+    ride.lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
+    ride.lifecycle_flags |= RIDE_LIFECYCLE_NO_RAW_STATS;
+    ride.unreliability_factor = 16;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
     ride_ratings_set(&ratings, RIDE_RATING(2, 45), RIDE_RATING(1, 60), RIDE_RATING(2, 60));
 
-    ride_ratings_add(&ratings, ride->operation_option * 10, ride->operation_option * 20, ride->operation_option * 20);
+    ride_ratings_add(&ratings, ride.operation_option * 10, ride.operation_option * 20, ride.operation_option * 20);
 
     ride_ratings_apply_scenery(&ratings, ride, 11155);
 
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = 0;
+    ride.sheltered_eighths = 0;
 }
 
-void ride_ratings_calculate_submarine_ride(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_submarine_ride(Ride& ride, RideRatingUpdateState& state)
 {
-    ride->unreliability_factor = 7;
+    ride.unreliability_factor = 7;
     set_unreliability_factor(ride);
 
     // NOTE Fixed bug from original game, see boat Hire.
@@ -4146,21 +4147,21 @@ void ride_ratings_calculate_submarine_ride(Ride* ride, RideRatingUpdateState& st
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
     // Originally, this was always to zero, even though the default vehicle is completely enclosed.
-    ride->sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
+    ride.sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
 }
 
-void ride_ratings_calculate_river_rafts(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_river_rafts(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 12;
+    ride.unreliability_factor = 12;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -4177,19 +4178,19 @@ void ride_ratings_calculate_river_rafts(Ride* ride, RideRatingUpdateState& state
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
+    ride.sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
 }
 
-void ride_ratings_calculate_enterprise(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_enterprise(Ride& ride, RideRatingUpdateState& state)
 {
-    ride->lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
-    ride->lifecycle_flags |= RIDE_LIFECYCLE_NO_RAW_STATS;
-    ride->unreliability_factor = 22;
+    ride.lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
+    ride.lifecycle_flags |= RIDE_LIFECYCLE_NO_RAW_STATS;
+    ride.unreliability_factor = 22;
     set_unreliability_factor(ride);
 
     // Base ratings
@@ -4199,27 +4200,27 @@ void ride_ratings_calculate_enterprise(Ride* ride, RideRatingUpdateState& state)
         /* .nausea     = */ RIDE_RATING(5, 72),
     };
 
-    ride_ratings_add(&ratings, ride->operation_option, ride->operation_option * 16, ride->operation_option * 16);
+    ride_ratings_add(&ratings, ride.operation_option, ride.operation_option * 16, ride.operation_option * 16);
 
     ride_ratings_apply_scenery(&ratings, ride, 19521);
 
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = 3;
+    ride.sheltered_eighths = 3;
 }
 
-void ride_ratings_calculate_inverted_impulse_coaster(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_inverted_impulse_coaster(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 20;
+    ride.unreliability_factor = 20;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -4243,20 +4244,20 @@ void ride_ratings_calculate_inverted_impulse_coaster(Ride* ride, RideRatingUpdat
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
+    ride.sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
 }
 
-void ride_ratings_calculate_mini_roller_coaster(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_mini_roller_coaster(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 13;
+    ride.unreliability_factor = 13;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -4282,20 +4283,20 @@ void ride_ratings_calculate_mini_roller_coaster(Ride* ride, RideRatingUpdateStat
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
+    ride.sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
 }
 
-void ride_ratings_calculate_mine_ride(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_mine_ride(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 16;
+    ride.unreliability_factor = 16;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -4318,20 +4319,20 @@ void ride_ratings_calculate_mine_ride(Ride* ride, RideRatingUpdateState& state)
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
+    ride.sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
 }
 
-void ride_ratings_calculate_lim_launched_roller_coaster(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_lim_launched_roller_coaster(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 25;
+    ride.unreliability_factor = 25;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -4349,12 +4350,12 @@ void ride_ratings_calculate_lim_launched_roller_coaster(Ride* ride, RideRatingUp
     ride_ratings_apply_proximity(state, &ratings, 20130);
     ride_ratings_apply_scenery(&ratings, ride, 6693);
 
-    if (ride->inversions == 0)
+    if (ride.inversions == 0)
         ride_ratings_apply_highest_drop_height_penalty(&ratings, ride, 10, 2, 2, 2);
 
     ride_ratings_apply_max_speed_penalty(&ratings, ride, 0xA0000, 2, 2, 2);
 
-    if (ride->inversions == 0)
+    if (ride.inversions == 0)
     {
         ride_ratings_apply_max_negative_g_penalty(&ratings, ride, 10, 2, 2, 2);
         ride_ratings_apply_num_drops_penalty(&ratings, ride, 2, 2, 2, 2);
@@ -4364,20 +4365,20 @@ void ride_ratings_calculate_lim_launched_roller_coaster(Ride* ride, RideRatingUp
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
+    ride.sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
 }
 
-void ride_ratings_calculate_classic_mini_roller_coaster(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_classic_mini_roller_coaster(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 13;
+    ride.unreliability_factor = 13;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -4402,20 +4403,20 @@ void ride_ratings_calculate_classic_mini_roller_coaster(Ride* ride, RideRatingUp
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
+    ride.sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
 }
 
-void ride_ratings_calculate_hybrid_coaster(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_hybrid_coaster(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 16;
+    ride.unreliability_factor = 16;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -4433,14 +4434,14 @@ void ride_ratings_calculate_hybrid_coaster(Ride* ride, RideRatingUpdateState& st
     ride_ratings_apply_proximity(state, &ratings, 22367);
     ride_ratings_apply_scenery(&ratings, ride, 6693);
 
-    if (ride->inversions == 0)
+    if (ride.inversions == 0)
     {
         ride_ratings_apply_highest_drop_height_penalty(&ratings, ride, 14, 2, 2, 2);
     }
 
     ride_ratings_apply_max_speed_penalty(&ratings, ride, 0xA0000, 2, 2, 2);
 
-    if (ride->inversions == 0)
+    if (ride.inversions == 0)
     {
         ride_ratings_apply_max_negative_g_penalty(&ratings, ride, FIXED_2DP(0, 40), 2, 2, 2);
         ride_ratings_apply_num_drops_penalty(&ratings, ride, 2, 2, 2, 2);
@@ -4449,18 +4450,18 @@ void ride_ratings_calculate_hybrid_coaster(Ride* ride, RideRatingUpdateState& st
     ride_ratings_apply_excessive_lateral_g_penalty(&ratings, ride, 24576, 35746, 49648);
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
-    ride->ratings = ratings;
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
-    ride->sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
+    ride.ratings = ratings;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
 }
 
-void ride_ratings_calculate_single_rail_roller_coaster(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_single_rail_roller_coaster(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 16;
+    ride.unreliability_factor = 16;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -4478,12 +4479,12 @@ void ride_ratings_calculate_single_rail_roller_coaster(Ride* ride, RideRatingUpd
     ride_ratings_apply_proximity(state, &ratings, 22367);
     ride_ratings_apply_scenery(&ratings, ride, 6693);
 
-    if (ride->inversions == 0)
+    if (ride.inversions == 0)
         ride_ratings_apply_highest_drop_height_penalty(&ratings, ride, 14, 2, 2, 2); // Done
 
     ride_ratings_apply_max_speed_penalty(&ratings, ride, 0xA0000, 2, 2, 2); // Done
 
-    if (ride->inversions == 0)
+    if (ride.inversions == 0)
     {
         ride_ratings_apply_max_negative_g_penalty(&ratings, ride, FIXED_2DP(0, 40), 2, 2, 2); // Done
         ride_ratings_apply_num_drops_penalty(&ratings, ride, 2, 2, 2, 2);                     // Done
@@ -4493,20 +4494,20 @@ void ride_ratings_calculate_single_rail_roller_coaster(Ride* ride, RideRatingUpd
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
+    ride.sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
 }
 
-void ride_ratings_calculate_alpine_coaster(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_alpine_coaster(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 7;
+    ride.unreliability_factor = 7;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -4527,20 +4528,20 @@ void ride_ratings_calculate_alpine_coaster(Ride* ride, RideRatingUpdateState& st
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
+    ride.sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
 }
 
-void ride_ratings_calculate_classic_wooden_roller_coaster(Ride* ride, RideRatingUpdateState& state)
+void ride_ratings_calculate_classic_wooden_roller_coaster(Ride& ride, RideRatingUpdateState& state)
 {
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    if (!(ride.lifecycle_flags & RIDE_LIFECYCLE_TESTED))
         return;
 
-    ride->unreliability_factor = 19;
+    ride.unreliability_factor = 19;
     set_unreliability_factor(ride);
 
     RatingTuple ratings;
@@ -4567,12 +4568,12 @@ void ride_ratings_calculate_classic_wooden_roller_coaster(Ride* ride, RideRating
     ride_ratings_apply_intensity_penalty(&ratings);
     ride_ratings_apply_adjustments(ride, &ratings);
 
-    ride->ratings = ratings;
+    ride.ratings = ratings;
 
-    ride->upkeep_cost = ride_compute_upkeep(state, ride);
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
+    ride.upkeep_cost = ride_compute_upkeep(state, ride);
+    ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
 
-    ride->sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
+    ride.sheltered_eighths = get_num_of_sheltered_eighths(ride).TotalShelteredEighths;
 }
 
 #pragma endregion
diff --git a/src/openrct2/ride/RideRatings.h b/src/openrct2/ride/RideRatings.h
index e83574e828..d0c1132ee9 100644
--- a/src/openrct2/ride/RideRatings.h
+++ b/src/openrct2/ride/RideRatings.h
@@ -59,95 +59,95 @@ extern RideRatingUpdateState gRideRatingUpdateState;
 void ride_ratings_update_ride(const Ride& ride);
 void ride_ratings_update_all();
 
-using ride_ratings_calculation = void (*)(Ride* ride, RideRatingUpdateState& state);
+using ride_ratings_calculation = void (*)(Ride& ride, RideRatingUpdateState& state);
 ride_ratings_calculation ride_ratings_get_calculate_func(ride_type_t rideType);
 
-void ride_ratings_calculate_spiral_roller_coaster(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_stand_up_roller_coaster(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_suspended_swinging_coaster(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_inverted_roller_coaster(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_junior_roller_coaster(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_miniature_railway(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_monorail(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_mini_suspended_coaster(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_boat_hire(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_wooden_wild_mouse(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_steeplechase(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_car_ride(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_launched_freefall(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_bobsleigh_coaster(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_observation_tower(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_looping_roller_coaster(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_dinghy_slide(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_mine_train_coaster(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_chairlift(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_corkscrew_roller_coaster(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_maze(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_spiral_slide(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_go_karts(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_log_flume(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_river_rapids(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_dodgems(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_swinging_ship(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_inverter_ship(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_food_stall(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_shop(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_merry_go_round(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_information_kiosk(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_toilets(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_ferris_wheel(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_motion_simulator(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_3d_cinema(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_top_spin(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_space_rings(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_reverse_freefall_coaster(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_lift(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_vertical_drop_roller_coaster(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_cash_machine(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_twist(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_haunted_house(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_first_aid(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_circus(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_ghost_train(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_twister_roller_coaster(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_wooden_roller_coaster(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_side_friction_roller_coaster(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_wild_mouse(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_multi_dimension_roller_coaster(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_flying_roller_coaster(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_virginia_reel(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_splash_boats(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_mini_helicopters(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_lay_down_roller_coaster(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_suspended_monorail(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_reverser_roller_coaster(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_heartline_twister_coaster(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_mini_golf(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_giga_coaster(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_roto_drop(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_flying_saucers(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_crooked_house(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_monorail_cycles(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_compact_inverted_coaster(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_water_coaster(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_air_powered_vertical_coaster(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_inverted_hairpin_coaster(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_magic_carpet(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_submarine_ride(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_river_rafts(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_enterprise(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_inverted_impulse_coaster(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_mini_roller_coaster(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_mine_ride(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_lim_launched_roller_coaster(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_classic_mini_roller_coaster(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_hybrid_coaster(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_single_rail_roller_coaster(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_alpine_coaster(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_classic_wooden_roller_coaster(Ride* ride, RideRatingUpdateState& state);
-void ride_ratings_calculate_drink_stall(Ride* ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_spiral_roller_coaster(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_stand_up_roller_coaster(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_suspended_swinging_coaster(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_inverted_roller_coaster(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_junior_roller_coaster(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_miniature_railway(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_monorail(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_mini_suspended_coaster(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_boat_hire(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_wooden_wild_mouse(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_steeplechase(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_car_ride(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_launched_freefall(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_bobsleigh_coaster(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_observation_tower(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_looping_roller_coaster(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_dinghy_slide(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_mine_train_coaster(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_chairlift(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_corkscrew_roller_coaster(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_maze(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_spiral_slide(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_go_karts(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_log_flume(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_river_rapids(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_dodgems(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_swinging_ship(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_inverter_ship(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_food_stall(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_shop(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_merry_go_round(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_information_kiosk(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_toilets(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_ferris_wheel(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_motion_simulator(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_3d_cinema(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_top_spin(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_space_rings(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_reverse_freefall_coaster(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_lift(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_vertical_drop_roller_coaster(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_cash_machine(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_twist(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_haunted_house(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_first_aid(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_circus(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_ghost_train(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_twister_roller_coaster(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_wooden_roller_coaster(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_side_friction_roller_coaster(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_wild_mouse(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_multi_dimension_roller_coaster(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_flying_roller_coaster(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_virginia_reel(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_splash_boats(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_mini_helicopters(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_lay_down_roller_coaster(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_suspended_monorail(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_reverser_roller_coaster(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_heartline_twister_coaster(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_mini_golf(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_giga_coaster(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_roto_drop(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_flying_saucers(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_crooked_house(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_monorail_cycles(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_compact_inverted_coaster(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_water_coaster(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_air_powered_vertical_coaster(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_inverted_hairpin_coaster(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_magic_carpet(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_submarine_ride(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_river_rafts(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_enterprise(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_inverted_impulse_coaster(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_mini_roller_coaster(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_mine_ride(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_lim_launched_roller_coaster(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_classic_mini_roller_coaster(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_hybrid_coaster(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_single_rail_roller_coaster(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_alpine_coaster(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_classic_wooden_roller_coaster(Ride& ride, RideRatingUpdateState& state);
+void ride_ratings_calculate_drink_stall(Ride& ride, RideRatingUpdateState& state);
 
 // Special Track Element Adjustment functions for RTDs
-void SpecialTrackElementRatingsAjustment_Default(const Ride* ride, int32_t& excitement, int32_t& intensity, int32_t& nausea);
-void SpecialTrackElementRatingsAjustment_GhostTrain(const Ride* ride, int32_t& excitement, int32_t& intensity, int32_t& nausea);
-void SpecialTrackElementRatingsAjustment_LogFlume(const Ride* ride, int32_t& excitement, int32_t& intensity, int32_t& nausea);
+void SpecialTrackElementRatingsAjustment_Default(const Ride& ride, int32_t& excitement, int32_t& intensity, int32_t& nausea);
+void SpecialTrackElementRatingsAjustment_GhostTrain(const Ride& ride, int32_t& excitement, int32_t& intensity, int32_t& nausea);
+void SpecialTrackElementRatingsAjustment_LogFlume(const Ride& ride, int32_t& excitement, int32_t& intensity, int32_t& nausea);
diff --git a/src/openrct2/ride/Station.cpp b/src/openrct2/ride/Station.cpp
index 778fcf23ad..a0ca23733f 100644
--- a/src/openrct2/ride/Station.cpp
+++ b/src/openrct2/ride/Station.cpp
@@ -17,23 +17,23 @@
 #include "Track.h"
 #include "Vehicle.h"
 
-static void ride_update_station_blocksection(Ride* ride, StationIndex stationIndex);
-static void ride_update_station_dodgems(Ride* ride, StationIndex stationIndex);
-static void ride_update_station_normal(Ride* ride, StationIndex stationIndex);
-static void ride_update_station_race(Ride* ride, StationIndex stationIndex);
-static void ride_race_init_vehicle_speeds(Ride* ride);
-static void ride_invalidate_station_start(Ride* ride, StationIndex stationIndex, bool greenLight);
+static void ride_update_station_blocksection(Ride& ride, StationIndex stationIndex);
+static void ride_update_station_dodgems(Ride& ride, StationIndex stationIndex);
+static void ride_update_station_normal(Ride& ride, StationIndex stationIndex);
+static void ride_update_station_race(Ride& ride, StationIndex stationIndex);
+static void ride_race_init_vehicle_speeds(const Ride& ride);
+static void ride_invalidate_station_start(Ride& ride, StationIndex stationIndex, bool greenLight);
 
 /**
  *
  *  rct2: 0x006ABFFB
  */
-void ride_update_station(Ride* ride, StationIndex stationIndex)
+void ride_update_station(Ride& ride, StationIndex stationIndex)
 {
-    if (ride->GetStation(stationIndex).Start.IsNull())
+    if (ride.GetStation(stationIndex).Start.IsNull())
         return;
 
-    switch (ride->mode)
+    switch (ride.mode)
     {
         case RideMode::Race:
             ride_update_station_race(ride, stationIndex);
@@ -55,12 +55,12 @@ void ride_update_station(Ride* ride, StationIndex stationIndex)
  *
  *  rct2: 0x006AC0A1
  */
-static void ride_update_station_blocksection(Ride* ride, StationIndex stationIndex)
+static void ride_update_station_blocksection(Ride& ride, StationIndex stationIndex)
 {
     TileElement* tileElement = ride_get_station_start_track_element(ride, stationIndex);
-    auto& station = ride->GetStation(stationIndex);
+    auto& station = ride.GetStation(stationIndex);
 
-    if ((ride->status == RideStatus::Closed && ride->num_riders == 0)
+    if ((ride.status == RideStatus::Closed && ride.num_riders == 0)
         || (tileElement != nullptr && tileElement->AsTrack()->IsBrakeClosed()))
     {
         station.Depart &= ~STATION_DEPART_FLAG;
@@ -86,25 +86,25 @@ static void ride_update_station_blocksection(Ride* ride, StationIndex stationInd
  *
  *  rct2: 0x006AC12B
  */
-static void ride_update_station_dodgems(Ride* ride, StationIndex stationIndex)
+static void ride_update_station_dodgems(Ride& ride, StationIndex stationIndex)
 {
-    auto& station = ride->GetStation(stationIndex);
+    auto& station = ride.GetStation(stationIndex);
 
     // Change of station depart flag should really call invalidate_station_start
     // but since dodgems do not have station lights there is no point.
-    if (ride->status == RideStatus::Closed || (ride->lifecycle_flags & (RIDE_LIFECYCLE_BROKEN_DOWN | RIDE_LIFECYCLE_CRASHED)))
+    if (ride.status == RideStatus::Closed || (ride.lifecycle_flags & (RIDE_LIFECYCLE_BROKEN_DOWN | RIDE_LIFECYCLE_CRASHED)))
     {
         station.Depart &= ~STATION_DEPART_FLAG;
         return;
     }
 
-    if (ride->lifecycle_flags & RIDE_LIFECYCLE_PASS_STATION_NO_STOPPING)
+    if (ride.lifecycle_flags & RIDE_LIFECYCLE_PASS_STATION_NO_STOPPING)
     {
-        int32_t dx = ride->time_limit * 32;
+        int32_t dx = ride.time_limit * 32;
         int32_t dh = (dx >> 8) & 0xFF;
-        for (size_t i = 0; i < ride->NumTrains; i++)
+        for (size_t i = 0; i < ride.NumTrains; i++)
         {
-            Vehicle* vehicle = GetEntity<Vehicle>(ride->vehicles[i]);
+            Vehicle* vehicle = GetEntity<Vehicle>(ride.vehicles[i]);
             if (vehicle == nullptr)
                 continue;
 
@@ -112,7 +112,7 @@ static void ride_update_station_dodgems(Ride* ride, StationIndex stationIndex)
                 continue;
 
             // End match
-            ride->lifecycle_flags &= ~RIDE_LIFECYCLE_PASS_STATION_NO_STOPPING;
+            ride.lifecycle_flags &= ~RIDE_LIFECYCLE_PASS_STATION_NO_STOPPING;
             station.Depart &= ~STATION_DEPART_FLAG;
             return;
         }
@@ -123,9 +123,9 @@ static void ride_update_station_dodgems(Ride* ride, StationIndex stationIndex)
     else
     {
         // Check if all vehicles are ready to go
-        for (size_t i = 0; i < ride->NumTrains; i++)
+        for (size_t i = 0; i < ride.NumTrains; i++)
         {
-            Vehicle* vehicle = GetEntity<Vehicle>(ride->vehicles[i]);
+            Vehicle* vehicle = GetEntity<Vehicle>(ride.vehicles[i]);
             if (vehicle == nullptr)
                 continue;
 
@@ -137,9 +137,9 @@ static void ride_update_station_dodgems(Ride* ride, StationIndex stationIndex)
         }
 
         // Begin the match
-        ride->lifecycle_flags |= RIDE_LIFECYCLE_PASS_STATION_NO_STOPPING;
+        ride.lifecycle_flags |= RIDE_LIFECYCLE_PASS_STATION_NO_STOPPING;
         station.Depart |= STATION_DEPART_FLAG;
-        ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAIN | RIDE_INVALIDATE_RIDE_LIST;
+        ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAIN | RIDE_INVALIDATE_RIDE_LIST;
     }
 }
 
@@ -147,12 +147,12 @@ static void ride_update_station_dodgems(Ride* ride, StationIndex stationIndex)
  *
  *  rct2: 0x006AC02C
  */
-static void ride_update_station_normal(Ride* ride, StationIndex stationIndex)
+static void ride_update_station_normal(Ride& ride, StationIndex stationIndex)
 {
-    auto& station = ride->GetStation(stationIndex);
+    auto& station = ride.GetStation(stationIndex);
     int32_t time = station.Depart & STATION_DEPART_MASK;
-    if ((ride->lifecycle_flags & (RIDE_LIFECYCLE_BROKEN_DOWN | RIDE_LIFECYCLE_CRASHED))
-        || (ride->status == RideStatus::Closed && ride->num_riders == 0))
+    if ((ride.lifecycle_flags & (RIDE_LIFECYCLE_BROKEN_DOWN | RIDE_LIFECYCLE_CRASHED))
+        || (ride.status == RideStatus::Closed && ride.num_riders == 0))
     {
         if (time != 0 && time != 127 && !(gCurrentTicks & 7))
             time--;
@@ -182,10 +182,10 @@ static void ride_update_station_normal(Ride* ride, StationIndex stationIndex)
  *
  *  rct2: 0x006AC1DF
  */
-static void ride_update_station_race(Ride* ride, StationIndex stationIndex)
+static void ride_update_station_race(Ride& ride, StationIndex stationIndex)
 {
-    auto& station = ride->GetStation(stationIndex);
-    if (ride->status == RideStatus::Closed || (ride->lifecycle_flags & (RIDE_LIFECYCLE_BROKEN_DOWN | RIDE_LIFECYCLE_CRASHED)))
+    auto& station = ride.GetStation(stationIndex);
+    if (ride.status == RideStatus::Closed || (ride.lifecycle_flags & (RIDE_LIFECYCLE_BROKEN_DOWN | RIDE_LIFECYCLE_CRASHED)))
     {
         if (station.Depart & STATION_DEPART_FLAG)
         {
@@ -195,13 +195,13 @@ static void ride_update_station_race(Ride* ride, StationIndex stationIndex)
         return;
     }
 
-    if (ride->lifecycle_flags & RIDE_LIFECYCLE_PASS_STATION_NO_STOPPING)
+    if (ride.lifecycle_flags & RIDE_LIFECYCLE_PASS_STATION_NO_STOPPING)
     {
-        int32_t numLaps = ride->NumLaps;
+        int32_t numLaps = ride.NumLaps;
 
-        for (size_t i = 0; i < ride->NumTrains; i++)
+        for (size_t i = 0; i < ride.NumTrains; i++)
         {
-            Vehicle* vehicle = GetEntity<Vehicle>(ride->vehicles[i]);
+            Vehicle* vehicle = GetEntity<Vehicle>(ride.vehicles[i]);
             if (vehicle == nullptr)
                 continue;
 
@@ -213,13 +213,13 @@ static void ride_update_station_race(Ride* ride, StationIndex stationIndex)
                     auto* peep = GetEntity<Guest>(vehicle->peep[0]);
                     if (peep != nullptr)
                     {
-                        ride->race_winner = peep->sprite_index;
-                        ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAIN | RIDE_INVALIDATE_RIDE_LIST;
+                        ride.race_winner = peep->sprite_index;
+                        ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAIN | RIDE_INVALIDATE_RIDE_LIST;
                     }
                 }
 
                 // Race is over
-                ride->lifecycle_flags &= ~RIDE_LIFECYCLE_PASS_STATION_NO_STOPPING;
+                ride.lifecycle_flags &= ~RIDE_LIFECYCLE_PASS_STATION_NO_STOPPING;
                 if (station.Depart & STATION_DEPART_FLAG)
                 {
                     station.Depart &= ~STATION_DEPART_FLAG;
@@ -235,9 +235,9 @@ static void ride_update_station_race(Ride* ride, StationIndex stationIndex)
     else
     {
         // Check if all vehicles are ready to go
-        for (size_t i = 0; i < ride->NumTrains; i++)
+        for (size_t i = 0; i < ride.NumTrains; i++)
         {
-            Vehicle* vehicle = GetEntity<Vehicle>(ride->vehicles[i]);
+            Vehicle* vehicle = GetEntity<Vehicle>(ride.vehicles[i]);
             if (vehicle == nullptr)
                 continue;
 
@@ -254,13 +254,13 @@ static void ride_update_station_race(Ride* ride, StationIndex stationIndex)
 
         // Begin the race
         ride_race_init_vehicle_speeds(ride);
-        ride->lifecycle_flags |= RIDE_LIFECYCLE_PASS_STATION_NO_STOPPING;
+        ride.lifecycle_flags |= RIDE_LIFECYCLE_PASS_STATION_NO_STOPPING;
         if (!(station.Depart & STATION_DEPART_FLAG))
         {
             station.Depart |= STATION_DEPART_FLAG;
             ride_invalidate_station_start(ride, stationIndex, true);
         }
-        ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAIN | RIDE_INVALIDATE_RIDE_LIST;
+        ride.window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAIN | RIDE_INVALIDATE_RIDE_LIST;
     }
 }
 
@@ -270,11 +270,11 @@ static void ride_update_station_race(Ride* ride, StationIndex stationIndex)
  * set the speed of the go kart type vehicle at the start to a random value or alter if peep name is an easter egg
  * @param ride (esi)
  */
-static void ride_race_init_vehicle_speeds(Ride* ride)
+static void ride_race_init_vehicle_speeds(const Ride& ride)
 {
-    for (size_t i = 0; i < ride->NumTrains; i++)
+    for (size_t i = 0; i < ride.NumTrains; i++)
     {
-        Vehicle* vehicle = GetEntity<Vehicle>(ride->vehicles[i]);
+        Vehicle* vehicle = GetEntity<Vehicle>(ride.vehicles[i]);
         if (vehicle == nullptr)
             continue;
 
@@ -318,9 +318,9 @@ static void ride_race_init_vehicle_speeds(Ride* ride)
  *
  *  rct2: 0x006AC2C7
  */
-static void ride_invalidate_station_start(Ride* ride, StationIndex stationIndex, bool greenLight)
+static void ride_invalidate_station_start(Ride& ride, StationIndex stationIndex, bool greenLight)
 {
-    auto startPos = ride->GetStation(stationIndex).Start;
+    auto startPos = ride.GetStation(stationIndex).Start;
     TileElement* tileElement = ride_get_station_start_track_element(ride, stationIndex);
 
     // If no station track found return
@@ -333,9 +333,9 @@ static void ride_invalidate_station_start(Ride* ride, StationIndex stationIndex,
     MapInvalidateTileZoom1({ startPos, tileElement->GetBaseZ(), tileElement->GetClearanceZ() });
 }
 
-TileElement* ride_get_station_start_track_element(const Ride* ride, StationIndex stationIndex)
+TileElement* ride_get_station_start_track_element(const Ride& ride, StationIndex stationIndex)
 {
-    auto stationStart = ride->GetStation(stationIndex).GetStart();
+    auto stationStart = ride.GetStation(stationIndex).GetStart();
 
     // Find the station track element
     TileElement* tileElement = MapGetFirstElementAt(stationStart);
@@ -368,37 +368,37 @@ TileElement* ride_get_station_exit_element(const CoordsXYZ& elementPos)
     return nullptr;
 }
 
-StationIndex ride_get_first_valid_station_exit(Ride* ride)
+StationIndex ride_get_first_valid_station_exit(const Ride& ride)
 {
-    for (const auto& station : ride->GetStations())
+    for (const auto& station : ride.GetStations())
     {
         if (!station.Exit.IsNull())
         {
-            return ride->GetStationIndex(&station);
+            return ride.GetStationIndex(&station);
         }
     }
     return StationIndex::GetNull();
 }
 
-StationIndex ride_get_first_valid_station_start(const Ride* ride)
+StationIndex ride_get_first_valid_station_start(const Ride& ride)
 {
-    for (const auto& station : ride->GetStations())
+    for (const auto& station : ride.GetStations())
     {
         if (!station.Start.IsNull())
         {
-            return ride->GetStationIndex(&station);
+            return ride.GetStationIndex(&station);
         }
     }
     return StationIndex::GetNull();
 }
 
-StationIndex ride_get_first_empty_station_start(const Ride* ride)
+StationIndex ride_get_first_empty_station_start(const Ride& ride)
 {
-    for (const auto& station : ride->GetStations())
+    for (const auto& station : ride.GetStations())
     {
         if (station.Start.IsNull())
         {
-            return ride->GetStationIndex(&station);
+            return ride.GetStationIndex(&station);
         }
     }
     return StationIndex::GetNull();
diff --git a/src/openrct2/ride/Station.h b/src/openrct2/ride/Station.h
index 2bc782ecb0..9edfb48b83 100644
--- a/src/openrct2/ride/Station.h
+++ b/src/openrct2/ride/Station.h
@@ -15,7 +15,7 @@
 struct Ride;
 struct TileCoordsXYZD;
 
-void ride_update_station(Ride* ride, StationIndex stationIndex);
-StationIndex ride_get_first_valid_station_exit(Ride* ride);
-StationIndex ride_get_first_valid_station_start(const Ride* ride);
-StationIndex ride_get_first_empty_station_start(const Ride* ride);
+void ride_update_station(Ride& ride, StationIndex stationIndex);
+StationIndex ride_get_first_valid_station_exit(const Ride& ride);
+StationIndex ride_get_first_valid_station_start(const Ride& ride);
+StationIndex ride_get_first_empty_station_start(const Ride& ride);
diff --git a/src/openrct2/ride/Track.cpp b/src/openrct2/ride/Track.cpp
index 12e5847726..093f4f31c8 100644
--- a/src/openrct2/ride/Track.cpp
+++ b/src/openrct2/ride/Track.cpp
@@ -93,15 +93,15 @@ static TileElement* find_station_element(const CoordsXYZD& loc, RideId rideIndex
     return nullptr;
 }
 
-static void ride_remove_station(Ride* ride, const CoordsXYZ& location)
+static void ride_remove_station(Ride& ride, const CoordsXYZ& location)
 {
-    for (auto& station : ride->GetStations())
+    for (auto& station : ride.GetStations())
     {
         auto stationStart = station.GetStart();
         if (stationStart == location)
         {
             station.Start.SetNull();
-            ride->num_stations--;
+            ride.num_stations--;
             break;
         }
     }
@@ -129,7 +129,7 @@ ResultWithMessage track_add_station_element(CoordsXYZD loc, RideId rideIndex, in
         }
         if (flags & GAME_COMMAND_FLAG_APPLY)
         {
-            auto stationIndex = ride_get_first_empty_station_start(ride);
+            auto stationIndex = ride_get_first_empty_station_start(*ride);
             assert(!stationIndex.IsNull());
 
             auto& station = ride->GetStation(stationIndex);
@@ -158,7 +158,7 @@ ResultWithMessage track_add_station_element(CoordsXYZD loc, RideId rideIndex, in
             {
                 if (flags & GAME_COMMAND_FLAG_APPLY)
                 {
-                    ride_remove_station(ride, loc);
+                    ride_remove_station(*ride, loc);
                 }
             }
 
@@ -180,7 +180,7 @@ ResultWithMessage track_add_station_element(CoordsXYZD loc, RideId rideIndex, in
             {
                 if (flags & GAME_COMMAND_FLAG_APPLY)
                 {
-                    ride_remove_station(ride, loc);
+                    ride_remove_station(*ride, loc);
                 }
             }
 
@@ -217,7 +217,7 @@ ResultWithMessage track_add_station_element(CoordsXYZD loc, RideId rideIndex, in
                 track_type_t targetTrackType;
                 if (stationFrontLoc == loc)
                 {
-                    auto stationIndex = ride_get_first_empty_station_start(ride);
+                    auto stationIndex = ride_get_first_empty_station_start(*ride);
                     if (stationIndex.IsNull())
                     {
                         log_verbose("No empty station starts, not updating metadata! This can happen with hacked rides.");
@@ -280,7 +280,7 @@ ResultWithMessage track_remove_station_element(const CoordsXYZD& loc, RideId rid
         {
             if (flags & GAME_COMMAND_FLAG_APPLY)
             {
-                ride_remove_station(ride, loc);
+                ride_remove_station(*ride, loc);
             }
         }
         return { true };
@@ -296,7 +296,7 @@ ResultWithMessage track_remove_station_element(const CoordsXYZD& loc, RideId rid
         {
             if (flags & GAME_COMMAND_FLAG_APPLY)
             {
-                ride_remove_station(ride, currentLoc);
+                ride_remove_station(*ride, currentLoc);
             }
         }
 
@@ -319,7 +319,7 @@ ResultWithMessage track_remove_station_element(const CoordsXYZD& loc, RideId rid
             {
                 if (flags & GAME_COMMAND_FLAG_APPLY)
                 {
-                    ride_remove_station(ride, currentLoc);
+                    ride_remove_station(*ride, currentLoc);
                 }
             }
             stationFrontLoc = currentLoc;
@@ -352,7 +352,7 @@ ResultWithMessage track_remove_station_element(const CoordsXYZD& loc, RideId rid
                 track_type_t targetTrackType;
                 if ((currentLoc == stationFrontLoc) || (currentLoc + CoordsDirectionDelta[currentLoc.direction] == removeLoc))
                 {
-                    auto stationIndex = ride_get_first_empty_station_start(ride);
+                    auto stationIndex = ride_get_first_empty_station_start(*ride);
                     if (stationIndex.IsNull())
                     {
                         log_verbose("No empty station starts, not updating metadata! This can happen with hacked rides.");
diff --git a/src/openrct2/ride/TrackDesign.cpp b/src/openrct2/ride/TrackDesign.cpp
index e0c8dee86f..33e554492c 100644
--- a/src/openrct2/ride/TrackDesign.cpp
+++ b/src/openrct2/ride/TrackDesign.cpp
@@ -175,7 +175,7 @@ ResultWithMessage TrackDesign::CreateTrackDesign(TrackDesignState& tds, const Ri
 ResultWithMessage TrackDesign::CreateTrackDesignTrack(TrackDesignState& tds, const Ride& ride)
 {
     CoordsXYE trackElement;
-    if (!ride_try_get_origin_element(&ride, &trackElement))
+    if (!ride_try_get_origin_element(ride, &trackElement))
     {
         return { false, STR_TRACK_TOO_LARGE_OR_TOO_MUCH_SCENERY };
     }
@@ -336,7 +336,8 @@ ResultWithMessage TrackDesign::CreateTrackDesignTrack(TrackDesignState& tds, con
         }
     }
 
-    TrackDesignPreviewDrawOutlines(tds, this, GetOrAllocateRide(PreviewRideId), { 4096, 4096, 0, _currentTrackPieceDirection });
+    TrackDesignPreviewDrawOutlines(
+        tds, this, *GetOrAllocateRide(PreviewRideId), { 4096, 4096, 0, _currentTrackPieceDirection });
 
     // Resave global vars for scenery reasons.
     tds.Origin = startPos;
@@ -455,7 +456,8 @@ ResultWithMessage TrackDesign::CreateTrackDesignMaze(TrackDesignState& tds, cons
 
     // Save global vars as they are still used by scenery????
     int32_t startZ = tds.Origin.z;
-    TrackDesignPreviewDrawOutlines(tds, this, GetOrAllocateRide(PreviewRideId), { 4096, 4096, 0, _currentTrackPieceDirection });
+    TrackDesignPreviewDrawOutlines(
+        tds, this, *GetOrAllocateRide(PreviewRideId), { 4096, 4096, 0, _currentTrackPieceDirection });
     tds.Origin = { startLoc.x, startLoc.y, startZ };
 
     gMapSelectFlags &= ~MAP_SELECT_FLAG_ENABLE_CONSTRUCT;
@@ -1346,7 +1348,8 @@ static GameActions::Result TrackDesignPlaceAllScenery(
     return res;
 }
 
-static GameActions::Result TrackDesignPlaceMaze(TrackDesignState& tds, TrackDesign* td6, const CoordsXYZ& coords, Ride* ride)
+static GameActions::Result TrackDesignPlaceMaze(
+    TrackDesignState& tds, TrackDesign* td6, const CoordsXYZ& coords, const Ride& ride)
 {
     if (tds.PlaceOperation == PTD_OPERATION_DRAW_OUTLINES)
     {
@@ -1413,7 +1416,7 @@ static GameActions::Result TrackDesignPlaceMaze(TrackDesignState& tds, TrackDesi
                             flags |= GAME_COMMAND_FLAG_REPLAY;
                         }
                         auto rideEntranceExitPlaceAction = RideEntranceExitPlaceAction(
-                            mapCoord, rotation, ride->id, StationIndex::FromUnderlying(0), false);
+                            mapCoord, rotation, ride.id, StationIndex::FromUnderlying(0), false);
                         rideEntranceExitPlaceAction.SetFlags(flags);
                         auto res = GameActions::ExecuteNested(&rideEntranceExitPlaceAction);
                         if (res.Error != GameActions::Status::Ok)
@@ -1458,7 +1461,7 @@ static GameActions::Result TrackDesignPlaceMaze(TrackDesignState& tds, TrackDesi
                             flags |= GAME_COMMAND_FLAG_REPLAY;
                         }
                         auto rideEntranceExitPlaceAction = RideEntranceExitPlaceAction(
-                            mapCoord, rotation, ride->id, StationIndex::FromUnderlying(0), true);
+                            mapCoord, rotation, ride.id, StationIndex::FromUnderlying(0), true);
                         rideEntranceExitPlaceAction.SetFlags(flags);
                         auto res = GameActions::ExecuteNested(&rideEntranceExitPlaceAction);
                         if (res.Error != GameActions::Status::Ok)
@@ -1495,7 +1498,7 @@ static GameActions::Result TrackDesignPlaceMaze(TrackDesignState& tds, TrackDesi
                         flags |= GAME_COMMAND_FLAG_REPLAY;
                     }
 
-                    auto mazePlace = MazePlaceTrackAction({ mapCoord, coords.z }, ride->id, maze_entry);
+                    auto mazePlace = MazePlaceTrackAction({ mapCoord, coords.z }, ride.id, maze_entry);
                     mazePlace.SetFlags(flags);
                     auto res = flags & GAME_COMMAND_FLAG_APPLY ? GameActions::ExecuteNested(&mazePlace)
                                                                : GameActions::QueryNested(&mazePlace);
@@ -1546,7 +1549,7 @@ static GameActions::Result TrackDesignPlaceMaze(TrackDesignState& tds, TrackDesi
 
     if (tds.PlaceOperation == PTD_OPERATION_REMOVE_GHOST)
     {
-        auto gameAction = RideDemolishAction(ride->id, RIDE_MODIFY_DEMOLISH);
+        auto gameAction = RideDemolishAction(ride.id, RIDE_MODIFY_DEMOLISH);
         gameAction.SetFlags(GAME_COMMAND_FLAG_ALLOW_DURING_PAUSED | GAME_COMMAND_FLAG_NO_SPEND | GAME_COMMAND_FLAG_GHOST);
         GameActions::Execute(&gameAction);
     }
@@ -1559,7 +1562,7 @@ static GameActions::Result TrackDesignPlaceMaze(TrackDesignState& tds, TrackDesi
     return res;
 }
 
-static GameActions::Result TrackDesignPlaceRide(TrackDesignState& tds, TrackDesign* td6, const CoordsXYZ& origin, Ride* ride)
+static GameActions::Result TrackDesignPlaceRide(TrackDesignState& tds, TrackDesign* td6, const CoordsXYZ& origin, Ride& ride)
 {
     tds.Origin = origin;
     if (tds.PlaceOperation == PTD_OPERATION_DRAW_OUTLINES)
@@ -1649,7 +1652,7 @@ static GameActions::Result TrackDesignPlaceRide(TrackDesignState& tds, TrackDesi
                 }
 
                 auto trackPlaceAction = TrackPlaceAction(
-                    ride->id, trackType, ride->type, { newCoords, tempZ, static_cast<uint8_t>(rotation) }, brakeSpeed,
+                    ride.id, trackType, ride.type, { newCoords, tempZ, static_cast<uint8_t>(rotation) }, brakeSpeed,
                     trackColour, seatRotation, liftHillAndAlternativeState, true);
                 trackPlaceAction.SetFlags(flags);
 
@@ -1786,7 +1789,7 @@ static GameActions::Result TrackDesignPlaceRide(TrackDesignState& tds, TrackDesi
                         }
 
                         auto rideEntranceExitPlaceAction = RideEntranceExitPlaceAction(
-                            newCoords, rotation, ride->id, stationIndex, entrance.isExit);
+                            newCoords, rotation, ride.id, stationIndex, entrance.isExit);
                         rideEntranceExitPlaceAction.SetFlags(flags);
                         auto res = flags & GAME_COMMAND_FLAG_APPLY ? GameActions::ExecuteNested(&rideEntranceExitPlaceAction)
                                                                    : GameActions::QueryNested(&rideEntranceExitPlaceAction);
@@ -1823,8 +1826,8 @@ static GameActions::Result TrackDesignPlaceRide(TrackDesignState& tds, TrackDesi
 
     if (tds.PlaceOperation == PTD_OPERATION_REMOVE_GHOST)
     {
-        ride->ValidateStations();
-        ride->Delete();
+        ride.ValidateStations();
+        ride.Delete();
     }
 
     auto res = GameActions::Result(GameActions::Status::Ok, STR_NONE, STR_NONE);
@@ -1847,7 +1850,7 @@ static GameActions::Result TrackDesignPlaceRide(TrackDesignState& tds, TrackDesi
  *  rct2: 0x006D01B3
  */
 static GameActions::Result TrackDesignPlaceVirtual(
-    TrackDesignState& tds, TrackDesign* td6, uint8_t ptdOperation, bool placeScenery, Ride* ride, const CoordsXYZD& coords)
+    TrackDesignState& tds, TrackDesign* td6, uint8_t ptdOperation, bool placeScenery, Ride& ride, const CoordsXYZD& coords)
 {
     _trackDesignPlaceStateSceneryUnavailable = false;
     _trackDesignPlaceStateEntranceExitPlaced = false;
@@ -1872,7 +1875,7 @@ static GameActions::Result TrackDesignPlaceVirtual(
     // NOTE: We need to save this, in networked games this would affect all clients otherwise.
     auto savedRideId = _currentRideIndex;
     auto savedTrackPieceDirection = _currentTrackPieceDirection;
-    _currentRideIndex = ride->id;
+    _currentRideIndex = ride.id;
     _currentTrackPieceDirection = coords.direction;
 
     GameActions::Result trackPlaceRes;
@@ -1915,7 +1918,7 @@ static GameActions::Result TrackDesignPlaceVirtual(
     return res;
 }
 
-GameActions::Result TrackDesignPlace(TrackDesign* td6, uint32_t flags, bool placeScenery, Ride* ride, const CoordsXYZD& coords)
+GameActions::Result TrackDesignPlace(TrackDesign* td6, uint32_t flags, bool placeScenery, Ride& ride, const CoordsXYZD& coords)
 {
     uint32_t ptdOperation = (flags & GAME_COMMAND_FLAG_APPLY) != 0 ? PTD_OPERATION_PLACE : PTD_OPERATION_PLACE_QUERY;
     if ((flags & GAME_COMMAND_FLAG_APPLY) != 0 && (flags & GAME_COMMAND_FLAG_GHOST) != 0)
@@ -1929,18 +1932,18 @@ GameActions::Result TrackDesignPlace(TrackDesign* td6, uint32_t flags, bool plac
     return TrackDesignPlaceVirtual(tds, td6, ptdOperation, placeScenery, ride, coords);
 }
 
-void TrackDesignPreviewRemoveGhosts(TrackDesign* td6, Ride* ride, const CoordsXYZD& coords)
+void TrackDesignPreviewRemoveGhosts(TrackDesign* td6, Ride& ride, const CoordsXYZD& coords)
 {
     TrackDesignState tds{};
     TrackDesignPlaceVirtual(tds, td6, PTD_OPERATION_REMOVE_GHOST, true, ride, coords);
 }
 
-void TrackDesignPreviewDrawOutlines(TrackDesignState& tds, TrackDesign* td6, Ride* ride, const CoordsXYZD& coords)
+void TrackDesignPreviewDrawOutlines(TrackDesignState& tds, TrackDesign* td6, Ride& ride, const CoordsXYZD& coords)
 {
     TrackDesignPlaceVirtual(tds, td6, PTD_OPERATION_DRAW_OUTLINES, true, ride, coords);
 }
 
-static int32_t TrackDesignGetZPlacement(TrackDesignState& tds, TrackDesign* td6, Ride* ride, const CoordsXYZD& coords)
+static int32_t TrackDesignGetZPlacement(TrackDesignState& tds, TrackDesign* td6, Ride& ride, const CoordsXYZD& coords)
 {
     TrackDesignPlaceVirtual(tds, td6, PTD_OPERATION_GET_PLACE_Z, true, ride, coords);
 
@@ -1949,7 +1952,7 @@ static int32_t TrackDesignGetZPlacement(TrackDesignState& tds, TrackDesign* td6,
     return tds.PlaceZ - tds.PlaceSceneryZ;
 }
 
-int32_t TrackDesignGetZPlacement(TrackDesign* td6, Ride* ride, const CoordsXYZD& coords)
+int32_t TrackDesignGetZPlacement(TrackDesign* td6, Ride& ride, const CoordsXYZD& coords)
 {
     TrackDesignState tds{};
     return TrackDesignGetZPlacement(tds, td6, ride, coords);
@@ -2033,7 +2036,7 @@ static bool TrackDesignPlacePreview(TrackDesignState& tds, TrackDesign* td6, mon
 
     _currentTrackPieceDirection = 0;
     int32_t z = TrackDesignGetZPlacement(
-        tds, td6, GetOrAllocateRide(PreviewRideId), { mapSize.x, mapSize.y, 16, _currentTrackPieceDirection });
+        tds, td6, *GetOrAllocateRide(PreviewRideId), { mapSize.x, mapSize.y, 16, _currentTrackPieceDirection });
 
     if (tds.HasScenery)
     {
@@ -2050,7 +2053,7 @@ static bool TrackDesignPlacePreview(TrackDesignState& tds, TrackDesign* td6, mon
     }
 
     auto res = TrackDesignPlaceVirtual(
-        tds, td6, PTD_OPERATION_PLACE_TRACK_PREVIEW, placeScenery, ride,
+        tds, td6, PTD_OPERATION_PLACE_TRACK_PREVIEW, placeScenery, *ride,
         { mapSize.x, mapSize.y, z, _currentTrackPieceDirection });
     gParkFlags = backup_park_flags;
 
diff --git a/src/openrct2/ride/TrackDesign.h b/src/openrct2/ride/TrackDesign.h
index 543a003dfc..185c08cfa2 100644
--- a/src/openrct2/ride/TrackDesign.h
+++ b/src/openrct2/ride/TrackDesign.h
@@ -225,10 +225,10 @@ extern RideId gTrackDesignSaveRideIndex;
 
 void TrackDesignMirror(TrackDesign* td6);
 
-GameActions::Result TrackDesignPlace(TrackDesign* td6, uint32_t flags, bool placeScenery, Ride* ride, const CoordsXYZD& coords);
-void TrackDesignPreviewRemoveGhosts(TrackDesign* td6, Ride* ride, const CoordsXYZD& coords);
-void TrackDesignPreviewDrawOutlines(TrackDesignState& tds, TrackDesign* td6, Ride* ride, const CoordsXYZD& coords);
-int32_t TrackDesignGetZPlacement(TrackDesign* td6, Ride* ride, const CoordsXYZD& coords);
+GameActions::Result TrackDesignPlace(TrackDesign* td6, uint32_t flags, bool placeScenery, Ride& ride, const CoordsXYZD& coords);
+void TrackDesignPreviewRemoveGhosts(TrackDesign* td6, Ride& ride, const CoordsXYZD& coords);
+void TrackDesignPreviewDrawOutlines(TrackDesignState& tds, TrackDesign* td6, Ride& ride, const CoordsXYZD& coords);
+int32_t TrackDesignGetZPlacement(TrackDesign* td6, Ride& ride, const CoordsXYZD& coords);
 
 ///////////////////////////////////////////////////////////////////////////////
 // Track design preview
diff --git a/src/openrct2/ride/Vehicle.cpp b/src/openrct2/ride/Vehicle.cpp
index 45f15b9c68..880563c115 100644
--- a/src/openrct2/ride/Vehicle.cpp
+++ b/src/openrct2/ride/Vehicle.cpp
@@ -1266,7 +1266,7 @@ bool Vehicle::CloseRestraints()
             {
                 curRide->lifecycle_flags |= RIDE_LIFECYCLE_BROKEN_DOWN;
 
-                ride_breakdown_add_news_item(curRide);
+                ride_breakdown_add_news_item(*curRide);
 
                 curRide->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAIN | RIDE_INVALIDATE_RIDE_LIST
                     | RIDE_INVALIDATE_RIDE_MAINTENANCE;
@@ -1382,7 +1382,7 @@ bool Vehicle::OpenRestraints()
             {
                 curRide->lifecycle_flags |= RIDE_LIFECYCLE_BROKEN_DOWN;
 
-                ride_breakdown_add_news_item(curRide);
+                ride_breakdown_add_news_item(*curRide);
 
                 curRide->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAIN | RIDE_INVALIDATE_RIDE_LIST
                     | RIDE_INVALIDATE_RIDE_MAINTENANCE;
@@ -1413,33 +1413,33 @@ bool Vehicle::OpenRestraints()
     return restraintsOpen;
 }
 
-void RideUpdateMeasurementsSpecialElements_Default(Ride* ride, const track_type_t trackType)
+void RideUpdateMeasurementsSpecialElements_Default(Ride& ride, const track_type_t trackType)
 {
     const auto& ted = GetTrackElementDescriptor(trackType);
     uint16_t trackFlags = ted.Flags;
     if (trackFlags & TRACK_ELEM_FLAG_NORMAL_TO_INVERSION)
     {
-        if (ride->inversions < OpenRCT2::Limits::MaxInversions)
-            ride->inversions++;
+        if (ride.inversions < OpenRCT2::Limits::MaxInversions)
+            ride.inversions++;
     }
 }
 
-void RideUpdateMeasurementsSpecialElements_MiniGolf(Ride* ride, const track_type_t trackType)
+void RideUpdateMeasurementsSpecialElements_MiniGolf(Ride& ride, const track_type_t trackType)
 {
     const auto& ted = GetTrackElementDescriptor(trackType);
     uint16_t trackFlags = ted.Flags;
     if (trackFlags & TRACK_ELEM_FLAG_IS_GOLF_HOLE)
     {
-        if (ride->holes < OpenRCT2::Limits::MaxGolfHoles)
-            ride->holes++;
+        if (ride.holes < OpenRCT2::Limits::MaxGolfHoles)
+            ride.holes++;
     }
 }
 
-void RideUpdateMeasurementsSpecialElements_WaterCoaster(Ride* ride, const track_type_t trackType)
+void RideUpdateMeasurementsSpecialElements_WaterCoaster(Ride& ride, const track_type_t trackType)
 {
     if (trackType >= TrackElemType::FlatCovered && trackType <= TrackElemType::RightQuarterTurn3TilesCovered)
     {
-        ride->special_track_elements |= RIDE_ELEMENT_TUNNEL_SPLASH_OR_RAPIDS;
+        ride.special_track_elements |= RIDE_ELEMENT_TUNNEL_SPLASH_OR_RAPIDS;
     }
 }
 
@@ -1548,7 +1548,7 @@ void Vehicle::UpdateMeasurements()
         }
 
         const auto& rtd = curRide->GetRideTypeDescriptor();
-        rtd.UpdateMeasurementsSpecialElements(curRide, trackElemType);
+        rtd.UpdateMeasurementsSpecialElements(*curRide, trackElemType);
 
         switch (trackElemType)
         {
@@ -1600,16 +1600,16 @@ void Vehicle::UpdateMeasurements()
             switch (curRide->turn_count_default >> 11)
             {
                 case 0:
-                    increment_turn_count_1_element(curRide, turnType);
+                    increment_turn_count_1_element(*curRide, turnType);
                     break;
                 case 1:
-                    increment_turn_count_2_elements(curRide, turnType);
+                    increment_turn_count_2_elements(*curRide, turnType);
                     break;
                 case 2:
-                    increment_turn_count_3_elements(curRide, turnType);
+                    increment_turn_count_3_elements(*curRide, turnType);
                     break;
                 default:
-                    increment_turn_count_4_plus_elements(curRide, turnType);
+                    increment_turn_count_4_plus_elements(*curRide, turnType);
                     break;
             }
         }
@@ -1711,7 +1711,7 @@ void Vehicle::UpdateMeasurements()
 
         if (trackFlags & TRACK_ELEM_FLAG_HELIX)
         {
-            uint8_t helixes = ride_get_helix_sections(curRide);
+            uint8_t helixes = ride_get_helix_sections(*curRide);
             if (helixes != OpenRCT2::Limits::MaxHelices)
                 helixes++;
 
@@ -2129,20 +2129,20 @@ void Vehicle::TrainReadyToDepart(uint8_t num_peeps_on_train, uint8_t num_used_se
     SetState(Vehicle::Status::WaitingForPassengers);
 }
 
-static std::optional<uint32_t> ride_get_train_index_from_vehicle(Ride* ride, EntityId spriteIndex)
+static std::optional<uint32_t> ride_get_train_index_from_vehicle(const Ride& ride, EntityId spriteIndex)
 {
     uint32_t trainIndex = 0;
-    while (ride->vehicles[trainIndex] != spriteIndex)
+    while (ride.vehicles[trainIndex] != spriteIndex)
     {
         trainIndex++;
-        if (trainIndex >= ride->NumTrains)
+        if (trainIndex >= ride.NumTrains)
         {
             // This should really return nullopt, but doing so
             // would break some hacked parks that hide track by setting tracked rides'
             // track type to, e.g., Crooked House
             break;
         }
-        if (trainIndex >= std::size(ride->vehicles))
+        if (trainIndex >= std::size(ride.vehicles))
         {
             return std::nullopt;
         }
@@ -2175,7 +2175,7 @@ void Vehicle::UpdateWaitingForPassengers()
             return;
         }
 
-        auto trainIndex = ride_get_train_index_from_vehicle(curRide, sprite_index);
+        auto trainIndex = ride_get_train_index_from_vehicle(*curRide, sprite_index);
         if (!trainIndex.has_value())
         {
             return;
@@ -2460,7 +2460,7 @@ void Vehicle::UpdateWaitingToDepart()
         int32_t direction;
 
         uint8_t trackDirection = GetTrackDirection();
-        if (track_block_get_next_from_zero(TrackLocation, curRide, trackDirection, &track, &zUnused, &direction, false))
+        if (track_block_get_next_from_zero(TrackLocation, *curRide, trackDirection, &track, &zUnused, &direction, false))
         {
             if (track.element->AsTrack()->HasCableLift())
             {
@@ -3111,7 +3111,7 @@ void Vehicle::UpdateDeparting()
                 return;
 
             curRide->lifecycle_flags |= RIDE_LIFECYCLE_BROKEN_DOWN;
-            ride_breakdown_add_news_item(curRide);
+            ride_breakdown_add_news_item(*curRide);
 
             curRide->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAIN | RIDE_INVALIDATE_RIDE_LIST
                 | RIDE_INVALIDATE_RIDE_MAINTENANCE;
@@ -3452,7 +3452,7 @@ void Vehicle::UpdateCollisionSetup()
     if (!(curRide->lifecycle_flags & RIDE_LIFECYCLE_CRASHED))
     {
         auto frontVehicle = GetHead();
-        auto trainIndex = ride_get_train_index_from_vehicle(curRide, frontVehicle->sprite_index);
+        auto trainIndex = ride_get_train_index_from_vehicle(*curRide, frontVehicle->sprite_index);
         if (!trainIndex.has_value())
         {
             return;
@@ -4141,7 +4141,7 @@ void Vehicle::UpdateTravellingCableLift()
                 return;
 
             curRide->lifecycle_flags |= RIDE_LIFECYCLE_BROKEN_DOWN;
-            ride_breakdown_add_news_item(curRide);
+            ride_breakdown_add_news_item(*curRide);
             curRide->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAIN | RIDE_INVALIDATE_RIDE_LIST
                 | RIDE_INVALIDATE_RIDE_MAINTENANCE;
 
@@ -5147,24 +5147,24 @@ static TileElement* vehicle_check_collision(const CoordsXYZ& vehiclePosition)
     return nullptr;
 }
 
-static void ride_train_crash(Ride* ride, uint16_t numFatalities)
+static void ride_train_crash(Ride& ride, uint16_t numFatalities)
 {
     Formatter ft;
     ft.Add<uint16_t>(numFatalities);
 
     uint8_t crashType = numFatalities == 0 ? RIDE_CRASH_TYPE_NO_FATALITIES : RIDE_CRASH_TYPE_FATALITIES;
 
-    if (crashType >= ride->last_crash_type)
-        ride->last_crash_type = crashType;
+    if (crashType >= ride.last_crash_type)
+        ride.last_crash_type = crashType;
 
     if (numFatalities != 0)
     {
         if (gConfigNotifications.RideCasualties)
         {
-            ride->FormatNameTo(ft);
+            ride.FormatNameTo(ft);
             News::AddItemToQueue(
                 News::ItemType::Ride, numFatalities == 1 ? STR_X_PERSON_DIED_ON_X : STR_X_PEOPLE_DIED_ON_X,
-                ride->id.ToUnderlying(), ft);
+                ride.id.ToUnderlying(), ft);
         }
 
         if (gParkRatingCasualtyPenalty < 500)
@@ -5183,7 +5183,7 @@ void Vehicle::KillAllPassengersInTrain()
     if (curRide == nullptr)
         return;
 
-    ride_train_crash(curRide, NumPeepsUntilTrainTail());
+    ride_train_crash(*curRide, NumPeepsUntilTrainTail());
 
     for (Vehicle* trainCar = GetEntity<Vehicle>(sprite_index); trainCar != nullptr;
          trainCar = GetEntity<Vehicle>(trainCar->next_vehicle_on_train))
@@ -5239,7 +5239,7 @@ void Vehicle::CrashOnLand()
     if (!(curRide->lifecycle_flags & RIDE_LIFECYCLE_CRASHED))
     {
         auto frontVehicle = GetHead();
-        auto trainIndex = ride_get_train_index_from_vehicle(curRide, frontVehicle->sprite_index);
+        auto trainIndex = ride_get_train_index_from_vehicle(*curRide, frontVehicle->sprite_index);
         if (!trainIndex.has_value())
         {
             return;
@@ -5307,7 +5307,7 @@ void Vehicle::CrashOnWater()
     if (!(curRide->lifecycle_flags & RIDE_LIFECYCLE_CRASHED))
     {
         auto frontVehicle = GetHead();
-        auto trainIndex = ride_get_train_index_from_vehicle(curRide, frontVehicle->sprite_index);
+        auto trainIndex = ride_get_train_index_from_vehicle(*curRide, frontVehicle->sprite_index);
         if (!trainIndex.has_value())
         {
             return;
@@ -6667,7 +6667,7 @@ void Vehicle::UpdateAdditionalAnimation()
                     auto curRide = GetRide();
                     if (curRide != nullptr)
                     {
-                        if (!ride_has_station_shelter(curRide)
+                        if (!ride_has_station_shelter(*curRide)
                             || (status != Vehicle::Status::MovingToEndOfStation && status != Vehicle::Status::Arriving))
                         {
                             int32_t typeIndex = [&] {
diff --git a/src/openrct2/ride/Vehicle.h b/src/openrct2/ride/Vehicle.h
index 8d2c53c215..4f9356aed0 100644
--- a/src/openrct2/ride/Vehicle.h
+++ b/src/openrct2/ride/Vehicle.h
@@ -532,9 +532,9 @@ void vehicle_update_all();
 void vehicle_sounds_update();
 uint16_t vehicle_get_move_info_size(VehicleTrackSubposition trackSubposition, track_type_t type, uint8_t direction);
 
-void RideUpdateMeasurementsSpecialElements_Default(Ride* ride, const track_type_t trackType);
-void RideUpdateMeasurementsSpecialElements_MiniGolf(Ride* ride, const track_type_t trackType);
-void RideUpdateMeasurementsSpecialElements_WaterCoaster(Ride* ride, const track_type_t trackType);
+void RideUpdateMeasurementsSpecialElements_Default(Ride& ride, const track_type_t trackType);
+void RideUpdateMeasurementsSpecialElements_MiniGolf(Ride& ride, const track_type_t trackType);
+void RideUpdateMeasurementsSpecialElements_WaterCoaster(Ride& ride, const track_type_t trackType);
 
 extern Vehicle* gCurrentVehicle;
 extern StationIndex _vehicleStationIndex;
diff --git a/src/openrct2/world/Entrance.cpp b/src/openrct2/world/Entrance.cpp
index 7e5a14e9b3..d70c2464b0 100644
--- a/src/openrct2/world/Entrance.cpp
+++ b/src/openrct2/world/Entrance.cpp
@@ -112,10 +112,10 @@ void RideEntranceExitRemoveGhost()
  *  rct2: 0x006CA28C
  */
 money32 RideEntranceExitPlaceGhost(
-    Ride* ride, const CoordsXY& entranceExitCoords, Direction direction, int32_t placeType, StationIndex stationNum)
+    const Ride& ride, const CoordsXY& entranceExitCoords, Direction direction, int32_t placeType, StationIndex stationNum)
 {
     ride_construction_remove_ghosts();
-    money32 result = RideEntranceExitPlaceGhost(ride->id, entranceExitCoords, direction, placeType, stationNum);
+    money32 result = RideEntranceExitPlaceGhost(ride.id, entranceExitCoords, direction, placeType, stationNum);
 
     if (result != MONEY32_UNDEFINED)
     {
diff --git a/src/openrct2/world/Park.cpp b/src/openrct2/world/Park.cpp
index 8c009f037d..1254b2ce87 100644
--- a/src/openrct2/world/Park.cpp
+++ b/src/openrct2/world/Park.cpp
@@ -423,7 +423,7 @@ int32_t Park::CalculateParkRating() const
         for (auto& ride : GetRideManager())
         {
             totalRideUptime += 100 - ride.downtime;
-            if (ride_has_ratings(&ride))
+            if (ride_has_ratings(ride))
             {
                 totalRideExcitement += ride.excitement / 8;
                 totalRideIntensity += ride.intensity / 8;
@@ -485,7 +485,7 @@ money64 Park::CalculateParkValue() const
     money64 result = 0;
     for (const auto& ride : GetRideManager())
     {
-        result += CalculateRideValue(&ride);
+        result += CalculateRideValue(ride);
     }
 
     // +7.00 per guest
@@ -494,13 +494,13 @@ money64 Park::CalculateParkValue() const
     return result;
 }
 
-money64 Park::CalculateRideValue(const Ride* ride) const
+money64 Park::CalculateRideValue(const Ride& ride) const
 {
     money64 result = 0;
-    if (ride != nullptr && ride->value != RIDE_VALUE_UNDEFINED)
+    if (ride.value != RIDE_VALUE_UNDEFINED)
     {
-        const auto& rtd = ride->GetRideTypeDescriptor();
-        result = ToMoney32FromGBP(static_cast<int32_t>(ride->value))
+        const auto& rtd = ride.GetRideTypeDescriptor();
+        result = ToMoney32FromGBP(static_cast<int32_t>(ride.value))
             * (static_cast<money64>(ride_customers_in_last_5_minutes(ride)) + rtd.BonusValue * 4LL);
     }
     return result;
diff --git a/src/openrct2/world/Park.h b/src/openrct2/world/Park.h
index ed8ab09285..f55b1185d1 100644
--- a/src/openrct2/world/Park.h
+++ b/src/openrct2/world/Park.h
@@ -80,7 +80,7 @@ namespace OpenRCT2
         void UpdateHistories();
 
     private:
-        money64 CalculateRideValue(const Ride* ride) const;
+        money64 CalculateRideValue(const Ride& ride) const;
         money16 CalculateTotalRideValueForMoney() const;
         uint32_t CalculateSuggestedMaxGuests() const;
         uint32_t CalculateGuestGenerationProbability() const;