From ab7b17fc4ebd7ae6965ca97ccf7d62127a0f8c31 Mon Sep 17 00:00:00 2001
From: Ted John <ted@brambles.org>
Date: Thu, 8 Aug 2019 22:58:56 +0100
Subject: [PATCH] Add nullptr checks for get_ride in libopenrct2 (#9788)

---
 src/openrct2/actions/LandSetHeightAction.hpp |   2 +-
 src/openrct2/actions/MazeSetTrackAction.hpp  |  15 +-
 src/openrct2/drawing/LightFX.cpp             |   5 +-
 src/openrct2/interface/Viewport.cpp          |   4 +-
 src/openrct2/management/Marketing.cpp        |   7 +-
 src/openrct2/peep/Guest.cpp                  | 133 +++++++++------
 src/openrct2/peep/GuestPathfinding.cpp       |  13 +-
 src/openrct2/peep/Peep.cpp                   |  29 ++--
 src/openrct2/peep/Staff.cpp                  |  30 ++--
 src/openrct2/rct1/S4Importer.cpp             |  56 +++---
 src/openrct2/ride/CableLift.cpp              |  10 +-
 src/openrct2/ride/CableLift.h                |   3 +-
 src/openrct2/ride/Ride.cpp                   | 128 +++++++-------
 src/openrct2/ride/Track.cpp                  |  20 ++-
 src/openrct2/ride/TrackDesign.cpp            |   5 +-
 src/openrct2/ride/TrackDesignSave.cpp        |  15 +-
 src/openrct2/ride/Vehicle.cpp                | 171 +++++++++++++------
 src/openrct2/ride/gentle/CircusShow.cpp      |   9 +-
 src/openrct2/ride/gentle/CrookedHouse.cpp    |   8 +-
 src/openrct2/ride/gentle/FerrisWheel.cpp     |  14 +-
 src/openrct2/ride/gentle/HauntedHouse.cpp    |  14 +-
 src/openrct2/ride/gentle/MerryGoRound.cpp    |  14 +-
 src/openrct2/ride/gentle/MiniGolf.cpp        |  18 +-
 src/openrct2/ride/gentle/SpiralSlide.cpp     |   4 +-
 src/openrct2/ride/shops/Facility.cpp         |  14 +-
 src/openrct2/ride/shops/Shop.cpp             |  18 +-
 src/openrct2/ride/thrill/3dCinema.cpp        |  12 +-
 src/openrct2/ride/thrill/MotionSimulator.cpp |   9 +-
 src/openrct2/ride/transport/Chairlift.cpp    |  12 +-
 src/openrct2/windows/_legacy.cpp             |   7 +-
 src/openrct2/world/Banner.cpp                |   4 +-
 src/openrct2/world/Footpath.cpp              |  19 ++-
 src/openrct2/world/Map.cpp                   |   7 +-
 33 files changed, 509 insertions(+), 320 deletions(-)

diff --git a/src/openrct2/actions/LandSetHeightAction.hpp b/src/openrct2/actions/LandSetHeightAction.hpp
index 47bd9b8b51..be3a099da1 100644
--- a/src/openrct2/actions/LandSetHeightAction.hpp
+++ b/src/openrct2/actions/LandSetHeightAction.hpp
@@ -266,7 +266,7 @@ private:
                         int32_t maxHeight = rideEntry->max_height;
                         if (maxHeight == 0)
                         {
-                            maxHeight = RideData5[get_ride(rideIndex)->type].max_height;
+                            maxHeight = RideData5[ride->type].max_height;
                         }
                         int32_t zDelta = tileElement->clearance_height - _height;
                         if (zDelta >= 0 && zDelta / 2 > maxHeight)
diff --git a/src/openrct2/actions/MazeSetTrackAction.hpp b/src/openrct2/actions/MazeSetTrackAction.hpp
index 0ced878c7d..0a20b6cf27 100644
--- a/src/openrct2/actions/MazeSetTrackAction.hpp
+++ b/src/openrct2/actions/MazeSetTrackAction.hpp
@@ -181,6 +181,14 @@ public:
         res->ExpenditureType = RCT_EXPENDITURE_TYPE_RIDE_CONSTRUCTION;
         res->ErrorTitle = STR_RIDE_CONSTRUCTION_CANT_CONSTRUCT_THIS_HERE;
 
+        auto ride = get_ride(_rideIndex);
+        if (ride == nullptr)
+        {
+            res->Error = GA_ERROR::INVALID_PARAMETERS;
+            res->ErrorMessage = STR_NONE;
+            return res;
+        }
+
         if (!map_check_free_elements_and_reorganise(1))
         {
             res->Error = GA_ERROR::NO_FREE_ELEMENTS;
@@ -198,13 +206,9 @@ public:
         uint8_t baseHeight = _loc.z / 8;
         uint8_t clearanceHeight = (_loc.z + 32) / 8;
 
-        TileElement* tileElement = map_get_track_element_at_of_type_from_ride(
-            _loc.x, _loc.y, baseHeight, TRACK_ELEM_MAZE, _rideIndex);
+        auto tileElement = map_get_track_element_at_of_type_from_ride(_loc.x, _loc.y, baseHeight, TRACK_ELEM_MAZE, _rideIndex);
         if (tileElement == nullptr)
         {
-            Ride* ride = get_ride(_rideIndex);
-            openrct2_assert(ride != nullptr, "Invalid ride index: %d\n", uint32_t(_rideIndex));
-
             money32 price = (((RideTrackCosts[ride->type].track_price * TrackPricing[TRACK_ELEM_MAZE]) >> 16));
             res->Cost = price / 2 * 10;
 
@@ -333,7 +337,6 @@ public:
 
         if ((tileElement->AsTrack()->GetMazeEntry() & 0x8888) == 0x8888)
         {
-            Ride* ride = get_ride(_rideIndex);
             tile_element_remove(tileElement);
             sub_6CB945(ride);
             ride->maze_tiles--;
diff --git a/src/openrct2/drawing/LightFX.cpp b/src/openrct2/drawing/LightFX.cpp
index 1c63d7b413..7691bd9c6e 100644
--- a/src/openrct2/drawing/LightFX.cpp
+++ b/src/openrct2/drawing/LightFX.cpp
@@ -785,7 +785,10 @@ void lightfx_add_lights_magic_vehicles()
                 -10, -10, -9, -8, -7, -6, -4, -2, 0, 2,  4,  6,  7,  8,  9,  10,
             };
 
-            Ride* ride = get_ride(vehicle->ride);
+            auto ride = get_ride(vehicle->ride);
+            if (ride == nullptr)
+                continue;
+
             switch (ride->type)
             {
                 case RIDE_TYPE_OBSERVATION_TOWER:
diff --git a/src/openrct2/interface/Viewport.cpp b/src/openrct2/interface/Viewport.cpp
index 4063fe882b..2d41fb9063 100644
--- a/src/openrct2/interface/Viewport.cpp
+++ b/src/openrct2/interface/Viewport.cpp
@@ -708,8 +708,8 @@ viewport_focus viewport_update_smart_guest_follow(rct_window* window, Peep* peep
         if (peep->state == PEEP_STATE_ON_RIDE || peep->state == PEEP_STATE_ENTERING_RIDE
             || (peep->state == PEEP_STATE_LEAVING_RIDE && peep->x == LOCATION_NULL))
         {
-            Ride* ride = get_ride(peep->current_ride);
-            if (ride->lifecycle_flags & RIDE_LIFECYCLE_ON_TRACK)
+            auto ride = get_ride(peep->current_ride);
+            if (ride != nullptr && (ride->lifecycle_flags & RIDE_LIFECYCLE_ON_TRACK))
             {
                 auto train = GET_VEHICLE(ride->vehicles[peep->current_train]);
                 if (train != nullptr)
diff --git a/src/openrct2/management/Marketing.cpp b/src/openrct2/management/Marketing.cpp
index 57f66e1ac6..8c650af40b 100644
--- a/src/openrct2/management/Marketing.cpp
+++ b/src/openrct2/management/Marketing.cpp
@@ -73,8 +73,11 @@ static void marketing_raise_finished_notification(const MarketingCampaign& campa
         // This sets the string parameters for the marketing types that have an argument.
         if (campaign.Type == ADVERTISING_CAMPAIGN_RIDE_FREE || campaign.Type == ADVERTISING_CAMPAIGN_RIDE)
         {
-            Ride* ride = get_ride(campaign.RideId);
-            ride->FormatNameTo(gCommonFormatArgs);
+            auto ride = get_ride(campaign.RideId);
+            if (ride != nullptr)
+            {
+                ride->FormatNameTo(gCommonFormatArgs);
+            }
         }
         else if (campaign.Type == ADVERTISING_CAMPAIGN_FOOD_OR_DRINK_FREE)
         {
diff --git a/src/openrct2/peep/Guest.cpp b/src/openrct2/peep/Guest.cpp
index 0f47fe4a49..763033a37b 100644
--- a/src/openrct2/peep/Guest.cpp
+++ b/src/openrct2/peep/Guest.cpp
@@ -1787,8 +1787,7 @@ void Guest::OnEnterRide(ride_id_t rideIndex)
  */
 void Guest::OnExitRide(ride_id_t rideIndex)
 {
-    Ride* ride = get_ride(rideIndex);
-
+    auto ride = get_ride(rideIndex);
     if (peep_flags & PEEP_FLAGS_RIDE_SHOULD_BE_MARKED_AS_FAVOURITE)
     {
         peep_flags &= ~PEEP_FLAGS_RIDE_SHOULD_BE_MARKED_AS_FAVOURITE;
@@ -1803,7 +1802,7 @@ void Guest::OnExitRide(ride_id_t rideIndex)
     if (peep_flags & PEEP_FLAGS_LEAVING_PARK)
         peep_flags &= ~(PEEP_FLAGS_PARK_ENTRANCE_CHOSEN);
 
-    if (peep_should_go_on_ride_again(this, ride))
+    if (ride != nullptr && peep_should_go_on_ride_again(this, ride))
     {
         guest_heading_to_ride_id = rideIndex;
         peep_is_lost_countdown = 200;
@@ -1819,7 +1818,7 @@ void Guest::OnExitRide(ride_id_t rideIndex)
         }
     }
 
-    if (peep_really_liked_ride(this, ride))
+    if (ride != nullptr && peep_really_liked_ride(this, ride))
     {
         InsertNewThought(PEEP_THOUGHT_TYPE_WAS_GREAT, rideIndex);
 
@@ -1831,8 +1830,11 @@ void Guest::OnExitRide(ride_id_t rideIndex)
         }
     }
 
-    ride->total_customers++;
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_CUSTOMER;
+    if (ride != nullptr)
+    {
+        ride->total_customers++;
+        ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_CUSTOMER;
+    }
 }
 
 /**
@@ -3338,11 +3340,14 @@ static bool peep_should_use_cash_machine(Peep* peep, ride_id_t rideIndex)
     if (peep->energy < 80)
         return false;
 
-    Ride* ride = get_ride(rideIndex);
-    ride_update_satisfaction(ride, peep->happiness >> 6);
-    ride->cur_num_customers++;
-    ride->total_customers++;
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_CUSTOMER;
+    auto ride = get_ride(rideIndex);
+    if (ride != nullptr)
+    {
+        ride_update_satisfaction(ride, peep->happiness >> 6);
+        ride->cur_num_customers++;
+        ride->total_customers++;
+        ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_CUSTOMER;
+    }
     return true;
 }
 
@@ -3355,8 +3360,8 @@ void Guest::UpdateBuying()
     if (!CheckForPath())
         return;
 
-    Ride* ride = get_ride(current_ride);
-    if (ride->type == RIDE_TYPE_NULL || ride->status != RIDE_STATUS_OPEN)
+    auto ride = get_ride(current_ride);
+    if (ride == nullptr || ride->status != RIDE_STATUS_OPEN)
     {
         SetState(PEEP_STATE_FALLING);
         return;
@@ -3464,7 +3469,9 @@ void Guest::UpdateBuying()
  */
 void Guest::UpdateRideAtEntrance()
 {
-    Ride* ride = get_ride(current_ride);
+    auto ride = get_ride(current_ride);
+    if (ride == nullptr)
+        return;
 
     // The peep will keep advancing in the entranceway
     // whilst in this state. When it has reached the very
@@ -3666,11 +3673,13 @@ static void peep_update_ride_leave_entrance_waypoints(Peep* peep, Ride* ride)
  */
 void Guest::UpdateRideAdvanceThroughEntrance()
 {
+    auto ride = get_ride(current_ride);
+    if (ride == nullptr)
+        return;
+
+    auto ride_entry = ride->GetRideEntry();
+
     int16_t actionX, actionY, actionZ, xy_distance;
-
-    Ride* ride = get_ride(current_ride);
-    rct_ride_entry* ride_entry = get_ride_entry(ride->subtype);
-
     if (UpdateAction(&actionX, &actionY, &xy_distance))
     {
         uint16_t distanceThreshold = 16;
@@ -4322,9 +4331,10 @@ void Guest::UpdateRideLeaveVehicle()
  */
 static void peep_update_ride_prepare_for_exit(Peep* peep)
 {
-    Ride* ride = get_ride(peep->current_ride);
+    auto ride = get_ride(peep->current_ride);
+    if (ride == nullptr || peep->current_ride_station >= std::size(ride->stations))
+        return;
 
-    Guard::Assert(peep->current_ride_station < std::size(ride->stations), GUARD_LINE);
     auto exit = ride_get_exit_location(ride, peep->current_ride_station);
     int16_t x = exit.x;
     int16_t y = exit.y;
@@ -4386,9 +4396,11 @@ void Guest::UpdateRideApproachExit()
  */
 void Guest::UpdateRideInExit()
 {
-    int16_t actionX, actionY, xy_distance;
-    Ride* ride = get_ride(current_ride);
+    auto ride = get_ride(current_ride);
+    if (ride == nullptr)
+        return;
 
+    int16_t actionX, actionY, xy_distance;
     if (UpdateAction(&actionX, &actionY, &xy_distance))
     {
         Invalidate();
@@ -4418,17 +4430,19 @@ void Guest::UpdateRideInExit()
     }
     sub_state = PEEP_RIDE_LEAVE_EXIT;
 }
-
+#pragma warning(default : 6011)
 /**
  *
  *  rct2: 0x006926AD
  */
 void Guest::UpdateRideApproachVehicleWaypoints()
 {
-    int16_t actionX, actionY, xy_distance;
-    Ride* ride = get_ride(current_ride);
-    uint8_t waypoint = var_37 & 3;
+    auto ride = get_ride(current_ride);
+    if (ride == nullptr)
+        return;
 
+    int16_t actionX, actionY, xy_distance;
+    uint8_t waypoint = var_37 & 3;
     if (UpdateAction(&actionX, &actionY, &xy_distance))
     {
         int16_t actionZ;
@@ -4501,9 +4515,11 @@ void Guest::UpdateRideApproachVehicleWaypoints()
  */
 void Guest::UpdateRideApproachExitWaypoints()
 {
-    int16_t actionX, actionY, xy_distance;
-    Ride* ride = get_ride(current_ride);
+    auto ride = get_ride(current_ride);
+    if (ride == nullptr)
+        return;
 
+    int16_t actionX, actionY, xy_distance;
     if (UpdateAction(&actionX, &actionY, &xy_distance))
     {
         int16_t actionZ;
@@ -4604,9 +4620,11 @@ void Guest::UpdateRideApproachExitWaypoints()
  */
 void Guest::UpdateRideApproachSpiralSlide()
 {
-    int16_t actionX, actionY, xy_distance;
-    Ride* ride = get_ride(current_ride);
+    auto ride = get_ride(current_ride);
+    if (ride == nullptr)
+        return;
 
+    int16_t actionX, actionY, xy_distance;
     if (UpdateAction(&actionX, &actionY, &xy_distance))
     {
         Invalidate();
@@ -4698,9 +4716,8 @@ static constexpr const CoordsXY _SpiralSlideEndWaypoint[] = {
  */
 void Guest::UpdateRideOnSpiralSlide()
 {
-    Ride* ride = get_ride(current_ride);
-
-    if (ride->type != RIDE_TYPE_SPIRAL_SLIDE)
+    auto ride = get_ride(current_ride);
+    if (ride == nullptr || ride->type != RIDE_TYPE_SPIRAL_SLIDE)
         return;
 
     if ((var_37 & 3) == 0)
@@ -4795,7 +4812,9 @@ void Guest::UpdateRideLeaveSpiralSlide()
         return;
     }
 
-    Ride* ride = get_ride(current_ride);
+    auto ride = get_ride(current_ride);
+    if (ride == nullptr)
+        return;
 
     uint8_t waypoint = var_37 & 3;
 
@@ -5030,19 +5049,22 @@ void Guest::UpdateRideMazePathfinding()
 void Guest::UpdateRideLeaveExit()
 {
     int16_t actionX, actionY, xy_distance;
-    Ride* ride = get_ride(current_ride);
+    auto ride = get_ride(current_ride);
 
     if (UpdateAction(&actionX, &actionY, &xy_distance))
     {
-        Invalidate();
-        MoveTo(actionX, actionY, ride->stations[current_ride_station].Height * 8);
-        Invalidate();
+        if (ride != nullptr)
+        {
+            Invalidate();
+            MoveTo(actionX, actionY, ride->stations[current_ride_station].Height * 8);
+            Invalidate();
+        }
         return;
     }
 
     OnExitRide(current_ride);
 
-    if (peep_flags & PEEP_FLAGS_TRACKING)
+    if (ride != nullptr && (peep_flags & PEEP_FLAGS_TRACKING))
     {
         auto nameArgLen = FormatNameTo(gCommonFormatArgs);
         ride->FormatNameTo(gCommonFormatArgs + nameArgLen);
@@ -5105,10 +5127,12 @@ void Guest::UpdateRideShopApproach()
  */
 void Guest::UpdateRideShopInteract()
 {
+    auto ride = get_ride(current_ride);
+    if (ride == nullptr)
+        return;
+
     const int16_t tileCenterX = next_x + 16;
     const int16_t tileCenterY = next_y + 16;
-    Ride* ride = get_ride(current_ride);
-
     if (ride->type == RIDE_TYPE_FIRST_AID)
     {
         if (nausea <= 35)
@@ -5176,11 +5200,13 @@ void Guest::UpdateRideShopLeave()
 
     SetState(PEEP_STATE_WALKING);
 
-    Ride* ride = get_ride(current_ride);
-    ride->total_customers++;
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_CUSTOMER;
-
-    ride_update_satisfaction(ride, happiness / 64);
+    auto ride = get_ride(current_ride);
+    if (ride != nullptr)
+    {
+        ride->total_customers++;
+        ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_CUSTOMER;
+        ride_update_satisfaction(ride, happiness / 64);
+    }
 }
 
 void Guest::UpdateGuest()
@@ -5607,8 +5633,8 @@ void Guest::UpdateQueuing()
         RemoveFromQueue();
         return;
     }
-    Ride* ride = get_ride(current_ride);
-    if (ride->status != RIDE_STATUS_OPEN)
+    auto ride = get_ride(current_ride);
+    if (ride == nullptr || ride->status != RIDE_STATUS_OPEN)
     {
         RemoveFromQueue();
         SetState(PEEP_STATE_1);
@@ -6377,8 +6403,6 @@ static void peep_update_walking_break_scenery(Peep* peep)
  */
 static bool peep_should_watch_ride(TileElement* tileElement)
 {
-    Ride* ride = get_ride(tileElement->AsTrack()->GetRideIndex());
-
     // Ghosts are purely this-client-side and should not cause any interaction,
     // as that may lead to a desync.
     if (network_get_mode() != NETWORK_MODE_NONE)
@@ -6387,7 +6411,8 @@ static bool peep_should_watch_ride(TileElement* tileElement)
             return false;
     }
 
-    if (!ride->IsRide())
+    auto ride = get_ride(tileElement->AsTrack()->GetRideIndex());
+    if (ride == nullptr || !ride->IsRide())
     {
         return false;
     }
@@ -6432,9 +6457,11 @@ static bool peep_should_watch_ride(TileElement* tileElement)
 
 bool loc_690FD0(Peep* peep, uint8_t* rideToView, uint8_t* rideSeatToView, TileElement* tileElement)
 {
-    Ride* ride = get_ride(tileElement->AsTrack()->GetRideIndex());
+    auto ride = get_ride(tileElement->AsTrack()->GetRideIndex());
+    if (ride == nullptr)
+        return false;
 
-    *rideToView = tileElement->AsTrack()->GetRideIndex();
+    *rideToView = ride->id;
     if (ride->excitement == RIDE_RATING_UNDEFINED)
     {
         *rideSeatToView = 1;
diff --git a/src/openrct2/peep/GuestPathfinding.cpp b/src/openrct2/peep/GuestPathfinding.cpp
index ddf2dd4d8f..2d0d94c0f2 100644
--- a/src/openrct2/peep/GuestPathfinding.cpp
+++ b/src/openrct2/peep/GuestPathfinding.cpp
@@ -302,8 +302,8 @@ static uint8_t footpath_element_dest_in_dir(
                 if (loc.z != tileElement->base_height)
                     continue;
                 ride_id_t rideIndex = tileElement->AsTrack()->GetRideIndex();
-                Ride* ride = get_ride(rideIndex);
-                if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_IS_SHOP))
+                auto ride = get_ride(rideIndex);
+                if (ride != nullptr && ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_IS_SHOP))
                 {
                     *outRideIndex = rideIndex;
                     return PATH_SEARCH_SHOP_ENTRANCE;
@@ -670,8 +670,8 @@ static void peep_pathfind_heuristic_search(
                 /* For peeps heading for a shop, the goal is the shop
                  * tile. */
                 rideIndex = tileElement->AsTrack()->GetRideIndex();
-                Ride* ride = get_ride(rideIndex);
-                if (!ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_IS_SHOP))
+                auto ride = get_ride(rideIndex);
+                if (ride == nullptr || !ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_IS_SHOP))
                     continue;
 
                 found = true;
@@ -2038,9 +2038,8 @@ int32_t guest_path_finding(Guest* peep)
 
     // Peep is heading for a ride.
     ride_id_t rideIndex = peep->guest_heading_to_ride_id;
-    Ride* ride = get_ride(rideIndex);
-
-    if (ride->status != RIDE_STATUS_OPEN)
+    auto ride = get_ride(rideIndex);
+    if (ride == nullptr || ride->status != RIDE_STATUS_OPEN)
     {
 #if defined(DEBUG_LEVEL_1) && DEBUG_LEVEL_1
         if (gPathFindDebug)
diff --git a/src/openrct2/peep/Peep.cpp b/src/openrct2/peep/Peep.cpp
index 6fedd244a5..e36029a68b 100644
--- a/src/openrct2/peep/Peep.cpp
+++ b/src/openrct2/peep/Peep.cpp
@@ -690,9 +690,12 @@ void peep_decrement_num_riders(Peep* peep)
 {
     if (peep->state == PEEP_STATE_ON_RIDE || peep->state == PEEP_STATE_ENTERING_RIDE)
     {
-        Ride* ride = get_ride(peep->current_ride);
-        ride->num_riders = std::max(0, ride->num_riders - 1);
-        ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAIN | RIDE_INVALIDATE_RIDE_LIST;
+        auto ride = get_ride(peep->current_ride);
+        if (ride != nullptr)
+        {
+            ride->num_riders = std::max(0, ride->num_riders - 1);
+            ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAIN | RIDE_INVALIDATE_RIDE_LIST;
+        }
     }
 }
 
@@ -711,9 +714,12 @@ void peep_window_state_update(Peep* peep)
     {
         if (peep->state == PEEP_STATE_ON_RIDE || peep->state == PEEP_STATE_ENTERING_RIDE)
         {
-            Ride* ride = get_ride(peep->current_ride);
-            ride->num_riders++;
-            ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAIN | RIDE_INVALIDATE_RIDE_LIST;
+            auto ride = get_ride(peep->current_ride);
+            if (ride != nullptr)
+            {
+                ride->num_riders++;
+                ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAIN | RIDE_INVALIDATE_RIDE_LIST;
+            }
         }
 
         window_invalidate_by_number(WC_PEEP, peep->sprite_index);
@@ -2371,6 +2377,8 @@ static void peep_interact_with_entrance(Peep* peep, int16_t x, int16_t y, TileEl
     uint8_t entranceType = tile_element->AsEntrance()->GetEntranceType();
     ride_id_t rideIndex = tile_element->AsEntrance()->GetRideIndex();
     auto ride = get_ride(rideIndex);
+    if (ride == nullptr)
+        return;
 
     // Store some details to determine when to override the default
     // behaviour (defined below) for when staff attempt to enter a ride
@@ -2942,9 +2950,8 @@ static void peep_interact_with_path(Peep* peep, int16_t x, int16_t y, TileElemen
 static bool peep_interact_with_shop(Peep* peep, int16_t x, int16_t y, TileElement* tile_element)
 {
     ride_id_t rideIndex = tile_element->AsTrack()->GetRideIndex();
-    Ride* ride = get_ride(rideIndex);
-
-    if (!ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_IS_SHOP))
+    auto ride = get_ride(rideIndex);
+    if (ride == nullptr || !ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_IS_SHOP))
         return false;
 
     auto guest = peep->AsGuest();
@@ -3555,7 +3562,9 @@ static void peep_release_balloon(Guest* peep, int16_t spawn_height)
  */
 void Peep::RemoveFromQueue()
 {
-    Ride* ride = get_ride(current_ride);
+    auto ride = get_ride(current_ride);
+    if (ride == nullptr)
+        return;
 
     auto& station = ride->stations[current_ride_station];
     // Make sure we don't underflow, building while paused might reset it to 0 where peeps have
diff --git a/src/openrct2/peep/Staff.cpp b/src/openrct2/peep/Staff.cpp
index dbdb878046..c597e29142 100644
--- a/src/openrct2/peep/Staff.cpp
+++ b/src/openrct2/peep/Staff.cpp
@@ -1414,9 +1414,8 @@ void Staff::UpdateSweeping()
  */
 void Staff::UpdateHeadingToInspect()
 {
-    Ride* ride = get_ride(current_ride);
-
-    if (ride->type == RIDE_TYPE_NULL)
+    auto ride = get_ride(current_ride);
+    if (ride == nullptr)
     {
         SetState(PEEP_STATE_FALLING);
         return;
@@ -1527,9 +1526,8 @@ void Staff::UpdateHeadingToInspect()
  */
 void Staff::UpdateAnswering()
 {
-    Ride* ride = get_ride(current_ride);
-
-    if (ride->type == RIDE_TYPE_NULL || ride->mechanic_status != RIDE_MECHANIC_STATUS_HEADING)
+    auto ride = get_ride(current_ride);
+    if (ride == nullptr || ride->mechanic_status != RIDE_MECHANIC_STATUS_HEADING)
     {
         SetState(PEEP_STATE_FALLING);
         return;
@@ -2073,9 +2071,8 @@ static constexpr const uint32_t FixingSubstatesForBreakdown[9] = {
  */
 void Staff::UpdateFixing(int32_t steps)
 {
-    Ride* ride = get_ride(current_ride);
-
-    if (ride->type == RIDE_TYPE_NULL)
+    auto ride = get_ride(current_ride);
+    if (ride == nullptr)
     {
         SetState(PEEP_STATE_FALLING);
         return;
@@ -2754,10 +2751,13 @@ bool Staff::UpdateFixingLeaveByEntranceExit(bool firstRun, Ride* ride)
  */
 void Staff::UpdateRideInspected(ride_id_t rideIndex)
 {
-    Ride* ride = get_ride(rideIndex);
-    ride->lifecycle_flags &= ~RIDE_LIFECYCLE_DUE_INSPECTION;
-
-    ride->reliability += ((100 - ride->reliability_percentage) / 4) * (scenario_rand() & 0xFF);
-    ride->last_inspection = 0;
-    ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAINTENANCE | RIDE_INVALIDATE_RIDE_MAIN | RIDE_INVALIDATE_RIDE_LIST;
+    auto ride = get_ride(rideIndex);
+    if (ride != nullptr)
+    {
+        ride->lifecycle_flags &= ~RIDE_LIFECYCLE_DUE_INSPECTION;
+        ride->reliability += ((100 - ride->reliability_percentage) / 4) * (scenario_rand() & 0xFF);
+        ride->last_inspection = 0;
+        ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAINTENANCE | RIDE_INVALIDATE_RIDE_MAIN
+            | RIDE_INVALIDATE_RIDE_LIST;
+    }
 }
diff --git a/src/openrct2/rct1/S4Importer.cpp b/src/openrct2/rct1/S4Importer.cpp
index bf0b944456..aa0a53de30 100644
--- a/src/openrct2/rct1/S4Importer.cpp
+++ b/src/openrct2/rct1/S4Importer.cpp
@@ -1101,9 +1101,12 @@ private:
             if (src.ride_index != RCT12_RIDE_ID_NULL)
             {
                 auto ride = get_ride(src.ride_index);
-                ride->measurement = std::make_unique<RideMeasurement>();
-                ride->measurement->ride = ride;
-                ImportRideMeasurement(*ride->measurement, src);
+                if (ride != nullptr)
+                {
+                    ride->measurement = std::make_unique<RideMeasurement>();
+                    ride->measurement->ride = ride;
+                    ImportRideMeasurement(*ride->measurement, src);
+                }
             }
         }
     }
@@ -1168,7 +1171,10 @@ private:
 
     void ImportVehicle(rct_vehicle* dst, rct1_vehicle* src)
     {
-        Ride* ride = get_ride(src->ride);
+        auto ride = get_ride(src->ride);
+        if (ride == nullptr)
+            return;
+
         uint8_t vehicleEntryIndex = RCT1::GetVehicleSubEntryIndex(src->vehicle_type);
 
         dst->sprite_identifier = SPRITE_IDENTIFIER_VEHICLE;
@@ -2947,24 +2953,27 @@ private:
             }
 
             // Now, swap the entrance and exit.
-            Ride* ride = get_ride(0);
-            auto entranceCoords = ride->stations[0].Exit;
-            auto exitCoords = ride->stations[0].Entrance;
-            ride->stations[0].Entrance = entranceCoords;
-            ride->stations[0].Exit = exitCoords;
+            auto ride = get_ride(0);
+            if (ride != nullptr)
+            {
+                auto entranceCoords = ride->stations[0].Exit;
+                auto exitCoords = ride->stations[0].Entrance;
+                ride->stations[0].Entrance = entranceCoords;
+                ride->stations[0].Exit = exitCoords;
 
-            auto entranceElement = map_get_ride_exit_element_at(
-                entranceCoords.x * 32, entranceCoords.y * 32, entranceCoords.z, false);
-            entranceElement->SetEntranceType(ENTRANCE_TYPE_RIDE_ENTRANCE);
-            auto exitElement = map_get_ride_entrance_element_at(exitCoords.x * 32, exitCoords.y * 32, exitCoords.z, false);
-            exitElement->SetEntranceType(ENTRANCE_TYPE_RIDE_EXIT);
+                auto entranceElement = map_get_ride_exit_element_at(
+                    entranceCoords.x * 32, entranceCoords.y * 32, entranceCoords.z, false);
+                entranceElement->SetEntranceType(ENTRANCE_TYPE_RIDE_ENTRANCE);
+                auto exitElement = map_get_ride_entrance_element_at(exitCoords.x * 32, exitCoords.y * 32, exitCoords.z, false);
+                exitElement->SetEntranceType(ENTRANCE_TYPE_RIDE_EXIT);
 
-            // Trigger footpath update
-            footpath_queue_chain_reset();
-            footpath_connect_edges(
-                entranceCoords.x * 32, (entranceCoords.y) * 32, (TileElement*)entranceElement,
-                GAME_COMMAND_FLAG_APPLY | GAME_COMMAND_FLAG_ALLOW_DURING_PAUSED);
-            footpath_update_queue_chains();
+                // Trigger footpath update
+                footpath_queue_chain_reset();
+                footpath_connect_edges(
+                    entranceCoords.x * 32, (entranceCoords.y) * 32, (TileElement*)entranceElement,
+                    GAME_COMMAND_FLAG_APPLY | GAME_COMMAND_FLAG_ALLOW_DURING_PAUSED);
+                footpath_update_queue_chains();
+            }
         }
     }
 
@@ -3000,8 +3009,11 @@ private:
                         }
 
                         ride_id_t rideIndex = tileElement->AsTrack()->GetRideIndex();
-                        Ride* ride = get_ride(rideIndex);
-                        ride->num_block_brakes++;
+                        auto ride = get_ride(rideIndex);
+                        if (ride != nullptr)
+                        {
+                            ride->num_block_brakes++;
+                        }
                     }
                 } while (!(tileElement++)->IsLastForTile());
             }
diff --git a/src/openrct2/ride/CableLift.cpp b/src/openrct2/ride/CableLift.cpp
index fe82982718..ba96db2d76 100644
--- a/src/openrct2/ride/CableLift.cpp
+++ b/src/openrct2/ride/CableLift.cpp
@@ -27,18 +27,16 @@ static void cable_lift_update_travelling(rct_vehicle* vehicle);
 static void cable_lift_update_arriving(rct_vehicle* vehicle);
 
 rct_vehicle* cable_lift_segment_create(
-    ride_id_t rideIndex, int32_t x, int32_t y, int32_t z, int32_t direction, uint16_t var_44, int32_t remaining_distance,
-    bool head)
+    Ride& ride, int32_t x, int32_t y, int32_t z, int32_t direction, uint16_t var_44, int32_t remaining_distance, bool head)
 {
-    Ride* ride = get_ride(rideIndex);
     rct_vehicle* current = &(create_sprite(SPRITE_IDENTIFIER_VEHICLE)->vehicle);
     current->sprite_identifier = SPRITE_IDENTIFIER_VEHICLE;
-    current->ride = rideIndex;
+    current->ride = ride.id;
     current->ride_subtype = RIDE_ENTRY_INDEX_NULL;
     if (head)
     {
         move_sprite_to_list((rct_sprite*)current, SPRITE_LIST_VEHICLE_HEAD);
-        ride->cable_lift = current->sprite_index;
+        ride.cable_lift = current->sprite_index;
     }
     current->type = head ? VEHICLE_TYPE_HEAD : VEHICLE_TYPE_TAIL;
     current->var_44 = var_44;
@@ -79,7 +77,7 @@ rct_vehicle* cable_lift_segment_create(
 
     z = z * 8;
     current->track_z = z;
-    z += RideData5[ride->type].z_offset;
+    z += RideData5[ride.type].z_offset;
 
     sprite_move(16, 16, z, (rct_sprite*)current);
     current->track_type = (TRACK_ELEM_CABLE_LIFT_HILL << 2) | (current->sprite_direction >> 3);
diff --git a/src/openrct2/ride/CableLift.h b/src/openrct2/ride/CableLift.h
index e72df21799..2a868fa674 100644
--- a/src/openrct2/ride/CableLift.h
+++ b/src/openrct2/ride/CableLift.h
@@ -14,8 +14,7 @@
 #include "Vehicle.h"
 
 rct_vehicle* cable_lift_segment_create(
-    ride_id_t rideIndex, int32_t x, int32_t y, int32_t z, int32_t direction, uint16_t var_44, int32_t remaining_distance,
-    bool head);
+    Ride& ride, int32_t x, int32_t y, int32_t z, int32_t direction, uint16_t var_44, int32_t remaining_distance, bool head);
 void cable_lift_update(rct_vehicle* vehicle);
 int32_t cable_lift_update_track_motion(rct_vehicle* cableLift);
 
diff --git a/src/openrct2/ride/Ride.cpp b/src/openrct2/ride/Ride.cpp
index 428c9c15ba..6fea408d8d 100644
--- a/src/openrct2/ride/Ride.cpp
+++ b/src/openrct2/ride/Ride.cpp
@@ -759,13 +759,8 @@ bool track_block_get_previous(int32_t x, int32_t y, TileElement* tileElement, tr
  */
 int32_t ride_find_track_gap(const Ride* ride, CoordsXYE* input, CoordsXYE* output)
 {
-    if (ride == nullptr)
-    {
-        log_error("Trying to access invalid ride %d", ride->id);
-        return 0;
-    }
-
-    if (input == nullptr || input->element == nullptr || input->element->GetType() != TILE_ELEMENT_TYPE_TRACK)
+    if (ride == nullptr || input == nullptr || input->element == nullptr
+        || input->element->GetType() != TILE_ELEMENT_TYPE_TRACK)
         return 0;
 
     if (ride->type == RIDE_TYPE_MAZE)
@@ -1299,20 +1294,16 @@ void ride_restore_provisional_track_piece()
 
 void ride_remove_provisional_track_piece()
 {
-    if (!(_currentTrackSelectionFlags & TRACK_SELECTION_FLAG_TRACK))
+    auto rideIndex = _currentRideIndex;
+    auto ride = get_ride(rideIndex);
+    if (ride == nullptr || !(_currentTrackSelectionFlags & TRACK_SELECTION_FLAG_TRACK))
     {
         return;
     }
-    Ride* ride;
-    int32_t x, y, z, direction;
 
-    ride_id_t rideIndex = _currentRideIndex;
-
-    x = _unkF440C5.x;
-    y = _unkF440C5.y;
-    z = _unkF440C5.z;
-
-    ride = get_ride(rideIndex);
+    int32_t x = _unkF440C5.x;
+    int32_t y = _unkF440C5.y;
+    int32_t z = _unkF440C5.z;
     if (ride->type == RIDE_TYPE_MAZE)
     {
         int32_t flags = GAME_COMMAND_FLAG_APPLY | GAME_COMMAND_FLAG_ALLOW_DURING_PAUSED | GAME_COMMAND_FLAG_NO_SPEND
@@ -1324,7 +1315,7 @@ void ride_remove_provisional_track_piece()
     }
     else
     {
-        direction = _unkF440C5.direction;
+        int32_t direction = _unkF440C5.direction;
         if (!(direction & 4))
         {
             x -= CoordsDirectionDelta[direction].x;
@@ -1405,9 +1396,10 @@ void ride_construction_invalidate_current_track()
  */
 static void ride_construction_reset_current_piece()
 {
-    Ride* ride;
+    auto ride = get_ride(_currentRideIndex);
+    if (ride == nullptr)
+        return;
 
-    ride = get_ride(_currentRideIndex);
     if (!ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_HAS_NO_TRACK) || ride->num_stations == 0)
     {
         _currentTrackCurve = RideConstructionDefaultTrackType[ride->type] | 0x100;
@@ -1435,20 +1427,19 @@ static void ride_construction_reset_current_piece()
  */
 void ride_construction_set_default_next_piece()
 {
-    ride_id_t rideIndex;
+    auto rideIndex = _currentRideIndex;
+    auto ride = get_ride(rideIndex);
+    if (ride == nullptr)
+        return;
+
     int32_t x, y, z, direction, trackType, curve, bank, slope;
-    Ride* ride;
     track_begin_end trackBeginEnd;
     CoordsXYE xyElement;
     TileElement* tileElement;
-
     _currentTrackPrice = MONEY32_UNDEFINED;
     switch (_rideConstructionState)
     {
         case RIDE_CONSTRUCTION_STATE_FRONT:
-            rideIndex = _currentRideIndex;
-            ride = get_ride(rideIndex);
-
             x = _currentTrackBegin.x;
             y = _currentTrackBegin.y;
             z = _currentTrackBegin.z;
@@ -1519,9 +1510,6 @@ void ride_construction_set_default_next_piece()
                 && slope != TRACK_SLOPE_DOWN_60;
             break;
         case RIDE_CONSTRUCTION_STATE_BACK:
-            rideIndex = _currentRideIndex;
-            ride = get_ride(rideIndex);
-
             x = _currentTrackBegin.x;
             y = _currentTrackBegin.y;
             z = _currentTrackBegin.z;
@@ -1970,6 +1958,8 @@ int32_t ride_initialise_construction_window(Ride* ride)
     input_set_flag(INPUT_FLAG_6, true);
 
     ride = get_ride(_currentRideIndex);
+    if (ride == nullptr)
+        return 0;
 
     _currentTrackCurve = RideConstructionDefaultTrackType[ride->type] | 0x100;
     _currentTrackSlopeEnd = 0;
@@ -3909,7 +3899,9 @@ static int32_t ride_mode_check_station_present(Ride* ride)
  */
 static int32_t ride_check_for_entrance_exit(ride_id_t rideIndex)
 {
-    Ride* ride = get_ride(rideIndex);
+    auto ride = get_ride(rideIndex);
+    if (ride == nullptr)
+        return 0;
 
     if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_IS_SHOP))
         return 1;
@@ -4054,8 +4046,8 @@ static int32_t ride_check_block_brakes(CoordsXYE* input, CoordsXYE* output)
 static bool ride_check_track_contains_inversions(CoordsXYE* input, CoordsXYE* output)
 {
     ride_id_t rideIndex = input->element->AsTrack()->GetRideIndex();
-    Ride* ride = get_ride(rideIndex);
-    if (ride->type == RIDE_TYPE_MAZE)
+    auto ride = get_ride(rideIndex);
+    if (ride != nullptr && ride->type == RIDE_TYPE_MAZE)
         return true;
 
     rct_window* w = window_find_by_class(WC_RIDE_CONSTRUCTION);
@@ -4101,8 +4093,11 @@ static bool ride_check_track_contains_inversions(CoordsXYE* input, CoordsXYE* ou
  */
 static bool ride_check_track_contains_banked(CoordsXYE* input, CoordsXYE* output)
 {
-    ride_id_t rideIndex = input->element->AsTrack()->GetRideIndex();
-    Ride* ride = get_ride(rideIndex);
+    auto rideIndex = input->element->AsTrack()->GetRideIndex();
+    auto ride = get_ride(rideIndex);
+    if (ride == nullptr)
+        return false;
+
     if (ride->type == RIDE_TYPE_MAZE)
         return true;
 
@@ -4205,6 +4200,8 @@ static bool ride_check_start_and_end_is_station(CoordsXYE* input)
 
     ride_id_t rideIndex = input->element->AsTrack()->GetRideIndex();
     auto ride = get_ride(rideIndex);
+    if (ride == nullptr)
+        return false;
 
     auto w = window_find_by_class(WC_RIDE_CONSTRUCTION);
     if (w != nullptr && _rideConstructionState != RIDE_CONSTRUCTION_STATE_0 && rideIndex == _currentRideIndex)
@@ -4359,7 +4356,9 @@ static void ride_set_block_points(CoordsXYE* startElement)
  */
 static void ride_set_start_finish_points(ride_id_t rideIndex, CoordsXYE* startElement)
 {
-    Ride* ride = get_ride(rideIndex);
+    auto ride = get_ride(rideIndex);
+    if (ride == nullptr)
+        return;
 
     switch (ride->type)
     {
@@ -4610,33 +4609,38 @@ static train_ref vehicle_create_train(
     ride_id_t rideIndex, int32_t x, int32_t y, int32_t z, int32_t vehicleIndex, int32_t* remainingDistance,
     TileElement* tileElement)
 {
-    Ride* ride = get_ride(rideIndex);
-
     train_ref train = { nullptr, nullptr };
-    for (int32_t carIndex = 0; carIndex < ride->num_cars_per_train; carIndex++)
+    auto ride = get_ride(rideIndex);
+    if (ride != nullptr)
     {
-        const uint8_t vehicle = ride_entry_get_vehicle_at_position(ride->subtype, ride->num_cars_per_train, carIndex);
-        rct_vehicle* car = vehicle_create_car(
-            rideIndex, vehicle, carIndex, vehicleIndex, x, y, z, remainingDistance, tileElement);
-        if (carIndex == 0)
+        for (int32_t carIndex = 0; carIndex < ride->num_cars_per_train; carIndex++)
         {
-            train.head = car;
+            const uint8_t vehicle = ride_entry_get_vehicle_at_position(ride->subtype, ride->num_cars_per_train, carIndex);
+            rct_vehicle* car = vehicle_create_car(
+                rideIndex, vehicle, carIndex, vehicleIndex, x, y, z, remainingDistance, tileElement);
+            if (carIndex == 0)
+            {
+                train.head = car;
+            }
+            else
+            {
+                // Link the previous car with this car
+                train.tail->next_vehicle_on_train = car->sprite_index;
+                train.tail->next_vehicle_on_ride = car->sprite_index;
+                car->prev_vehicle_on_ride = train.tail->sprite_index;
+            }
+            train.tail = car;
         }
-        else
-        {
-            // Link the previous car with this car
-            train.tail->next_vehicle_on_train = car->sprite_index;
-            train.tail->next_vehicle_on_ride = car->sprite_index;
-            car->prev_vehicle_on_ride = train.tail->sprite_index;
-        }
-        train.tail = car;
     }
     return train;
 }
 
 static void vehicle_create_trains(ride_id_t rideIndex, int32_t x, int32_t y, int32_t z, TileElement* tileElement)
 {
-    Ride* ride = get_ride(rideIndex);
+    auto ride = get_ride(rideIndex);
+    if (ride == nullptr)
+        return;
+
     train_ref firstTrain = {};
     train_ref lastTrain = {};
     int32_t remainingDistance = 0;
@@ -5028,7 +5032,9 @@ static bool ride_initialise_cable_lift_track(Ride* ride, bool isApplying)
  */
 static bool ride_create_cable_lift(ride_id_t rideIndex, bool isApplying)
 {
-    Ride* ride = get_ride(rideIndex);
+    auto ride = get_ride(rideIndex);
+    if (ride == nullptr)
+        return false;
 
     if (ride->mode != RIDE_MODE_CONTINUOUS_CIRCUIT_BLOCK_SECTIONED && ride->mode != RIDE_MODE_CONTINUOUS_CIRCUIT)
     {
@@ -5076,7 +5082,7 @@ static bool ride_create_cable_lift(ride_id_t rideIndex, bool isApplying)
         int32_t remaining_distance = ebx;
         ebx -= edx;
 
-        rct_vehicle* current = cable_lift_segment_create(rideIndex, x, y, z, direction, var_44, remaining_distance, i == 0);
+        rct_vehicle* current = cable_lift_segment_create(*ride, x, y, z, direction, var_44, remaining_distance, i == 0);
         current->next_vehicle_on_train = SPRITE_INDEX_NULL;
         if (i == 0)
         {
@@ -5173,7 +5179,10 @@ static void ride_scroll_to_track_error(CoordsXYE* trackElement)
  */
 static TileElement* loc_6B4F6B(ride_id_t rideIndex, int32_t x, int32_t y)
 {
-    Ride* ride = get_ride(rideIndex);
+    auto ride = get_ride(rideIndex);
+    if (ride == nullptr)
+        return nullptr;
+
     TileElement* tileElement = map_get_first_element_at(x / 32, y / 32);
     do
     {
@@ -6196,6 +6205,9 @@ void ride_get_entrance_or_exit_position_from_screen_position(
     }
 
     ride = get_ride(gRideEntranceExitPlaceRideIndex);
+    if (ride == nullptr)
+        return;
+
     stationHeight = ride->stations[gRideEntranceExitPlaceStationIndex].Height;
 
     screen_get_map_xy_with_z(screenX, screenY, stationHeight * 8, &mapX, &mapY);
@@ -7311,9 +7323,9 @@ static bool check_for_adjacent_station(int32_t x, int32_t y, int32_t z, uint8_t
         TileElement* stationElement = get_station_platform(adjX, adjY, z, 2);
         if (stationElement != nullptr)
         {
-            ride_id_t rideIndex = stationElement->AsTrack()->GetRideIndex();
-            Ride* ride = get_ride(rideIndex);
-            if (ride->depart_flags & RIDE_DEPART_SYNCHRONISE_WITH_ADJACENT_STATIONS)
+            auto rideIndex = stationElement->AsTrack()->GetRideIndex();
+            auto ride = get_ride(rideIndex);
+            if (ride != nullptr && (ride->depart_flags & RIDE_DEPART_SYNCHRONISE_WITH_ADJACENT_STATIONS))
             {
                 found = true;
             }
diff --git a/src/openrct2/ride/Track.cpp b/src/openrct2/ride/Track.cpp
index 6a9920433a..f8bb671c56 100644
--- a/src/openrct2/ride/Track.cpp
+++ b/src/openrct2/ride/Track.cpp
@@ -636,13 +636,16 @@ static void ride_remove_station(Ride* ride, int32_t x, int32_t y, int32_t z)
  */
 bool track_add_station_element(int32_t x, int32_t y, int32_t z, int32_t direction, ride_id_t rideIndex, int32_t flags)
 {
+    auto ride = get_ride(rideIndex);
+    if (ride == nullptr)
+        return false;
+
     int32_t stationX0 = x;
     int32_t stationY0 = y;
     int32_t stationX1 = x;
     int32_t stationY1 = y;
     int32_t stationLength = 1;
 
-    Ride* ride = get_ride(rideIndex);
     if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_3))
     {
         if (ride->num_stations >= MAX_STATIONS)
@@ -787,6 +790,10 @@ bool track_add_station_element(int32_t x, int32_t y, int32_t z, int32_t directio
  */
 bool track_remove_station_element(int32_t x, int32_t y, int32_t z, int32_t direction, ride_id_t rideIndex, int32_t flags)
 {
+    auto ride = get_ride(rideIndex);
+    if (ride == nullptr)
+        return false;
+
     int32_t removeX = x;
     int32_t removeY = y;
     int32_t stationX0 = x;
@@ -796,7 +803,6 @@ bool track_remove_station_element(int32_t x, int32_t y, int32_t z, int32_t direc
     int32_t stationLength = 0;
     int32_t byte_F441D1 = -1;
 
-    Ride* ride = get_ride(rideIndex);
     if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_3))
     {
         TileElement* tileElement = map_get_track_element_at_with_direction_from_ride(x, y, z, direction, rideIndex);
@@ -1111,9 +1117,13 @@ bool track_element_is_block_start(TileElement* trackElement)
 
 int32_t track_get_actual_bank(TileElement* tileElement, int32_t bank)
 {
-    Ride* ride = get_ride(tileElement->AsTrack()->GetRideIndex());
-    bool isInverted = tileElement->AsTrack()->IsInverted();
-    return track_get_actual_bank_2(ride->type, isInverted, bank);
+    auto ride = get_ride(tileElement->AsTrack()->GetRideIndex());
+    if (ride != nullptr)
+    {
+        bool isInverted = tileElement->AsTrack()->IsInverted();
+        return track_get_actual_bank_2(ride->type, isInverted, bank);
+    }
+    return bank;
 }
 
 int32_t track_get_actual_bank_2(int32_t rideType, bool isInverted, int32_t bank)
diff --git a/src/openrct2/ride/TrackDesign.cpp b/src/openrct2/ride/TrackDesign.cpp
index 05063939f9..d7832fe44a 100644
--- a/src/openrct2/ride/TrackDesign.cpp
+++ b/src/openrct2/ride/TrackDesign.cpp
@@ -1721,6 +1721,9 @@ static bool track_design_place_preview(rct_track_td6* td6, money32* cost, Ride**
     }
 
     auto ride = get_ride(rideIndex);
+    if (ride == nullptr)
+        return false;
+
     ride->custom_name = {};
     ride->entrance_style = td6->entrance_style;
 
@@ -1872,7 +1875,7 @@ static money32 place_track_design(int16_t x, int16_t y, int16_t z, uint8_t flags
     auto ride = get_ride(rideIndex);
     if (ride == nullptr)
     {
-        log_warning("Invalid game command for track placement, ride id = %d", ride->id);
+        log_warning("Invalid game command for track placement, ride id = %d", rideIndex);
         return MONEY32_UNDEFINED;
     }
 
diff --git a/src/openrct2/ride/TrackDesignSave.cpp b/src/openrct2/ride/TrackDesignSave.cpp
index d7c5dd9d65..909f5e245e 100644
--- a/src/openrct2/ride/TrackDesignSave.cpp
+++ b/src/openrct2/ride/TrackDesignSave.cpp
@@ -150,9 +150,8 @@ static void track_design_save_callback(int32_t result, [[maybe_unused]] const ut
  */
 bool track_design_save(ride_id_t rideIndex)
 {
-    Ride* ride = get_ride(rideIndex);
-
-    if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
+    auto ride = get_ride(rideIndex);
+    if (ride == nullptr || !(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
     {
         context_show_error(STR_CANT_SAVE_TRACK_DESIGN, gGameCommandErrorText);
         return false;
@@ -753,8 +752,14 @@ static bool track_design_save_copy_scenery_to_td6(rct_track_td6* td6)
  */
 static rct_track_td6* track_design_save_to_td6(ride_id_t rideIndex)
 {
-    rct_track_td6* td6 = (rct_track_td6*)calloc(1, sizeof(rct_track_td6));
-    Ride* ride = get_ride(rideIndex);
+    auto ride = get_ride(rideIndex);
+    if (ride == nullptr)
+        return nullptr;
+
+    auto td6 = (rct_track_td6*)calloc(1, sizeof(rct_track_td6));
+    if (td6 == nullptr)
+        return nullptr;
+
     td6->type = ride->type;
     auto object = object_entry_get_entry(OBJECT_TYPE_RIDE, ride->subtype);
 
diff --git a/src/openrct2/ride/Vehicle.cpp b/src/openrct2/ride/Vehicle.cpp
index 858ce44a45..34fe6ade9f 100644
--- a/src/openrct2/ride/Vehicle.cpp
+++ b/src/openrct2/ride/Vehicle.cpp
@@ -1355,7 +1355,10 @@ void vehicle_update_all()
  */
 static bool vehicle_close_restraints(rct_vehicle* vehicle)
 {
-    Ride* ride = get_ride(vehicle->ride);
+    auto ride = get_ride(vehicle->ride);
+    if (ride == nullptr)
+        return true;
+
     bool restraintsClosed = true;
     uint16_t vehicle_id = vehicle->sprite_index;
 
@@ -1416,8 +1419,11 @@ static bool vehicle_open_restraints(rct_vehicle* vehicle)
         vehicle->var_4E = 0;
         vehicle->swing_sprite = 0;
 
-        Ride* ride = get_ride(vehicle->ride);
-        rct_ride_entry* rideEntry = get_ride_entry(vehicle->ride_subtype);
+        auto ride = get_ride(vehicle->ride);
+        if (ride == nullptr)
+            continue;
+
+        auto rideEntry = get_ride_entry(vehicle->ride_subtype);
         if (rideEntry == nullptr)
         {
             continue;
@@ -2040,7 +2046,10 @@ static void vehicle_update(rct_vehicle* vehicle)
  */
 static void vehicle_update_moving_to_end_of_station(rct_vehicle* vehicle)
 {
-    Ride* ride = get_ride(vehicle->ride);
+    auto ride = get_ride(vehicle->ride);
+    if (ride == nullptr)
+        return;
+
     int32_t flags, station;
 
     switch (ride->mode)
@@ -2150,7 +2159,9 @@ static void train_ready_to_depart(rct_vehicle* vehicle, uint8_t num_peeps_on_tra
     if (num_peeps_on_train != num_used_seats)
         return;
 
-    Ride* ride = get_ride(vehicle->ride);
+    auto ride = get_ride(vehicle->ride);
+    if (ride == nullptr)
+        return;
 
     if (ride->status == RIDE_STATUS_OPEN && !(ride->lifecycle_flags & RIDE_LIFECYCLE_BROKEN_DOWN)
         && !(vehicle->update_flags & VEHICLE_UPDATE_FLAG_TRAIN_READY_DEPART))
@@ -2429,7 +2440,10 @@ static void vehicle_update_waiting_for_passengers(rct_vehicle* vehicle)
  */
 static void vehicle_update_dodgems_mode(rct_vehicle* vehicle)
 {
-    Ride* ride = get_ride(vehicle->ride);
+    auto ride = get_ride(vehicle->ride);
+    if (ride == nullptr)
+        return;
+
     rct_ride_entry* rideEntry = get_ride_entry(vehicle->ride_subtype);
     if (rideEntry == nullptr)
     {
@@ -2715,9 +2729,9 @@ static bool try_add_synchronised_station(int32_t x, int32_t y, int32_t z)
         return false;
     }
 
-    ride_id_t rideIndex = tileElement->AsTrack()->GetRideIndex();
-    Ride* ride = get_ride(rideIndex);
-    if (!(ride->depart_flags & RIDE_DEPART_SYNCHRONISE_WITH_ADJACENT_STATIONS))
+    auto rideIndex = tileElement->AsTrack()->GetRideIndex();
+    auto ride = get_ride(rideIndex);
+    if (ride == nullptr || !(ride->depart_flags & RIDE_DEPART_SYNCHRONISE_WITH_ADJACENT_STATIONS))
     {
         /* Ride is not set to synchronise with adjacent stations. */
         return false;
@@ -2800,7 +2814,10 @@ static bool try_add_synchronised_station(int32_t x, int32_t y, int32_t z)
  */
 static bool vehicle_can_depart_synchronised(rct_vehicle* vehicle)
 {
-    Ride* ride = get_ride(vehicle->ride);
+    auto ride = get_ride(vehicle->ride);
+    if (ride == nullptr)
+        return false;
+
     int32_t station = vehicle->current_station;
     LocationXY8 location = ride->stations[station].Start;
     int32_t x = location.x * 32;
@@ -3018,7 +3035,10 @@ void vehicle_peep_easteregg_here_we_are(const rct_vehicle* vehicle)
  */
 void vehicle_update_test_finish(rct_vehicle* vehicle)
 {
-    Ride* ride = get_ride(vehicle->ride);
+    auto ride = get_ride(vehicle->ride);
+    if (ride == nullptr)
+        return;
+
     ride->lifecycle_flags &= ~RIDE_LIFECYCLE_TEST_IN_PROGRESS;
     vehicle->update_flags &= ~VEHICLE_UPDATE_FLAG_TESTING;
     ride->lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
@@ -3057,7 +3077,10 @@ void vehicle_test_reset(rct_vehicle* vehicle)
 {
     vehicle->update_flags |= VEHICLE_UPDATE_FLAG_TESTING;
 
-    Ride* ride = get_ride(vehicle->ride);
+    auto ride = get_ride(vehicle->ride);
+    if (ride == nullptr)
+        return;
+
     ride->lifecycle_flags |= RIDE_LIFECYCLE_TEST_IN_PROGRESS;
     ride->lifecycle_flags &= ~RIDE_LIFECYCLE_NO_RAW_STATS;
     ride->max_speed = 0;
@@ -3146,7 +3169,10 @@ static void vehicle_update_travelling_boat_hire_setup(rct_vehicle* vehicle)
 static void vehicle_update_departing_boat_hire(rct_vehicle* vehicle)
 {
     vehicle->lost_time_out = 0;
-    Ride* ride = get_ride(vehicle->ride);
+
+    auto ride = get_ride(vehicle->ride);
+    if (ride == nullptr)
+        return;
 
     ride->stations[vehicle->current_station].Depart &= STATION_DEPART_FLAG;
     uint8_t waitingTime = std::max(ride->min_waiting_time, static_cast<uint8_t>(3));
@@ -3397,7 +3423,9 @@ static void vehicle_update_departing(rct_vehicle* vehicle)
  */
 static void vehicle_finish_departing(rct_vehicle* vehicle)
 {
-    Ride* ride = get_ride(vehicle->ride);
+    auto ride = get_ride(vehicle->ride);
+    if (ride == nullptr)
+        return;
 
     if (ride->mode == RIDE_MODE_DOWNWARD_LAUNCH)
     {
@@ -3440,7 +3468,9 @@ static void vehicle_finish_departing(rct_vehicle* vehicle)
  */
 static void vehicle_check_if_missing(rct_vehicle* vehicle)
 {
-    Ride* ride = get_ride(vehicle->ride);
+    auto ride = get_ride(vehicle->ride);
+    if (ride == nullptr)
+        return;
 
     if (ride->lifecycle_flags & (RIDE_LIFECYCLE_BROKEN_DOWN | RIDE_LIFECYCLE_CRASHED))
         return;
@@ -3495,7 +3525,10 @@ static void vehicle_simulate_crash(rct_vehicle* vehicle)
 static void vehicle_update_collision_setup(rct_vehicle* vehicle)
 {
     auto ride = get_ride(vehicle->ride);
-    if (ride != nullptr && ride->status == RIDE_STATUS_SIMULATING)
+    if (ride == nullptr)
+        return;
+
+    if (ride->status == RIDE_STATUS_SIMULATING)
     {
         vehicle_simulate_crash(vehicle);
         return;
@@ -4031,7 +4064,10 @@ static void vehicle_update_unloading_passengers(rct_vehicle* vehicle)
         }
     }
 
-    Ride* ride = get_ride(vehicle->ride);
+    auto ride = get_ride(vehicle->ride);
+    if (ride == nullptr)
+        return;
+
     if (ride->mode == RIDE_MODE_FORWARD_ROTATION || ride->mode == RIDE_MODE_BACKWARD_ROTATION)
     {
         uint8_t seat = ((-vehicle->vehicle_sprite_type) >> 3) & 0xF;
@@ -4113,7 +4149,9 @@ static void vehicle_update_unloading_passengers(rct_vehicle* vehicle)
  */
 static void vehicle_update_waiting_for_cable_lift(rct_vehicle* vehicle)
 {
-    Ride* ride = get_ride(vehicle->ride);
+    auto ride = get_ride(vehicle->ride);
+    if (ride == nullptr)
+        return;
 
     rct_vehicle* cableLift = GET_VEHICLE(ride->cable_lift);
 
@@ -4130,7 +4168,9 @@ static void vehicle_update_waiting_for_cable_lift(rct_vehicle* vehicle)
  */
 static void vehicle_update_travelling_cable_lift(rct_vehicle* vehicle)
 {
-    Ride* ride = get_ride(vehicle->ride);
+    auto ride = get_ride(vehicle->ride);
+    if (ride == nullptr)
+        return;
 
     if (vehicle->sub_state == 0)
     {
@@ -4230,8 +4270,11 @@ static void loc_6DA9F9(rct_vehicle* vehicle, int32_t x, int32_t y, int32_t bx, i
 
         auto trackElement = map_get_track_element_at(vehicle->track_x, vehicle->track_y, vehicle->track_z >> 3);
 
-        Ride* ride = get_ride(vehicle->ride);
-        vehicle->track_type = (trackElement->GetTrackType() << 2) | (ride->boat_hire_return_direction & 3);
+        auto ride = get_ride(vehicle->ride);
+        if (ride != nullptr)
+        {
+            vehicle->track_type = (trackElement->GetTrackType() << 2) | (ride->boat_hire_return_direction & 3);
+        }
 
         vehicle->track_progress = 0;
         vehicle->SetState(VEHICLE_STATUS_TRAVELLING, vehicle->sub_state);
@@ -4403,7 +4446,9 @@ static void vehicle_update_motion_boat_hire(rct_vehicle* vehicle)
                 if (!vehicle_boat_is_location_accessible(TileCoordsXYZ(CoordsXYZ{ x, y, vehicle->track_z })))
                 {
                     // loc_6DA939:
-                    Ride* ride = get_ride(vehicle->ride);
+                    auto ride = get_ride(vehicle->ride);
+                    if (ride == nullptr)
+                        return;
 
                     bool do_loc_6DAA97 = false;
                     if (vehicle->sub_state != 1)
@@ -4536,7 +4581,10 @@ static void vehicle_update_motion_boat_hire(rct_vehicle* vehicle)
  */
 static void vehicle_update_boat_location(rct_vehicle* vehicle)
 {
-    Ride* ride = get_ride(vehicle->ride);
+    auto ride = get_ride(vehicle->ride);
+    if (ride == nullptr)
+        return;
+
     LocationXY8 returnPosition = ride->boat_hire_return_position;
     uint8_t returnDirection = ride->boat_hire_return_direction & 3;
 
@@ -4642,8 +4690,13 @@ static bool vehicle_boat_is_location_accessible(const TileCoordsXYZ& location)
  */
 static void vehicle_update_swinging(rct_vehicle* vehicle)
 {
-    Ride* ride = get_ride(vehicle->ride);
-    rct_ride_entry* rideEntry = get_ride_entry(vehicle->ride_subtype);
+    auto ride = get_ride(vehicle->ride);
+    if (ride == nullptr)
+        return;
+
+    auto rideEntry = get_ride_entry(vehicle->ride_subtype);
+    if (rideEntry == nullptr)
+        return;
 
     // SubState for this ride means swinging state
     // 0 == first swing
@@ -4714,7 +4767,10 @@ static void vehicle_update_ferris_wheel_rotating(rct_vehicle* vehicle)
     if (_vehicleBreakdown == 0)
         return;
 
-    Ride* ride = get_ride(vehicle->ride);
+    auto ride = get_ride(vehicle->ride);
+    if (ride == nullptr)
+        return;
+
     if ((vehicle->ferris_wheel_var_1 -= 1) != 0)
         return;
 
@@ -4829,8 +4885,11 @@ static void vehicle_update_rotating(rct_vehicle* vehicle)
     if (_vehicleBreakdown == 0)
         return;
 
-    Ride* ride = get_ride(vehicle->ride);
-    rct_ride_entry* rideEntry = get_ride_entry(vehicle->ride_subtype);
+    auto ride = get_ride(vehicle->ride);
+    if (ride == nullptr)
+        return;
+
+    auto rideEntry = get_ride_entry(vehicle->ride_subtype);
     if (rideEntry == nullptr)
     {
         return;
@@ -5133,8 +5192,11 @@ static TileElement* vehicle_check_collision(int16_t x, int16_t y, int16_t z)
  */
 static void vehicle_kill_all_passengers(rct_vehicle* vehicle)
 {
-    uint16_t numFatalities = 0;
+    auto ride = get_ride(vehicle->ride);
+    if (ride == nullptr)
+        return;
 
+    uint16_t numFatalities = 0;
     uint16_t spriteId = vehicle->sprite_index;
     for (rct_vehicle* curVehicle; spriteId != SPRITE_INDEX_NULL; spriteId = curVehicle->next_vehicle_on_train)
     {
@@ -5142,7 +5204,6 @@ static void vehicle_kill_all_passengers(rct_vehicle* vehicle)
         numFatalities += curVehicle->num_peeps;
     }
 
-    Ride* ride = get_ride(vehicle->ride);
     set_format_arg(0, uint16_t, numFatalities);
 
     uint8_t crashType = numFatalities == 0 ? RIDE_CRASH_TYPE_NO_FATALITIES : RIDE_CRASH_TYPE_FATALITIES;
@@ -5193,7 +5254,10 @@ static void vehicle_kill_all_passengers(rct_vehicle* vehicle)
 static void vehicle_crash_on_land(rct_vehicle* vehicle)
 {
     auto ride = get_ride(vehicle->ride);
-    if (ride != nullptr && ride->status == RIDE_STATUS_SIMULATING)
+    if (ride == nullptr)
+        return;
+
+    if (ride->status == RIDE_STATUS_SIMULATING)
     {
         vehicle_simulate_crash(vehicle);
         return;
@@ -5251,7 +5315,10 @@ static void vehicle_crash_on_land(rct_vehicle* vehicle)
 static void vehicle_crash_on_water(rct_vehicle* vehicle)
 {
     auto ride = get_ride(vehicle->ride);
-    if (ride != nullptr && ride->status == RIDE_STATUS_SIMULATING)
+    if (ride == nullptr)
+        return;
+
+    if (ride->status == RIDE_STATUS_SIMULATING)
     {
         vehicle_simulate_crash(vehicle);
         return;
@@ -5404,8 +5471,6 @@ static void vehicle_update_crash(rct_vehicle* vehicle)
  */
 static void vehicle_update_sound(rct_vehicle* vehicle)
 {
-    Ride* ride;
-    rct_ride_entry* rideEntry;
     // frictionVolume (bl) should be set before hand
     uint8_t frictionVolume = 255;
     SoundId frictionId = SoundId::Null;
@@ -5413,13 +5478,13 @@ static void vehicle_update_sound(rct_vehicle* vehicle)
     SoundId screamId = SoundId::Null;
     uint8_t screamVolume = 255;
 
-    ride = get_ride(vehicle->ride);
-    rideEntry = get_ride_entry(vehicle->ride_subtype);
-
-    if (rideEntry == nullptr)
-    {
+    auto ride = get_ride(vehicle->ride);
+    if (ride == nullptr)
+        return;
+
+    auto rideEntry = get_ride_entry(vehicle->ride_subtype);
+    if (rideEntry == nullptr)
         return;
-    }
 
     rct_ride_entry_vehicle* vehicleEntry = &rideEntry->vehicles[vehicle->vehicle_type];
 
@@ -6560,13 +6625,13 @@ static void apply_block_brakes(rct_vehicle* vehicle, bool is_block_brake_closed)
  */
 static void check_and_apply_block_section_stop_site(rct_vehicle* vehicle)
 {
-    Ride* ride = get_ride(vehicle->ride);
-    rct_ride_entry_vehicle* vehicleEntry = vehicle_get_vehicle_entry(vehicle);
-
-    if (vehicleEntry == nullptr)
-    {
+    auto ride = get_ride(vehicle->ride);
+    if (ride == nullptr)
+        return;
+
+    auto vehicleEntry = vehicle_get_vehicle_entry(vehicle);
+    if (vehicleEntry == nullptr)
         return;
-    }
 
     // Is chair lift type
     if (vehicleEntry->flags & VEHICLE_ENTRY_FLAG_CHAIRLIFT)
@@ -6711,8 +6776,8 @@ static void vehicle_update_block_brakes_open_previous_section(rct_vehicle* vehic
     int32_t trackType = trackElement->GetTrackType();
     if (trackType == TRACK_ELEM_BLOCK_BRAKES || trackType == TRACK_ELEM_END_STATION)
     {
-        Ride* ride = get_ride(vehicle->ride);
-        if (ride->IsBlockSectioned())
+        auto ride = get_ride(vehicle->ride);
+        if (ride != nullptr && ride->IsBlockSectioned())
         {
             audio_play_sound_at_location(SoundId::BlockBrakeClose, x, y, z);
         }
@@ -8046,10 +8111,14 @@ loc_6DB41D:
         vehicle_trigger_on_ride_photo(vehicle, tileElement);
     }
     {
-        uint16_t rideType = get_ride(tileElement->AsTrack()->GetRideIndex())->type;
-        if (trackType == TRACK_ELEM_ROTATION_CONTROL_TOGGLE && rideType == RIDE_TYPE_STEEL_WILD_MOUSE)
+        ride = get_ride(tileElement->AsTrack()->GetRideIndex());
+        if (ride != nullptr)
         {
-            vehicle->update_flags ^= VEHICLE_UPDATE_FLAG_ROTATION_OFF_WILD_MOUSE;
+            uint16_t rideType = ride->type;
+            if (trackType == TRACK_ELEM_ROTATION_CONTROL_TOGGLE && rideType == RIDE_TYPE_STEEL_WILD_MOUSE)
+            {
+                vehicle->update_flags ^= VEHICLE_UPDATE_FLAG_ROTATION_OFF_WILD_MOUSE;
+            }
         }
     }
     // Change from original: this used to check if the vehicle allowed doors.
diff --git a/src/openrct2/ride/gentle/CircusShow.cpp b/src/openrct2/ride/gentle/CircusShow.cpp
index 88896968ce..59c70454d7 100644
--- a/src/openrct2/ride/gentle/CircusShow.cpp
+++ b/src/openrct2/ride/gentle/CircusShow.cpp
@@ -22,8 +22,13 @@ static void paint_circus_show_tent(
 {
     const TileElement* savedTileElement = static_cast<const TileElement*>(session->CurrentlyDrawnItem);
 
-    Ride* ride = get_ride(rideIndex);
-    rct_ride_entry* rideEntry = get_ride_entry(ride->subtype);
+    auto ride = get_ride(rideIndex);
+    if (ride == nullptr)
+        return;
+
+    auto rideEntry = ride->GetRideEntry();
+    if (rideEntry == nullptr)
+        return;
 
     if (ride->lifecycle_flags & RIDE_LIFECYCLE_ON_TRACK && ride->vehicles[0] != SPRITE_INDEX_NULL)
     {
diff --git a/src/openrct2/ride/gentle/CrookedHouse.cpp b/src/openrct2/ride/gentle/CrookedHouse.cpp
index c1b468a662..f89b283619 100644
--- a/src/openrct2/ride/gentle/CrookedHouse.cpp
+++ b/src/openrct2/ride/gentle/CrookedHouse.cpp
@@ -36,9 +36,13 @@ static void paint_crooked_house_structure(
 {
     const TileElement* original_tile_element = static_cast<const TileElement*>(session->CurrentlyDrawnItem);
 
-    Ride* ride = get_ride(original_tile_element->AsTrack()->GetRideIndex());
+    auto ride = get_ride(original_tile_element->AsTrack()->GetRideIndex());
+    if (ride == nullptr)
+        return;
 
-    rct_ride_entry* rideEntry = get_ride_entry(ride->subtype);
+    auto rideEntry = ride->GetRideEntry();
+    if (rideEntry == nullptr)
+        return;
 
     if (ride->lifecycle_flags & RIDE_LIFECYCLE_ON_TRACK)
     {
diff --git a/src/openrct2/ride/gentle/FerrisWheel.cpp b/src/openrct2/ride/gentle/FerrisWheel.cpp
index 193fe84ccc..a6ec174c69 100644
--- a/src/openrct2/ride/gentle/FerrisWheel.cpp
+++ b/src/openrct2/ride/gentle/FerrisWheel.cpp
@@ -54,15 +54,15 @@ static void paint_ferris_wheel_structure(
 
     const TileElement* savedTileElement = static_cast<const TileElement*>(session->CurrentlyDrawnItem);
 
-    Ride* ride = get_ride(rideIndex);
-    rct_ride_entry* rideEntry = get_ride_entry(ride->subtype);
-    rct_vehicle* vehicle = nullptr;
-    if (rideEntry == nullptr)
-    {
-        log_error("Error drawing Ferris Wheel, rideEntry is NULL.");
+    auto ride = get_ride(rideIndex);
+    if (ride == nullptr)
         return;
-    }
 
+    auto rideEntry = ride->GetRideEntry();
+    if (rideEntry == nullptr)
+        return;
+
+    rct_vehicle* vehicle = nullptr;
     int8_t xOffset = !(direction & 1) ? axisOffset : 0;
     int8_t yOffset = (direction & 1) ? axisOffset : 0;
 
diff --git a/src/openrct2/ride/gentle/HauntedHouse.cpp b/src/openrct2/ride/gentle/HauntedHouse.cpp
index 569e10faf0..08a3cf8e63 100644
--- a/src/openrct2/ride/gentle/HauntedHouse.cpp
+++ b/src/openrct2/ride/gentle/HauntedHouse.cpp
@@ -38,14 +38,14 @@ static void paint_haunted_house_structure(
 
     uint8_t frameNum = 0;
 
-    Ride* ride = get_ride(rideIndex);
-    rct_ride_entry* rideEntry = get_ride_entry(ride->subtype);
-
-    if (rideEntry == nullptr)
-    {
-        log_error("Error drawing haunted house, rideEntry is NULL.");
+    auto ride = get_ride(rideIndex);
+    if (ride == nullptr)
         return;
-    }
+
+    auto rideEntry = ride->GetRideEntry();
+    if (rideEntry == nullptr)
+        return;
+
     uint32_t baseImageId = rideEntry->vehicles[0].base_image_id;
 
     if (ride->lifecycle_flags & RIDE_LIFECYCLE_ON_TRACK && ride->vehicles[0] != SPRITE_INDEX_NULL)
diff --git a/src/openrct2/ride/gentle/MerryGoRound.cpp b/src/openrct2/ride/gentle/MerryGoRound.cpp
index fb3db1cc96..0bcd25d1b3 100644
--- a/src/openrct2/ride/gentle/MerryGoRound.cpp
+++ b/src/openrct2/ride/gentle/MerryGoRound.cpp
@@ -29,15 +29,15 @@ static void paint_merry_go_round_structure(
     const TileElement* savedTileElement = static_cast<const TileElement*>(session->CurrentlyDrawnItem);
     height += 7;
 
-    Ride* ride = get_ride(rideIndex);
-    rct_ride_entry* rideEntry = get_ride_entry(ride->subtype);
-    rct_vehicle* vehicle = nullptr;
-
-    if (rideEntry == nullptr)
-    {
+    auto ride = get_ride(rideIndex);
+    if (ride == nullptr)
         return;
-    }
 
+    auto rideEntry = ride->GetRideEntry();
+    if (rideEntry == nullptr)
+        return;
+
+    rct_vehicle* vehicle = nullptr;
     uint32_t baseImageId = rideEntry->vehicles[0].base_image_id;
 
     if (ride->lifecycle_flags & RIDE_LIFECYCLE_ON_TRACK && ride->vehicles[0] != SPRITE_INDEX_NULL)
diff --git a/src/openrct2/ride/gentle/MiniGolf.cpp b/src/openrct2/ride/gentle/MiniGolf.cpp
index 4c0152393e..1cb7634544 100644
--- a/src/openrct2/ride/gentle/MiniGolf.cpp
+++ b/src/openrct2/ride/gentle/MiniGolf.cpp
@@ -1204,7 +1204,14 @@ void vehicle_visual_mini_golf_player(
         return;
     }
 
-    rct_ride_entry* rideEntry = get_ride_entry(get_ride(vehicle->ride)->subtype);
+    auto ride = get_ride(vehicle->ride);
+    if (ride == nullptr)
+        return;
+
+    auto rideEntry = ride->GetRideEntry();
+    if (rideEntry == nullptr)
+        return;
+
     rct_sprite* sprite = get_sprite(vehicle->peep[0]);
 
     uint8_t frame = mini_golf_peep_animation_frames[vehicle->mini_golf_current_animation][vehicle->animation_frame];
@@ -1237,8 +1244,13 @@ void vehicle_visual_mini_golf_ball(
         return;
     }
 
-    Ride* ride = get_ride(vehicle->ride);
-    rct_ride_entry* rideEntry = get_ride_entry(ride->subtype);
+    auto ride = get_ride(vehicle->ride);
+    if (ride == nullptr)
+        return;
+
+    auto rideEntry = ride->GetRideEntry();
+    if (rideEntry == nullptr)
+        return;
 
     uint32_t image_id = rideEntry->vehicles[0].base_image_id;
     sub_98197C(session, image_id, 0, 0, 1, 1, 0, z, 0, 0, z + 3);
diff --git a/src/openrct2/ride/gentle/SpiralSlide.cpp b/src/openrct2/ride/gentle/SpiralSlide.cpp
index 4101cb5e96..943ede9acc 100644
--- a/src/openrct2/ride/gentle/SpiralSlide.cpp
+++ b/src/openrct2/ride/gentle/SpiralSlide.cpp
@@ -87,7 +87,9 @@ static void spiral_slide_paint_tile_front(
 {
     uint32_t image_id = 0;
 
-    Ride* ride = get_ride(rideIndex);
+    auto ride = get_ride(rideIndex);
+    if (ride == nullptr)
+        return;
 
     if (direction == 1)
     {
diff --git a/src/openrct2/ride/shops/Facility.cpp b/src/openrct2/ride/shops/Facility.cpp
index c4c0a76964..11428794e9 100644
--- a/src/openrct2/ride/shops/Facility.cpp
+++ b/src/openrct2/ride/shops/Facility.cpp
@@ -29,21 +29,17 @@ static void facility_paint_setup(
     bool hasSupports = wooden_a_supports_paint_setup(
         session, direction & 1, 0, height, session->TrackColours[SCHEME_3], nullptr);
 
-    Ride* ride = get_ride(rideIndex);
-    rct_ride_entry* rideEntry = get_ride_entry(ride->subtype);
+    auto ride = get_ride(rideIndex);
+    if (ride == nullptr)
+        return;
 
+    auto rideEntry = ride->GetRideEntry();
     if (rideEntry == nullptr)
-    {
-        log_error("Error drawing facility, rideEntry is NULL.");
         return;
-    }
 
-    rct_ride_entry_vehicle* firstVehicleEntry = &rideEntry->vehicles[0];
+    auto firstVehicleEntry = &rideEntry->vehicles[0];
     if (firstVehicleEntry == nullptr)
-    {
-        log_error("Error drawing facility, firstVehicleEntry is NULL.");
         return;
-    }
 
     uint32_t imageId = session->TrackColours[SCHEME_TRACK];
     imageId |= firstVehicleEntry->base_image_id;
diff --git a/src/openrct2/ride/shops/Shop.cpp b/src/openrct2/ride/shops/Shop.cpp
index fba47f155c..90952fcaae 100644
--- a/src/openrct2/ride/shops/Shop.cpp
+++ b/src/openrct2/ride/shops/Shop.cpp
@@ -29,15 +29,17 @@ static void shop_paint_setup(
     bool hasSupports = wooden_a_supports_paint_setup(
         session, direction & 1, 0, height, session->TrackColours[SCHEME_3], nullptr);
 
-    Ride* ride = get_ride(rideIndex);
-    rct_ride_entry* rideEntry = get_ride_entry(ride->subtype);
-    rct_ride_entry_vehicle* firstVehicleEntry = &rideEntry->vehicles[0];
-
-    if (rideEntry == nullptr || firstVehicleEntry == nullptr)
-    {
-        log_error("Error drawing shop, rideEntry or firstVehicleEntry is NULL.");
+    auto ride = get_ride(rideIndex);
+    if (ride == nullptr)
+        return;
+
+    auto rideEntry = ride->GetRideEntry();
+    if (rideEntry == nullptr)
+        return;
+
+    auto firstVehicleEntry = &rideEntry->vehicles[0];
+    if (firstVehicleEntry == nullptr)
         return;
-    }
 
     uint32_t imageId = session->TrackColours[SCHEME_TRACK];
     if (imageId & IMAGE_TYPE_REMAP_2_PLUS)
diff --git a/src/openrct2/ride/thrill/3dCinema.cpp b/src/openrct2/ride/thrill/3dCinema.cpp
index d2cf817202..62ff01e77c 100644
--- a/src/openrct2/ride/thrill/3dCinema.cpp
+++ b/src/openrct2/ride/thrill/3dCinema.cpp
@@ -22,13 +22,13 @@ static void paint_3d_cinema_structure(
 {
     const TileElement* savedTileElement = static_cast<const TileElement*>(session->CurrentlyDrawnItem);
 
-    Ride* ride = get_ride(rideIndex);
-    rct_ride_entry* rideEntry = get_ride_entry(ride->subtype);
-
-    if (rideEntry == nullptr)
-    {
+    auto ride = get_ride(rideIndex);
+    if (ride == nullptr)
+        return;
+
+    auto rideEntry = ride->GetRideEntry();
+    if (rideEntry == nullptr)
         return;
-    }
 
     if (ride->lifecycle_flags & RIDE_LIFECYCLE_ON_TRACK && ride->vehicles[0] != SPRITE_INDEX_NULL)
     {
diff --git a/src/openrct2/ride/thrill/MotionSimulator.cpp b/src/openrct2/ride/thrill/MotionSimulator.cpp
index fd0cc6adf3..3695676d9d 100644
--- a/src/openrct2/ride/thrill/MotionSimulator.cpp
+++ b/src/openrct2/ride/thrill/MotionSimulator.cpp
@@ -33,8 +33,13 @@ enum
 static void paint_motionsimulator_vehicle(
     paint_session* session, int8_t offsetX, int8_t offsetY, uint8_t direction, int32_t height, const TileElement* tileElement)
 {
-    Ride* ride = get_ride(tileElement->AsTrack()->GetRideIndex());
-    rct_ride_entry* rideEntry = ride->GetRideEntry();
+    auto ride = get_ride(tileElement->AsTrack()->GetRideIndex());
+    if (ride == nullptr)
+        return;
+
+    auto rideEntry = ride->GetRideEntry();
+    if (rideEntry == nullptr)
+        return;
 
     const TileElement* savedTileElement = static_cast<const TileElement*>(session->CurrentlyDrawnItem);
 
diff --git a/src/openrct2/ride/transport/Chairlift.cpp b/src/openrct2/ride/transport/Chairlift.cpp
index 06eb4676bf..0d09223a5b 100644
--- a/src/openrct2/ride/transport/Chairlift.cpp
+++ b/src/openrct2/ride/transport/Chairlift.cpp
@@ -175,13 +175,15 @@ static void chairlift_paint_station_ne_sw(
     paint_session* session, ride_id_t rideIndex, uint8_t trackSequence, uint8_t direction, int32_t height,
     const TileElement* tileElement)
 {
+    auto ride = get_ride(rideIndex);
+    if (ride == nullptr)
+        return;
+
     const LocationXY16 pos = session->MapPosition;
     uint8_t trackType = tileElement->AsTrack()->GetTrackType();
-    Ride* ride = get_ride(rideIndex);
     uint32_t imageId;
 
     bool isStart = chairlift_paint_util_is_first_track(rideIndex, tileElement, pos, trackType);
-    ;
     bool isEnd = chairlift_paint_util_is_last_track(rideIndex, tileElement, pos, trackType);
 
     auto stationObj = ride_get_station_object(ride);
@@ -266,13 +268,15 @@ static void chairlift_paint_station_se_nw(
     paint_session* session, ride_id_t rideIndex, uint8_t trackSequence, uint8_t direction, int32_t height,
     const TileElement* tileElement)
 {
+    auto ride = get_ride(rideIndex);
+    if (ride == nullptr)
+        return;
+
     const LocationXY16 pos = session->MapPosition;
     uint8_t trackType = tileElement->AsTrack()->GetTrackType();
-    Ride* ride = get_ride(rideIndex);
     uint32_t imageId;
 
     bool isStart = chairlift_paint_util_is_first_track(rideIndex, tileElement, pos, trackType);
-    ;
     bool isEnd = chairlift_paint_util_is_last_track(rideIndex, tileElement, pos, trackType);
 
     auto stationObj = ride_get_station_object(ride);
diff --git a/src/openrct2/windows/_legacy.cpp b/src/openrct2/windows/_legacy.cpp
index c4ed2920ff..0730b5d980 100644
--- a/src/openrct2/windows/_legacy.cpp
+++ b/src/openrct2/windows/_legacy.cpp
@@ -45,11 +45,12 @@ money32 place_provisional_track_piece(
     ride_id_t rideIndex, int32_t trackType, int32_t trackDirection, int32_t liftHillAndAlternativeState, int32_t x, int32_t y,
     int32_t z)
 {
-    Ride* ride;
-    money32 result;
+    auto ride = get_ride(rideIndex);
+    if (ride == nullptr)
+        return MONEY32_UNDEFINED;
 
+    money32 result;
     ride_construction_remove_ghosts();
-    ride = get_ride(rideIndex);
     if (ride->type == RIDE_TYPE_MAZE)
     {
         int32_t flags = GAME_COMMAND_FLAG_APPLY | GAME_COMMAND_FLAG_ALLOW_DURING_PAUSED | GAME_COMMAND_FLAG_NO_SPEND
diff --git a/src/openrct2/world/Banner.cpp b/src/openrct2/world/Banner.cpp
index 01fa549f67..7553ac9156 100644
--- a/src/openrct2/world/Banner.cpp
+++ b/src/openrct2/world/Banner.cpp
@@ -87,8 +87,8 @@ static uint8_t banner_get_ride_index_at(int32_t x, int32_t y, int32_t z)
             continue;
 
         ride_id_t rideIndex = tileElement->AsTrack()->GetRideIndex();
-        Ride* ride = get_ride(rideIndex);
-        if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_IS_SHOP))
+        auto ride = get_ride(rideIndex);
+        if (ride == nullptr || ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_IS_SHOP))
             continue;
 
         if ((tileElement->clearance_height * 8) + 32 <= z)
diff --git a/src/openrct2/world/Footpath.cpp b/src/openrct2/world/Footpath.cpp
index 0ae82b3068..ce5db90641 100644
--- a/src/openrct2/world/Footpath.cpp
+++ b/src/openrct2/world/Footpath.cpp
@@ -801,8 +801,8 @@ static void loc_6A6D7E(
                 case TILE_ELEMENT_TYPE_TRACK:
                     if (z == tileElement->base_height)
                     {
-                        Ride* ride = get_ride(tileElement->AsTrack()->GetRideIndex());
-                        if (!ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_FLAT_RIDE))
+                        auto ride = get_ride(tileElement->AsTrack()->GetRideIndex());
+                        if (ride == nullptr || !ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_FLAT_RIDE))
                         {
                             continue;
                         }
@@ -929,8 +929,8 @@ static void loc_6A6C85(
 
     if (tileElement->GetType() == TILE_ELEMENT_TYPE_TRACK)
     {
-        Ride* ride = get_ride(tileElement->AsTrack()->GetRideIndex());
-        if (!ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_FLAT_RIDE))
+        auto ride = get_ride(tileElement->AsTrack()->GetRideIndex());
+        if (ride == nullptr || !ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_FLAT_RIDE))
         {
             return;
         }
@@ -2005,7 +2005,10 @@ bool tile_element_wants_path_connection_towards(TileCoordsXYZD coords, const Til
             case TILE_ELEMENT_TYPE_TRACK:
                 if (tileElement->base_height == coords.z)
                 {
-                    Ride* ride = get_ride(tileElement->AsTrack()->GetRideIndex());
+                    auto ride = get_ride(tileElement->AsTrack()->GetRideIndex());
+                    if (ride == nullptr)
+                        continue;
+
                     if (!ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_FLAT_RIDE))
                         break;
 
@@ -2090,9 +2093,9 @@ void footpath_remove_edges_at(int32_t x, int32_t y, TileElement* tileElement)
 {
     if (tileElement->GetType() == TILE_ELEMENT_TYPE_TRACK)
     {
-        ride_id_t rideIndex = tileElement->AsTrack()->GetRideIndex();
-        Ride* ride = get_ride(rideIndex);
-        if (!ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_FLAT_RIDE))
+        auto rideIndex = tileElement->AsTrack()->GetRideIndex();
+        auto ride = get_ride(rideIndex);
+        if (ride == nullptr || !ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_FLAT_RIDE))
             return;
     }
 
diff --git a/src/openrct2/world/Map.cpp b/src/openrct2/world/Map.cpp
index 4a53f053a9..3b5c2c09ed 100644
--- a/src/openrct2/world/Map.cpp
+++ b/src/openrct2/world/Map.cpp
@@ -1297,8 +1297,11 @@ void map_obstruction_set_error_text(TileElement* tileElement)
             break;
         case TILE_ELEMENT_TYPE_TRACK:
             ride = get_ride(tileElement->AsTrack()->GetRideIndex());
-            errorStringId = STR_X_IN_THE_WAY;
-            ride->FormatNameTo(gCommonFormatArgs);
+            if (ride != nullptr)
+            {
+                errorStringId = STR_X_IN_THE_WAY;
+                ride->FormatNameTo(gCommonFormatArgs);
+            }
             break;
         case TILE_ELEMENT_TYPE_SMALL_SCENERY:
             sceneryEntry = tileElement->AsSmallScenery()->GetEntry();