diff --git a/src/openrct2-ui/interface/LandTool.cpp b/src/openrct2-ui/interface/LandTool.cpp
index f6a0a0deb4..a12d50a831 100644
--- a/src/openrct2-ui/interface/LandTool.cpp
+++ b/src/openrct2-ui/interface/LandTool.cpp
@@ -14,6 +14,7 @@
 #include <openrct2/Context.h>
 #include <openrct2/Input.h>
 #include <openrct2/drawing/Drawing.h>
+#include <openrct2/object/ObjectLimits.h>
 #include <openrct2/object/ObjectManager.h>
 #include <openrct2/object/TerrainEdgeObject.h>
 #include <openrct2/object/TerrainSurfaceObject.h>
diff --git a/src/openrct2/Game.cpp b/src/openrct2/Game.cpp
index 6aec3d9873..06e025d49d 100644
--- a/src/openrct2/Game.cpp
+++ b/src/openrct2/Game.cpp
@@ -397,7 +397,7 @@ void game_convert_strings_to_rct2(rct_s6_data* s6)
     {
         if (!str_is_null_or_empty(userString))
         {
-            utf8_to_rct2_self(userString, RCT12_USER_STRING_MAX_LENGTH);
+            utf8_to_rct2_self(userString, RCT12::Limits::MaxUserStringLength);
         }
     }
 }
diff --git a/src/openrct2/ParkFile.cpp b/src/openrct2/ParkFile.cpp
index 2154af5ffa..d169567b67 100644
--- a/src/openrct2/ParkFile.cpp
+++ b/src/openrct2/ParkFile.cpp
@@ -1340,7 +1340,7 @@ namespace OpenRCT2
         static std::vector<ObjectEntryIndex> LegacyGetRideTypesBeenOn(const std::array<uint8_t, 16>& srcArray)
         {
             std::vector<ObjectEntryIndex> ridesTypesBeenOn;
-            for (ObjectEntryIndex i = 0; i < RCT12_MAX_RIDE_OBJECTS; i++)
+            for (ObjectEntryIndex i = 0; i < RCT2::Limits::MaxRideObject; i++)
             {
                 if (srcArray[i / 8] & (1 << (i % 8)))
                 {
@@ -1352,7 +1352,7 @@ namespace OpenRCT2
         static std::vector<ride_id_t> LegacyGetRidesBeenOn(const std::array<uint8_t, 32>& srcArray)
         {
             std::vector<ride_id_t> ridesBeenOn;
-            for (uint16_t i = 0; i < RCT12_MAX_RIDES_IN_PARK; i++)
+            for (uint16_t i = 0; i < RCT2::Limits::MaxRidesInPark; i++)
             {
                 if (srcArray[i / 8] & (1 << (i % 8)))
                 {
diff --git a/src/openrct2/actions/TrackDesignAction.cpp b/src/openrct2/actions/TrackDesignAction.cpp
index 3d831ee101..9907ed7879 100644
--- a/src/openrct2/actions/TrackDesignAction.cpp
+++ b/src/openrct2/actions/TrackDesignAction.cpp
@@ -249,7 +249,7 @@ GameActions::Result TrackDesignAction::Execute() const
         ride->entrance_style = gLastEntranceStyle;
     }
 
-    for (int32_t i = 0; i < RCT12_NUM_COLOUR_SCHEMES; i++)
+    for (int32_t i = 0; i < RCT12::Limits::NumColourSchemes; i++)
     {
         ride->track_colour[i].main = _td.track_spine_colour[i];
         ride->track_colour[i].additional = _td.track_rail_colour[i];
diff --git a/src/openrct2/config/Config.cpp b/src/openrct2/config/Config.cpp
index 84baec7c5e..80641d0563 100644
--- a/src/openrct2/config/Config.cpp
+++ b/src/openrct2/config/Config.cpp
@@ -29,7 +29,7 @@
 #include "../paint/VirtualFloor.h"
 #include "../platform/Platform2.h"
 #include "../platform/platform.h"
-#include "../rct1/RCT1.h"
+#include "../rct1/Limits.h"
 #include "../scenario/Scenario.h"
 #include "../ui/UiContext.h"
 #include "../util/Util.h"
@@ -1001,7 +1001,8 @@ bool RCT1DataPresentAtLocation(const utf8* path)
 
 bool CsgIsUsable(const rct_gx& csg)
 {
-    return csg.header.total_size == RCT1::RCT1_LL_CSG1_DAT_FILE_SIZE && csg.header.num_entries == RCT1::RCT1_NUM_LL_CSG_ENTRIES;
+    return csg.header.total_size == RCT1::Limits::LL_CSG1_DAT_FileSize
+        && csg.header.num_entries == RCT1::Limits::Num_LL_CSG_Entries;
 }
 
 bool CsgAtLocationIsUsable(const utf8* path)
diff --git a/src/openrct2/libopenrct2.vcxproj b/src/openrct2/libopenrct2.vcxproj
index 41c046c8f7..5a1694819c 100644
--- a/src/openrct2/libopenrct2.vcxproj
+++ b/src/openrct2/libopenrct2.vcxproj
@@ -311,13 +311,16 @@
     <ClInclude Include="platform\Crash.h" />
     <ClInclude Include="platform\platform.h" />
     <ClInclude Include="platform\Platform2.h" />
+    <ClInclude Include="rct12\Limits.h" />
     <ClInclude Include="rct12\RCT12.h" />
     <ClInclude Include="rct12\SawyerChunk.h" />
     <ClInclude Include="rct12\SawyerChunkReader.h" />
     <ClInclude Include="rct12\SawyerChunkWriter.h" />
     <ClInclude Include="rct12\SawyerEncoding.h" />
+    <ClInclude Include="rct1\Limits.h" />
     <ClInclude Include="rct1\RCT1.h" />
     <ClInclude Include="rct1\Tables.h" />
+    <ClInclude Include="rct2\Limits.h" />
     <ClInclude Include="rct2\RCT2.h" />
     <ClInclude Include="rct2\T6Exporter.h" />
     <ClInclude Include="ReplayManager.h" />
diff --git a/src/openrct2/object/RideObject.cpp b/src/openrct2/object/RideObject.cpp
index bcb40af3fa..47f6ecaae2 100644
--- a/src/openrct2/object/RideObject.cpp
+++ b/src/openrct2/object/RideObject.cpp
@@ -124,7 +124,7 @@ void RideObject::ReadLegacy(IReadObjectContext* context, IStream* stream)
     }
 
     // Read peep loading positions
-    for (int32_t i = 0; i < RCT2_MAX_VEHICLES_PER_RIDE_ENTRY; i++)
+    for (int32_t i = 0; i < RCT2::Limits::MaxVehiclesPerRideEntry; i++)
     {
         _peepLoadingWaypoints[i].clear();
         _peepLoadingPositions[i].clear();
@@ -198,7 +198,7 @@ void RideObject::Load()
     _legacyType.vehicle_preset_list = &_presetColours;
 
     int32_t cur_vehicle_images_offset = _legacyType.images_offset + MAX_RIDE_TYPES_PER_RIDE_ENTRY;
-    for (int32_t i = 0; i < RCT2_MAX_VEHICLES_PER_RIDE_ENTRY; i++)
+    for (int32_t i = 0; i < RCT2::Limits::MaxVehiclesPerRideEntry; i++)
     {
         rct_ride_entry_vehicle* vehicleEntry = &_legacyType.vehicles[i];
         if (vehicleEntry->sprite_flags & VEHICLE_SPRITE_FLAG_FLAT)
@@ -410,11 +410,11 @@ void RideObject::SetRepositoryItem(ObjectRepositoryItem* item) const
     uint8_t firstRideType = ride_entry_get_first_non_null_ride_type(&_legacyType);
     uint8_t category = GetRideTypeDescriptor(firstRideType).Category;
 
-    for (int32_t i = 0; i < RCT2_MAX_RIDE_TYPES_PER_RIDE_ENTRY; i++)
+    for (int32_t i = 0; i < RCT2::Limits::MaxRideTypesPerRideEntry; i++)
     {
         item->RideInfo.RideType[i] = _legacyType.ride_type[i];
     }
-    for (int32_t i = 0; i < RCT2_MAX_CATEGORIES_PER_RIDE; i++)
+    for (int32_t i = 0; i < RCT2::Limits::MaxCategoriesPerRide; i++)
     {
         item->RideInfo.RideCategory[i] = category;
     }
diff --git a/src/openrct2/rct1/Limits.h b/src/openrct2/rct1/Limits.h
new file mode 100644
index 0000000000..3426d13b0e
--- /dev/null
+++ b/src/openrct2/rct1/Limits.h
@@ -0,0 +1,28 @@
+/*****************************************************************************
+ * Copyright (c) 2014-2021 OpenRCT2 developers
+ *
+ * For a complete list of all authors, please refer to contributors.md
+ * Interested in contributing? Visit https://github.com/OpenRCT2/OpenRCT2
+ *
+ * OpenRCT2 is licensed under the GNU General Public License version 3.
+ *****************************************************************************/
+
+#pragma once
+#include "../rct12/Limits.h"
+
+namespace RCT1::Limits
+{
+    using namespace RCT12::Limits;
+    constexpr const uint16_t MaxTileElements = 0xC000;
+    constexpr const uint16_t MaxEntities = 5000;
+    constexpr const uint8_t MaxTrainsPerRide = 12;
+    constexpr const uint8_t MaxMapSize = 128;
+    constexpr const uint8_t MaxStaff = 116;
+    constexpr const uint16_t MaxAnimatedObjects = 1000;
+    constexpr const uint8_t MaxBanners = 100;
+    constexpr int32_t CoordsZStep = 4;
+    constexpr const uint32_t Num_LL_CSG_Entries = 69917;
+    constexpr const uint32_t LL_CSG1_DAT_FileSize = 41402869;
+    constexpr const uint32_t NumTerrainSurfaces = 16;
+    constexpr const uint32_t NumTerrainEdges = 15;
+} // namespace RCT1::Limits
diff --git a/src/openrct2/rct1/RCT1.h b/src/openrct2/rct1/RCT1.h
index 467b92b2c6..d5c8e028d9 100644
--- a/src/openrct2/rct1/RCT1.h
+++ b/src/openrct2/rct1/RCT1.h
@@ -15,23 +15,11 @@
 #include "../world/Banner.h"
 #include "../world/Climate.h"
 #include "../world/MapAnimation.h"
+#include "Limits.h"
 
 namespace RCT1
 {
-    constexpr const uint16_t RCT1_MAX_TILE_ELEMENTS = 0xC000;
-    constexpr const uint16_t RCT1_MAX_SPRITES = 5000;
-    constexpr const uint8_t RCT1_MAX_TRAINS_PER_RIDE = 12;
-    constexpr const uint8_t RCT1_MAX_MAP_SIZE = 128;
-    constexpr const uint8_t RCT1_MAX_STAFF = 116;
     constexpr const uint8_t RCT1_RESEARCH_FLAGS_SEPARATOR = 0xFF;
-    constexpr const uint16_t RCT1_MAX_ANIMATED_OBJECTS = 1000;
-    constexpr const uint8_t RCT1_MAX_BANNERS = 100;
-    constexpr int32_t RCT1_COORDS_Z_STEP = 4;
-    constexpr const uint32_t RCT1_NUM_LL_CSG_ENTRIES = 69917;
-    constexpr const uint32_t RCT1_LL_CSG1_DAT_FILE_SIZE = 41402869;
-    constexpr const uint32_t RCT1_NUM_TERRAIN_SURFACES = 16;
-    constexpr const uint32_t RCT1_NUM_TERRAIN_EDGES = 15;
-    constexpr const uint32_t RCT1_CUSTOMER_HISTORY_SIZE = 10;
 
     enum class RideType : uint8_t
     {
@@ -150,55 +138,55 @@ namespace RCT1
         {
             colour_t body;
             colour_t trim;
-        } vehicle_colours[RCT1_MAX_TRAINS_PER_RIDE];              // 0x006
-        colour_t track_primary_colour;                            // 0x01E
-        colour_t track_secondary_colour;                          // 0x01F
-        colour_t track_support_colour;                            // 0x020
-        uint8_t status;                                           // 0x021
-        uint16_t name;                                            // 0x022
-        uint16_t name_argument_ride;                              // 0x024
-        uint16_t name_argument_number;                            // 0x026
-        RCT12xy8 overall_view;                                    // 0x028
-        RCT12xy8 station_starts[RCT12_MAX_STATIONS_PER_RIDE];     // 0x02A
-        uint8_t station_height[RCT12_MAX_STATIONS_PER_RIDE];      // 0x032
-        uint8_t station_length[RCT12_MAX_STATIONS_PER_RIDE];      // 0x036
-        uint8_t station_light[RCT12_MAX_STATIONS_PER_RIDE];       // 0x03A
-        uint8_t station_depart[RCT12_MAX_STATIONS_PER_RIDE];      // 0x03E
-        RCT12xy8 entrance[RCT12_MAX_STATIONS_PER_RIDE];           // 0x042
-        RCT12xy8 exit[RCT12_MAX_STATIONS_PER_RIDE];               // 0x04A
-        uint16_t last_peep_in_queue[RCT12_MAX_STATIONS_PER_RIDE]; // 0x052
-        uint8_t num_peeps_in_queue[RCT12_MAX_STATIONS_PER_RIDE];  // 0x05A
-        uint16_t vehicles[RCT1_MAX_TRAINS_PER_RIDE];              // 0x05E
-        uint8_t depart_flags;                                     // 0x076
-        uint8_t num_stations;                                     // 0x077
-        uint8_t num_trains;                                       // 0x078
-        uint8_t num_cars_per_train;                               // 0x079
-        uint8_t proposed_num_vehicles;                            // 0x07A
-        uint8_t proposed_num_cars_per_train;                      // 0x07B
-        uint8_t max_trains;                                       // 0x07C
-        uint8_t min_max_cars_per_train;                           // 0x07D
-        uint8_t min_waiting_time;                                 // 0x07E
-        uint8_t max_waiting_time;                                 // 0x07F
-        uint8_t operation_option;                                 // 0x080
-        uint8_t boat_hire_return_direction;                       // 0x081
-        RCT12xy8 boat_hire_return_position;                       // 0x082
-        uint8_t data_logging_index;                               // 0x084
-        uint8_t special_track_elements;                           // 0x085
-        uint16_t unk_86;                                          // 0x086
-        int32_t max_speed;                                        // 0x088
-        int32_t average_speed;                                    // 0x08C
-        uint8_t current_test_segment;                             // 0x090
-        uint8_t average_speed_test_timeout;                       // 0x091
-        uint8_t pad_0E2[0x2];                                     // 0x092
-        int32_t length[RCT12_MAX_STATIONS_PER_RIDE];              // 0x094
-        uint16_t time[RCT12_MAX_STATIONS_PER_RIDE];               // 0x0A4
-        fixed16_2dp max_positive_vertical_g;                      // 0x0AC
-        fixed16_2dp max_negative_vertical_g;                      // 0x0AE
-        fixed16_2dp max_lateral_g;                                // 0x0B0
-        fixed16_2dp previous_vertical_g;                          // 0x0B2
-        fixed16_2dp previous_lateral_g;                           // 0x0B4
-        uint8_t pad_B6[0x2];                                      // 0x0B6
-        uint32_t testing_flags;                                   // 0x0B8
+        } vehicle_colours[Limits::MaxTrainsPerRide];             // 0x006
+        colour_t track_primary_colour;                           // 0x01E
+        colour_t track_secondary_colour;                         // 0x01F
+        colour_t track_support_colour;                           // 0x020
+        uint8_t status;                                          // 0x021
+        uint16_t name;                                           // 0x022
+        uint16_t name_argument_ride;                             // 0x024
+        uint16_t name_argument_number;                           // 0x026
+        RCT12xy8 overall_view;                                   // 0x028
+        RCT12xy8 station_starts[Limits::MaxStationsPerRide];     // 0x02A
+        uint8_t station_height[Limits::MaxStationsPerRide];      // 0x032
+        uint8_t station_length[Limits::MaxStationsPerRide];      // 0x036
+        uint8_t station_light[Limits::MaxStationsPerRide];       // 0x03A
+        uint8_t station_depart[Limits::MaxStationsPerRide];      // 0x03E
+        RCT12xy8 entrance[Limits::MaxStationsPerRide];           // 0x042
+        RCT12xy8 exit[Limits::MaxStationsPerRide];               // 0x04A
+        uint16_t last_peep_in_queue[Limits::MaxStationsPerRide]; // 0x052
+        uint8_t num_peeps_in_queue[Limits::MaxStationsPerRide];  // 0x05A
+        uint16_t vehicles[Limits::MaxTrainsPerRide];             // 0x05E
+        uint8_t depart_flags;                                    // 0x076
+        uint8_t num_stations;                                    // 0x077
+        uint8_t num_trains;                                      // 0x078
+        uint8_t num_cars_per_train;                              // 0x079
+        uint8_t proposed_num_vehicles;                           // 0x07A
+        uint8_t proposed_num_cars_per_train;                     // 0x07B
+        uint8_t max_trains;                                      // 0x07C
+        uint8_t min_max_cars_per_train;                          // 0x07D
+        uint8_t min_waiting_time;                                // 0x07E
+        uint8_t max_waiting_time;                                // 0x07F
+        uint8_t operation_option;                                // 0x080
+        uint8_t boat_hire_return_direction;                      // 0x081
+        RCT12xy8 boat_hire_return_position;                      // 0x082
+        uint8_t data_logging_index;                              // 0x084
+        uint8_t special_track_elements;                          // 0x085
+        uint16_t unk_86;                                         // 0x086
+        int32_t max_speed;                                       // 0x088
+        int32_t average_speed;                                   // 0x08C
+        uint8_t current_test_segment;                            // 0x090
+        uint8_t average_speed_test_timeout;                      // 0x091
+        uint8_t pad_0E2[0x2];                                    // 0x092
+        int32_t length[Limits::MaxStationsPerRide];              // 0x094
+        uint16_t time[Limits::MaxStationsPerRide];               // 0x0A4
+        fixed16_2dp max_positive_vertical_g;                     // 0x0AC
+        fixed16_2dp max_negative_vertical_g;                     // 0x0AE
+        fixed16_2dp max_lateral_g;                               // 0x0B0
+        fixed16_2dp previous_vertical_g;                         // 0x0B2
+        fixed16_2dp previous_lateral_g;                          // 0x0B4
+        uint8_t pad_B6[0x2];                                     // 0x0B6
+        uint32_t testing_flags;                                  // 0x0B8
         // x y map location of the current track piece during a test
         // this is to prevent counting special tracks multiple times
         RCT12xy8 cur_test_track_location; // 0x0BC
@@ -222,10 +210,10 @@ namespace RCT1
         int16_t unk_D0;           // 0x0D0
         int16_t unk_D2;           // 0x0D2
         // Customer count in the last 10 * 960 game ticks (sliding window)
-        uint16_t num_customers[RCT1_CUSTOMER_HISTORY_SIZE]; // 0xD4
-        money16 price;                                      // 0x0E8
-        RCT12xy8 chairlift_bullwheel_location[2];           // 0x0EA
-        uint8_t chairlift_bullwheel_z[2];                   // 0x0EE
+        uint16_t num_customers[Limits::CustomerHistorySize]; // 0xD4
+        money16 price;                                       // 0x0E8
+        RCT12xy8 chairlift_bullwheel_location[2];            // 0x0EA
+        uint8_t chairlift_bullwheel_z[2];                    // 0x0EE
         union
         {
             RatingTuple ratings;
@@ -283,20 +271,20 @@ namespace RCT1
             };
             uint16_t reliability; // 0x146
         };
-        uint8_t unreliability_factor;                    // 0x148
-        uint8_t downtime;                                // 0x149
-        uint8_t inspection_interval;                     // 0x14A
-        uint8_t last_inspection;                         // 0x14B
-        uint8_t unk_14C[20];                             // 0x14C
-        money32 income_per_hour;                         // 0x160
-        money32 profit;                                  // 0x164
-        uint8_t queue_time[RCT12_MAX_STATIONS_PER_RIDE]; // 0x168
-        colour_t track_colour_main[4];                   // 0x16C
-        colour_t track_colour_additional[4];             // 0x170
-        colour_t track_colour_supports[4];               // 0x174
-        uint8_t music;                                   // 0x178
-        uint8_t entrance_style;                          // 0x179
-        uint8_t unk_17A[230];                            // 0x17A
+        uint8_t unreliability_factor;                   // 0x148
+        uint8_t downtime;                               // 0x149
+        uint8_t inspection_interval;                    // 0x14A
+        uint8_t last_inspection;                        // 0x14B
+        uint8_t unk_14C[20];                            // 0x14C
+        money32 income_per_hour;                        // 0x160
+        money32 profit;                                 // 0x164
+        uint8_t queue_time[Limits::MaxStationsPerRide]; // 0x168
+        colour_t track_colour_main[4];                  // 0x16C
+        colour_t track_colour_additional[4];            // 0x170
+        colour_t track_colour_supports[4];              // 0x174
+        uint8_t music;                                  // 0x178
+        uint8_t entrance_style;                         // 0x179
+        uint8_t unk_17A[230];                           // 0x17A
     };
     assert_struct_size(Ride, 0x260);
 
@@ -515,7 +503,7 @@ namespace RCT1
         int8_t rejoin_queue_timeout;                        // 0xAC
         RCT12RideId previous_ride;                          // 0xAD
         uint16_t previous_ride_time_out;                    // 0xAE
-        RCT12PeepThought thoughts[RCT12_PEEP_MAX_THOUGHTS]; // 0xB0
+        RCT12PeepThought thoughts[Limits::MaxPeepThoughts]; // 0xB0
         uint8_t pad_C4;
         union
         {
@@ -639,9 +627,9 @@ namespace RCT1
         uint32_t ticks;
         uint32_t random_a;
         uint32_t random_b;
-        RCT12TileElement tile_elements[RCT1_MAX_TILE_ELEMENTS];
+        RCT12TileElement tile_elements[Limits::MaxTileElements];
         uint32_t unk_counter;
-        Entity sprites[RCT1_MAX_SPRITES];
+        Entity sprites[Limits::MaxEntities];
         uint16_t next_sprite_index;
         uint16_t first_vehicle_sprite_index;
         uint16_t first_peep_sprite_index;
@@ -662,7 +650,7 @@ namespace RCT1
         money16 park_entrance_fee;
         Entrance park_entrance;
         uint8_t unk_198849;
-        rct12_peep_spawn peep_spawn[RCT12_MAX_PEEP_SPAWNS];
+        rct12_peep_spawn peep_spawn[Limits::MaxPeepSpawns];
         uint8_t unk_198856;
         uint8_t research_level;
         uint32_t unk_198858;
@@ -672,7 +660,7 @@ namespace RCT1
         uint32_t ride_feature_2[128];
         uint16_t guests_in_park;
         uint16_t unk_198C9E;
-        money32 expenditure[RCT12_EXPENDITURE_TABLE_MONTH_COUNT][RCT12_EXPENDITURE_TYPE_COUNT];
+        money32 expenditure[Limits::ExpenditureTableMonthCount][Limits::ExpenditureTypeCount];
         uint32_t guests_in_park_2;
         uint8_t unk_199024;
         colour_t handman_colour;
@@ -715,19 +703,19 @@ namespace RCT1
         uint8_t marketing_status[20];
         uint8_t marketing_assoc[20];
         uint8_t unk_199582[2];
-        money32 cash_history[RCT12_FINANCE_GRAPH_SIZE];
+        money32 cash_history[Limits::FinanceGraphSize];
         money32 total_expenditure;
         money32 profit;
         uint8_t unk_199788[8];
-        money32 weekly_profit_history[RCT12_FINANCE_GRAPH_SIZE];
+        money32 weekly_profit_history[Limits::FinanceGraphSize];
         money32 park_value;
-        money32 park_value_history[RCT12_FINANCE_GRAPH_SIZE];
+        money32 park_value_history[Limits::FinanceGraphSize];
         money32 completed_company_value;
         uint32_t num_admissions;
         money32 admission_total_income;
         money32 company_value;
         uint8_t thought_timer[16];
-        rct12_award awards[RCT12_MAX_AWARDS];
+        rct12_award awards[Limits::MaxAwards];
         money16 land_price;
         money16 construction_rights_price;
         uint16_t unk_199BCC;
@@ -760,16 +748,16 @@ namespace RCT1
         uint16_t unk_199C9A;
         ResearchItem research_items_LL[180];
         uint8_t unk_19A020[5468];
-        RCT12Banner banners[RCT1_MAX_BANNERS];
-        char string_table[RCT12_MAX_USER_STRINGS][RCT12_USER_STRING_MAX_LENGTH];
+        RCT12Banner banners[Limits::MaxBanners];
+        char string_table[Limits::MaxUserStrings][Limits::MaxUserStringLength];
         uint32_t game_time_counter;
-        Ride rides[RCT12_MAX_RIDES_IN_PARK];
+        Ride rides[Limits::MaxRidesInPark];
         uint16_t unk_game_time_counter;
         int16_t view_x;
         int16_t view_y;
         uint8_t view_zoom;
         uint8_t view_rotation;
-        RCT12MapAnimation map_animations[RCT1_MAX_ANIMATED_OBJECTS];
+        RCT12MapAnimation map_animations[Limits::MaxAnimatedObjects];
         uint32_t num_map_animations;
         uint8_t unk_1CADBC[12];
         uint16_t scrolling_text_step;
@@ -779,8 +767,8 @@ namespace RCT1
         RCT12RideMeasurement ride_measurements[8];
         uint32_t next_guest_index;
         uint16_t game_counter_5;
-        uint8_t patrol_areas[(RCT1_MAX_STAFF + RCT12_STAFF_TYPE_COUNT) * RCT12_PATROL_AREA_SIZE];
-        uint8_t staff_modes[RCT1_MAX_STAFF];
+        uint8_t patrol_areas[(Limits::MaxStaff + Limits::StaffTypeCount) * Limits::PatrolAreaSize];
+        uint8_t staff_modes[Limits::MaxStaff];
         uint8_t unk_1F431E[4];
         uint8_t unk_1F4322[8];
         uint8_t climate;
@@ -796,7 +784,7 @@ namespace RCT1
         uint8_t target_weather_gloom;
         uint8_t rain;
         uint8_t target_rain;
-        rct12_news_item messages[RCT12_MAX_NEWS_ITEMS];
+        rct12_news_item messages[Limits::MaxNewsItems];
         char scenario_name[62];
         uint16_t scenario_slot_index;
         uint32_t scenario_flags;
@@ -816,7 +804,7 @@ namespace RCT1
         uint32_t flags;                                               // 0x02
         uint8_t mode;                                                 // 0x06
         uint8_t version_and_colour_scheme;                            // 0x07 0b0000_VVCC
-        rct_vehicle_colour vehicle_colours[RCT1_MAX_TRAINS_PER_RIDE]; // 0x08
+        rct_vehicle_colour vehicle_colours[Limits::MaxTrainsPerRide]; // 0x08
         uint8_t track_spine_colour_v0;                                // 0x20
         uint8_t track_rail_colour_v0;                                 // 0x21
         uint8_t track_support_colour_v0;                              // 0x22
@@ -859,9 +847,9 @@ namespace RCT1
      */
     struct TD4AA : public TD4
     {
-        uint8_t track_spine_colour[RCT12_NUM_COLOUR_SCHEMES];   // 0x38
-        uint8_t track_rail_colour[RCT12_NUM_COLOUR_SCHEMES];    // 0x3C
-        uint8_t track_support_colour[RCT12_NUM_COLOUR_SCHEMES]; // 0x40
+        uint8_t track_spine_colour[Limits::NumColourSchemes];   // 0x38
+        uint8_t track_rail_colour[Limits::NumColourSchemes];    // 0x3C
+        uint8_t track_support_colour[Limits::NumColourSchemes]; // 0x40
         uint8_t flags2;                                         // 0x44
 
         uint8_t pad_45[0x7F]; // 0x45
diff --git a/src/openrct2/rct1/S4Importer.cpp b/src/openrct2/rct1/S4Importer.cpp
index fb57005f1b..8e30d0aaa7 100644
--- a/src/openrct2/rct1/S4Importer.cpp
+++ b/src/openrct2/rct1/S4Importer.cpp
@@ -355,7 +355,7 @@ namespace RCT1
             // Avoid reusing the value used for last import
             _parkValueConversionFactor = 0;
 
-            uint16_t mapSize = _s4.map_size == 0 ? RCT1_MAX_MAP_SIZE : _s4.map_size;
+            uint16_t mapSize = _s4.map_size == 0 ? Limits::MaxMapSize : _s4.map_size;
 
             gScenarioFileName = GetRCT1ScenarioName();
 
@@ -499,7 +499,7 @@ namespace RCT1
 
         void AddAvailableEntriesFromMap()
         {
-            size_t maxTiles = RCT1_MAX_MAP_SIZE * RCT1_MAX_MAP_SIZE;
+            size_t maxTiles = Limits::MaxMapSize * Limits::MaxMapSize;
             size_t tileIndex = 0;
             RCT12TileElement* tileElement = _s4.tile_elements;
 
@@ -804,7 +804,7 @@ namespace RCT1
 
         void ImportRides()
         {
-            for (int32_t i = 0; i < RCT12_MAX_RIDES_IN_PARK; i++)
+            for (int32_t i = 0; i < Limits::MaxRidesInPark; i++)
             {
                 if (_s4.rides[i].type != RideType::Null)
                 {
@@ -875,7 +875,7 @@ namespace RCT1
                 dst->overall_view = TileCoordsXY{ src->overall_view.x, src->overall_view.y }.ToCoordsXY();
             }
 
-            for (int32_t i = 0; i < RCT12_MAX_STATIONS_PER_RIDE; i++)
+            for (int32_t i = 0; i < Limits::MaxStationsPerRide; i++)
             {
                 if (src->station_starts[i].IsNull())
                 {
@@ -886,7 +886,7 @@ namespace RCT1
                     auto tileStartLoc = TileCoordsXY{ src->station_starts[i].x, src->station_starts[i].y };
                     dst->stations[i].Start = tileStartLoc.ToCoordsXY();
                 }
-                dst->stations[i].SetBaseZ(src->station_height[i] * RCT1_COORDS_Z_STEP);
+                dst->stations[i].SetBaseZ(src->station_height[i] * Limits::CoordsZStep);
                 dst->stations[i].Length = src->station_length[i];
                 dst->stations[i].Depart = src->station_light[i];
 
@@ -912,7 +912,7 @@ namespace RCT1
                 dst->stations[i].SegmentLength = src->length[i];
             }
             // All other values take 0 as their default. Since they're already memset to that, no need to do it again.
-            for (int32_t i = RCT12_MAX_STATIONS_PER_RIDE; i < MAX_STATIONS; i++)
+            for (int32_t i = Limits::MaxStationsPerRide; i < MAX_STATIONS; i++)
             {
                 dst->stations[i].Start.SetNull();
                 dst->stations[i].TrainAtStation = RideStation::NO_TRAIN;
@@ -924,11 +924,11 @@ namespace RCT1
             dst->num_stations = src->num_stations;
 
             // Vehicle links (indexes converted later)
-            for (int32_t i = 0; i < RCT1_MAX_TRAINS_PER_RIDE; i++)
+            for (int32_t i = 0; i < Limits::MaxTrainsPerRide; i++)
             {
                 dst->vehicles[i] = src->vehicles[i];
             }
-            for (int32_t i = RCT1_MAX_TRAINS_PER_RIDE; i <= MAX_VEHICLES_PER_RIDE; i++)
+            for (int32_t i = Limits::MaxTrainsPerRide; i <= MAX_VEHICLES_PER_RIDE; i++)
             {
                 dst->vehicles[i] = SPRITE_INDEX_NULL;
             }
@@ -1111,7 +1111,7 @@ namespace RCT1
             }
             else
             {
-                for (int i = 0; i < RCT12_NUM_COLOUR_SCHEMES; i++)
+                for (int i = 0; i < Limits::NumColourSchemes; i++)
                 {
                     dst->track_colour[i].main = RCT1::GetColour(src->track_colour_main[i]);
                     dst->track_colour[i].additional = RCT1::GetColour(src->track_colour_additional[i]);
@@ -1141,7 +1141,7 @@ namespace RCT1
             }
             else
             {
-                for (int i = 0; i < RCT1_MAX_TRAINS_PER_RIDE; i++)
+                for (int i = 0; i < Limits::MaxTrainsPerRide; i++)
                 {
                     // RCT1 had no third colour
                     const auto colourSchemeCopyDescriptor = GetColourSchemeCopyDescriptor(src->vehicle_type);
@@ -1235,7 +1235,7 @@ namespace RCT1
 
         void ImportSprites()
         {
-            for (int i = 0; i < RCT1_MAX_SPRITES; i++)
+            for (int i = 0; i < Limits::MaxEntities; i++)
             {
                 ImportEntity(_s4.sprites[i].unknown);
             }
@@ -1324,7 +1324,7 @@ namespace RCT1
 
             dst->State = static_cast<PeepState>(src->state);
             dst->SubState = src->sub_state;
-            dst->NextLoc = { src->next_x, src->next_y, src->next_z * RCT1_COORDS_Z_STEP };
+            dst->NextLoc = { src->next_x, src->next_y, src->next_z * Limits::CoordsZStep };
             dst->NextFlags = src->next_flags;
             dst->Var37 = src->var_37;
             dst->StepProgress = src->step_progress;
@@ -1368,8 +1368,8 @@ namespace RCT1
             //                                          index in the array ----^     ^--- bit position in the 8-bit value
             // We do the opposite in this function to recover the x and y values.
 
-            int32_t peepOffset = staffId * RCT12_PATROL_AREA_SIZE;
-            for (int32_t i = 0; i < RCT12_PATROL_AREA_SIZE; i++)
+            int32_t peepOffset = staffId * Limits::PatrolAreaSize;
+            for (int32_t i = 0; i < Limits::PatrolAreaSize; i++)
             {
                 if (_s4.patrol_areas[peepOffset + i] == 0)
                 {
@@ -1411,7 +1411,7 @@ namespace RCT1
         void ImportPeepSpawns()
         {
             gPeepSpawns.clear();
-            for (size_t i = 0; i < RCT12_MAX_PEEP_SPAWNS; i++)
+            for (size_t i = 0; i < Limits::MaxPeepSpawns; i++)
             {
                 if (_s4.peep_spawn[i].x != RCT12_PEEP_SPAWN_UNDEFINED)
                 {
@@ -1439,16 +1439,16 @@ namespace RCT1
             gParkValue = ToMoney64(CorrectRCT1ParkValue(_s4.park_value));
             gCurrentProfit = ToMoney64(_s4.profit);
 
-            for (size_t i = 0; i < RCT12_FINANCE_GRAPH_SIZE; i++)
+            for (size_t i = 0; i < Limits::FinanceGraphSize; i++)
             {
                 gCashHistory[i] = ToMoney64(_s4.cash_history[i]);
                 gParkValueHistory[i] = ToMoney64(CorrectRCT1ParkValue(_s4.park_value_history[i]));
                 gWeeklyProfitHistory[i] = ToMoney64(_s4.weekly_profit_history[i]);
             }
 
-            for (size_t i = 0; i < RCT12_EXPENDITURE_TABLE_MONTH_COUNT; i++)
+            for (size_t i = 0; i < Limits::ExpenditureTableMonthCount; i++)
             {
-                for (size_t j = 0; j < RCT12_EXPENDITURE_TYPE_COUNT; j++)
+                for (size_t j = 0; j < Limits::ExpenditureTypeCount; j++)
                 {
                     gExpenditureTable[i][j] = ToMoney64(_s4.expenditure[i][j]);
                 }
@@ -1537,10 +1537,10 @@ namespace RCT1
 
             // Build tile pointer cache (needed to get the first element at a certain location)
             auto tilePointerIndex = TilePointerIndex<RCT12TileElement>(
-                RCT1_MAX_MAP_SIZE, _s4.tile_elements, std::size(_s4.tile_elements));
+                Limits::MaxMapSize, _s4.tile_elements, std::size(_s4.tile_elements));
 
             std::vector<TileElement> tileElements;
-            const auto maxSize = _s4.map_size == 0 ? RCT1_MAX_MAP_SIZE : _s4.map_size;
+            const auto maxSize = _s4.map_size == 0 ? Limits::MaxMapSize : _s4.map_size;
             for (TileCoordsXY coords = { 0, 0 }; coords.y < MAXIMUM_MAP_SIZE_TECHNICAL; coords.y++)
             {
                 for (coords.x = 0; coords.x < MAXIMUM_MAP_SIZE_TECHNICAL; coords.x++)
@@ -1552,7 +1552,7 @@ namespace RCT1
                         RCT12TileElement* srcElement = tilePointerIndex.GetFirstElementAt(coords);
                         do
                         {
-                            if (srcElement->base_height == RCT12_MAX_ELEMENT_HEIGHT)
+                            if (srcElement->base_height == Limits::MaxElementHeight)
                                 continue;
 
                             // Reserve 8 elements for import
@@ -1598,8 +1598,8 @@ namespace RCT1
             // This flag will be set by the caller.
             dst->SetLastForTile(false);
 
-            dst->SetBaseZ(src->base_height * RCT1_COORDS_Z_STEP);
-            dst->SetClearanceZ(src->clearance_height * RCT1_COORDS_Z_STEP);
+            dst->SetBaseZ(src->base_height * Limits::CoordsZStep);
+            dst->SetClearanceZ(src->clearance_height * Limits::CoordsZStep);
 
             switch (tileElementType)
             {
@@ -1800,8 +1800,8 @@ namespace RCT1
                         ConvertWall(type, &colourA, &colourB);
 
                         type = _wallTypeToEntryMap[type];
-                        auto baseZ = src->base_height * RCT1_COORDS_Z_STEP;
-                        auto clearanceZ = src->clearance_height * RCT1_COORDS_Z_STEP;
+                        auto baseZ = src->base_height * Limits::CoordsZStep;
+                        auto clearanceZ = src->clearance_height * Limits::CoordsZStep;
                         auto edgeSlope = LandSlopeToWallSlope[slope][edge & 3];
                         if (edgeSlope & (EDGE_SLOPE_UPWARDS | EDGE_SLOPE_DOWNWARDS))
                         {
@@ -2166,7 +2166,7 @@ namespace RCT1
             }
 
             // Awards
-            for (int32_t i = 0; i < RCT12_MAX_AWARDS; i++)
+            for (int32_t i = 0; i < Limits::MaxAwards; i++)
             {
                 rct12_award* src = &_s4.awards[i];
                 Award* dst = &gCurrentAwards[i];
@@ -2185,7 +2185,7 @@ namespace RCT1
             }
 
             // News items
-            for (size_t i = 0; i < RCT12_MAX_NEWS_ITEMS; i++)
+            for (size_t i = 0; i < Limits::MaxNewsItems; i++)
             {
                 const rct12_news_item* src = &_s4.messages[i];
                 News::Item* dst = &gNewsItems[i];
@@ -2439,7 +2439,7 @@ namespace RCT1
             gParkEntrances.clear();
             tile_element_iterator it;
             tile_element_iterator_begin(&it);
-            while (tile_element_iterator_next(&it) && gParkEntrances.size() < RCT12_MAX_PARK_ENTRANCES)
+            while (tile_element_iterator_next(&it) && gParkEntrances.size() < Limits::MaxParkEntrances)
             {
                 TileElement* element = it.element;
 
@@ -2588,9 +2588,9 @@ namespace RCT1
          */
         void CountBlockSections()
         {
-            for (int32_t x = 0; x < RCT1_MAX_MAP_SIZE; x++)
+            for (int32_t x = 0; x < Limits::MaxMapSize; x++)
             {
-                for (int32_t y = 0; y < RCT1_MAX_MAP_SIZE; y++)
+                for (int32_t y = 0; y < Limits::MaxMapSize; y++)
                 {
                     TileElement* tileElement = map_get_first_element_at(TileCoordsXY{ x, y });
                     if (tileElement == nullptr)
diff --git a/src/openrct2/rct1/T4Importer.cpp b/src/openrct2/rct1/T4Importer.cpp
index 0863558b2d..2659ed4984 100644
--- a/src/openrct2/rct1/T4Importer.cpp
+++ b/src/openrct2/rct1/T4Importer.cpp
@@ -94,7 +94,7 @@ namespace RCT1
             TD4AA td4aa{};
             _stream.Read(&td4aa, sizeof(TD4AA));
 
-            for (int32_t i = 0; i < RCT12_NUM_COLOUR_SCHEMES; i++)
+            for (int32_t i = 0; i < Limits::NumColourSchemes; i++)
             {
                 td->track_spine_colour[i] = RCT1::GetColour(td4aa.track_spine_colour[i]);
                 td->track_rail_colour[i] = RCT1::GetColour(td4aa.track_rail_colour[i]);
@@ -161,7 +161,7 @@ namespace RCT1
             td->colour_scheme = td4Base.version_and_colour_scheme & 0x3;
 
             // Vehicle colours
-            for (int32_t i = 0; i < RCT1_MAX_TRAINS_PER_RIDE; i++)
+            for (int32_t i = 0; i < Limits::MaxTrainsPerRide; i++)
             {
                 // RCT1 had no third colour
                 RCT1::VehicleColourSchemeCopyDescriptor colourSchemeCopyDescriptor = RCT1::GetColourSchemeCopyDescriptor(
@@ -206,7 +206,7 @@ namespace RCT1
                 }
             }
             // Set remaining vehicles to same colour as first vehicle
-            for (size_t i = RCT1_MAX_TRAINS_PER_RIDE; i < std::size(td->vehicle_colours); i++)
+            for (size_t i = Limits::MaxTrainsPerRide; i < std::size(td->vehicle_colours); i++)
             {
                 td->vehicle_colours[i] = td->vehicle_colours[0];
                 td->vehicle_additional_colour[i] = td->vehicle_additional_colour[0];
diff --git a/src/openrct2/rct1/Tables.cpp b/src/openrct2/rct1/Tables.cpp
index 7bdf9b1936..e648fab3ac 100644
--- a/src/openrct2/rct1/Tables.cpp
+++ b/src/openrct2/rct1/Tables.cpp
@@ -118,7 +118,7 @@ namespace RCT1
 
     std::string_view GetTerrainSurfaceObject(uint8_t terrainSurface)
     {
-        static constexpr std::string_view map[RCT1_NUM_TERRAIN_SURFACES] =
+        static constexpr std::string_view map[Limits::NumTerrainSurfaces] =
         {
             "rct2.terrain_surface.grass",
             "rct2.terrain_surface.sand",
@@ -142,7 +142,7 @@ namespace RCT1
 
     std::string_view GetTerrainEdgeObject(uint8_t terrainEdge)
     {
-        static constexpr std::string_view map[RCT1_NUM_TERRAIN_EDGES] =
+        static constexpr std::string_view map[Limits::NumTerrainEdges] =
         {
             "rct2.terrain_edge.rock",
             "rct1.terrain_edge.brick",
diff --git a/src/openrct2/rct12/Limits.h b/src/openrct2/rct12/Limits.h
new file mode 100644
index 0000000000..5c1b0e0cb2
--- /dev/null
+++ b/src/openrct2/rct12/Limits.h
@@ -0,0 +1,47 @@
+/*****************************************************************************
+ * Copyright (c) 2014-2021 OpenRCT2 developers
+ *
+ * For a complete list of all authors, please refer to contributors.md
+ * Interested in contributing? Visit https://github.com/OpenRCT2/OpenRCT2
+ *
+ * OpenRCT2 is licensed under the GNU General Public License version 3.
+ *****************************************************************************/
+
+#pragma once
+#include <cstdint>
+
+namespace RCT12::Limits
+{
+    constexpr const uint8_t MaxRideObject = 128;
+
+    constexpr const uint8_t MaxRidesInPark = 255;
+    constexpr const uint8_t MaxAwards = 4;
+    constexpr const uint8_t MaxNewsItems = 61;
+    constexpr const uint8_t MaxStationsPerRide = 4;
+    constexpr const uint8_t MaxPeepSpawns = 2;
+    constexpr const uint8_t MaxParkEntrances = 4;
+    // The number of elements in the patrol_areas array per staff member. Every bit in the array represents a 4x4 square.
+    // In RCT1, that's an 8-bit array. 8 * 128 = 1024 bits, which is also the number of 4x4 squares on a 128x128 map.
+    // For RCT2, it's a 32-bit array. 32 * 128 = 4096 bits, which is also the number of 4x4 squares on a 256x256 map.
+    constexpr const uint8_t PatrolAreaSize = 128;
+    constexpr const uint8_t StaffTypeCount = 4;
+    constexpr const uint8_t NumColourSchemes = 4;
+    constexpr const uint8_t MaxVehicleColours = 32;
+
+    constexpr const uint8_t ExpenditureTableMonthCount = 16;
+    constexpr const uint8_t ExpenditureTypeCount = 14;
+    constexpr const uint8_t FinanceGraphSize = 128;
+
+    constexpr const uint16_t MaxUserStrings = 1024;
+    constexpr const uint8_t MaxUserStringLength = 32;
+
+    constexpr const uint8_t MaxPeepThoughts = 5;
+
+    constexpr const uint16_t RideMeasurementMaxItems = 4800;
+
+    constexpr uint16_t const MaxInversions = 31;
+    constexpr uint16_t const MaxGolfHoles = 31;
+    constexpr uint16_t const MaxHelices = 31;
+    constexpr const uint8_t MaxElementHeight = 255;
+    constexpr const uint8_t CustomerHistorySize = 10;
+} // namespace RCT12::Limits
diff --git a/src/openrct2/rct12/RCT12.h b/src/openrct2/rct12/RCT12.h
index c377e03556..33b14eebf1 100644
--- a/src/openrct2/rct12/RCT12.h
+++ b/src/openrct2/rct12/RCT12.h
@@ -14,6 +14,7 @@
 #include "../common.h"
 #include "../object/Object.h"
 #include "../ride/RideTypes.h"
+#include "Limits.h"
 
 #include <string>
 #include <string_view>
@@ -29,39 +30,10 @@ constexpr uint8_t RCT2_STRING_FORMAT_ARG_END = 141;
 constexpr uint8_t RCT2_STRING_FORMAT_COLOUR_START = 142;
 constexpr uint8_t RCT2_STRING_FORMAT_COLOUR_END = 156;
 
-constexpr const uint8_t RCT12_MAX_RIDE_OBJECTS = 128;
-
-constexpr const uint8_t RCT12_MAX_RIDES_IN_PARK = 255;
-constexpr const uint8_t RCT12_MAX_AWARDS = 4;
-constexpr const uint8_t RCT12_MAX_NEWS_ITEMS = 61;
-constexpr const uint8_t RCT12_MAX_STATIONS_PER_RIDE = 4;
-constexpr const uint8_t RCT12_MAX_PEEP_SPAWNS = 2;
-constexpr const uint8_t RCT12_MAX_PARK_ENTRANCES = 4;
-// The number of elements in the patrol_areas array per staff member. Every bit in the array represents a 4x4 square.
-// In RCT1, that's an 8-bit array. 8 * 128 = 1024 bits, which is also the number of 4x4 squares on a 128x128 map.
-// For RCT2, it's a 32-bit array. 32 * 128 = 4096 bits, which is also the number of 4x4 squares on a 256x256 map.
-constexpr const uint8_t RCT12_PATROL_AREA_SIZE = 128;
-constexpr const uint8_t RCT12_STAFF_TYPE_COUNT = 4;
-constexpr const uint8_t RCT12_NUM_COLOUR_SCHEMES = 4;
-constexpr const uint8_t RCT12_MAX_VEHICLE_COLOURS = 32;
 constexpr const uint8_t RCT12_SOUND_ID_NULL = 0xFF;
 
-constexpr const uint8_t RCT12_EXPENDITURE_TABLE_MONTH_COUNT = 16;
-constexpr const uint8_t RCT12_EXPENDITURE_TYPE_COUNT = 14;
-constexpr const uint8_t RCT12_FINANCE_GRAPH_SIZE = 128;
-
-constexpr const uint16_t RCT12_MAX_USER_STRINGS = 1024;
-constexpr const uint8_t RCT12_USER_STRING_MAX_LENGTH = 32;
-
-constexpr const uint8_t RCT12_PEEP_MAX_THOUGHTS = 5;
-
 using RCT12RideId = uint8_t;
 constexpr const RCT12RideId RCT12_RIDE_ID_NULL = 255;
-constexpr const uint16_t RCT12_RIDE_MEASUREMENT_MAX_ITEMS = 4800;
-
-constexpr uint16_t const RCT12_MAX_INVERSIONS = 31;
-constexpr uint16_t const RCT12_MAX_GOLF_HOLES = 31;
-constexpr uint16_t const RCT12_MAX_HELICES = 31;
 
 constexpr uint8_t RCT12_BANNER_INDEX_NULL = std::numeric_limits<uint8_t>::max();
 
@@ -83,8 +55,6 @@ constexpr const uint32_t RCT12_RESEARCHED_ITEMS_END = 0xFFFFFFFE;
 // Extra end of list entry. Leftover from RCT1.
 constexpr const uint32_t RCT12_RESEARCHED_ITEMS_END_2 = 0xFFFFFFFD;
 
-constexpr const uint8_t RCT12_MAX_ELEMENT_HEIGHT = 255;
-
 constexpr const uint16_t RCT12_PEEP_SPAWN_UNDEFINED = 0xFFFF;
 
 constexpr const uint16_t RCT12VehicleTrackDirectionMask = 0b0000000000000011;
@@ -868,17 +838,17 @@ assert_struct_size(RCT12PeepThought, 4);
 
 struct RCT12RideMeasurement
 {
-    uint8_t ride_index;                                 // 0x0000
-    uint8_t flags;                                      // 0x0001
-    uint32_t last_use_tick;                             // 0x0002
-    uint16_t num_items;                                 // 0x0006
-    uint16_t current_item;                              // 0x0008
-    uint8_t vehicle_index;                              // 0x000A
-    uint8_t current_station;                            // 0x000B
-    int8_t vertical[RCT12_RIDE_MEASUREMENT_MAX_ITEMS];  // 0x000C
-    int8_t lateral[RCT12_RIDE_MEASUREMENT_MAX_ITEMS];   // 0x12CC
-    uint8_t velocity[RCT12_RIDE_MEASUREMENT_MAX_ITEMS]; // 0x258C
-    uint8_t altitude[RCT12_RIDE_MEASUREMENT_MAX_ITEMS]; // 0x384C
+    uint8_t ride_index;                                       // 0x0000
+    uint8_t flags;                                            // 0x0001
+    uint32_t last_use_tick;                                   // 0x0002
+    uint16_t num_items;                                       // 0x0006
+    uint16_t current_item;                                    // 0x0008
+    uint8_t vehicle_index;                                    // 0x000A
+    uint8_t current_station;                                  // 0x000B
+    int8_t vertical[RCT12::Limits::RideMeasurementMaxItems];  // 0x000C
+    int8_t lateral[RCT12::Limits::RideMeasurementMaxItems];   // 0x12CC
+    uint8_t velocity[RCT12::Limits::RideMeasurementMaxItems]; // 0x258C
+    uint8_t altitude[RCT12::Limits::RideMeasurementMaxItems]; // 0x384C
 };
 assert_struct_size(RCT12RideMeasurement, 0x4B0C);
 
@@ -955,7 +925,7 @@ money32 OpenRCT2CompletedCompanyValueToRCT12(money64 origValue);
 template<typename T> std::vector<uint16_t> RCT12GetRideTypesBeenOn(T* srcPeep)
 {
     std::vector<uint16_t> ridesTypesBeenOn;
-    for (uint16_t i = 0; i < RCT12_MAX_RIDE_OBJECTS; i++)
+    for (uint16_t i = 0; i < RCT12::Limits::MaxRideObject; i++)
     {
         if (srcPeep->ride_types_been_on[i / 8] & (1 << (i % 8)))
         {
@@ -967,7 +937,7 @@ template<typename T> std::vector<uint16_t> RCT12GetRideTypesBeenOn(T* srcPeep)
 template<typename T> std::vector<ride_id_t> RCT12GetRidesBeenOn(T* srcPeep)
 {
     std::vector<ride_id_t> ridesBeenOn;
-    for (uint16_t i = 0; i < RCT12_MAX_RIDES_IN_PARK; i++)
+    for (uint16_t i = 0; i < RCT12::Limits::MaxRidesInPark; i++)
     {
         if (srcPeep->rides_been_on[i / 8] & (1 << (i % 8)))
         {
diff --git a/src/openrct2/rct2/Limits.h b/src/openrct2/rct2/Limits.h
new file mode 100644
index 0000000000..cfd7c92d3d
--- /dev/null
+++ b/src/openrct2/rct2/Limits.h
@@ -0,0 +1,50 @@
+/*****************************************************************************
+ * Copyright (c) 2014-2021 OpenRCT2 developers
+ *
+ * For a complete list of all authors, please refer to contributors.md
+ * Interested in contributing? Visit https://github.com/OpenRCT2/OpenRCT2
+ *
+ * OpenRCT2 is licensed under the GNU General Public License version 3.
+ *****************************************************************************/
+
+#pragma once
+#include "../rct12/Limits.h"
+
+namespace RCT2::Limits
+{
+    using namespace RCT12::Limits;
+    constexpr const uint8_t MaxStaff = 200;
+    constexpr const uint8_t MaxBanners = 250;
+    constexpr const uint8_t MaxTrainsPerRide = 32;
+    constexpr const uint8_t MaxCategoriesPerRide = 2;
+    constexpr const uint8_t MaxRideTypesPerRideEntry = 3;
+    constexpr const uint8_t MaxVehiclesPerRideEntry = 4;
+    constexpr const uint8_t DowntimeHistorySize = 8;
+    constexpr const uint16_t MaxEntities = 10000;
+    constexpr const uint32_t MaxTileElements = 0x30000;
+    constexpr const uint16_t MaxAnimatedObjects = 2000;
+    constexpr const uint8_t MaxResearchedRideTypeQuads = 8;  // With 32 bits per uint32_t, this means there is room for
+                                                             // 256 types.
+    constexpr const uint8_t MaxResearchedRideEntryQuads = 8; // With 32 bits per uint32_t, this means there is room for
+                                                             // 256 entries.
+    constexpr const uint8_t MaxResearchedSceneryItemQuads = 56;
+    constexpr const uint16_t MaxResearchedSceneryItems = (MaxResearchedSceneryItemQuads * 32); // There are 32
+                                                                                               // bits per
+                                                                                               // quad.
+    constexpr const uint16_t MaxResearchItems = 500;
+
+    constexpr uint16_t TD6MaxTrackElements = 8192;
+
+    constexpr const uint8_t MaxSmallSceneryObjects = 252;
+    constexpr const uint8_t MaxLargeSceneryObjects = 128;
+    constexpr const uint8_t MaxWallSceneryObjects = 128;
+    constexpr const uint8_t MaxBannerObjects = 32;
+    constexpr const uint8_t MaxPathObjects = 16;
+    constexpr const uint8_t MaxPathAdditionObjects = 15;
+    constexpr const uint8_t MaxScenereyGroupObjects = 19;
+    constexpr const uint8_t MaxParkEntranceObjects = 1;
+    constexpr const uint8_t MaxWaterObjects = 1;
+    constexpr const uint8_t MaxScenarioTextObjects = 1;
+    constexpr const uint8_t RideTypeCount = 91;
+    constexpr const uint16_t MaxMapSize = 256;
+} // namespace RCT2::Limits
diff --git a/src/openrct2/rct2/RCT2.cpp b/src/openrct2/rct2/RCT2.cpp
index d2b43cfc74..3e11da36c7 100644
--- a/src/openrct2/rct2/RCT2.cpp
+++ b/src/openrct2/rct2/RCT2.cpp
@@ -7,6 +7,8 @@
  * OpenRCT2 is licensed under the GNU General Public License version 3.
  *****************************************************************************/
 
+#include "RCT2.h"
+
 #include "../Context.h"
 #include "../object/Object.h"
 #include "../object/ObjectManager.h"
diff --git a/src/openrct2/rct2/RCT2.h b/src/openrct2/rct2/RCT2.h
index dd55bb2627..215ef7323f 100644
--- a/src/openrct2/rct2/RCT2.h
+++ b/src/openrct2/rct2/RCT2.h
@@ -16,78 +16,42 @@
 #include "../rct12/RCT12.h"
 #include "../ride/RideRatings.h"
 #include "../ride/VehicleColour.h"
+#include "Limits.h"
 
 #include <tuple>
 #include <vector>
 
-constexpr const uint8_t RCT2_MAX_STAFF = 200;
-constexpr const uint8_t RCT2_MAX_BANNERS_IN_PARK = 250;
-constexpr const uint8_t RCT2_MAX_VEHICLES_PER_RIDE = 31;
-constexpr const uint8_t RCT2_MAX_CARS_PER_TRAIN = 32;
-constexpr const uint8_t RCT2_MAX_CATEGORIES_PER_RIDE = 2;
-constexpr const uint8_t RCT2_MAX_RIDE_TYPES_PER_RIDE_ENTRY = 3;
-constexpr const uint8_t RCT2_MAX_VEHICLES_PER_RIDE_ENTRY = 4;
-constexpr const uint8_t RCT2_DOWNTIME_HISTORY_SIZE = 8;
-constexpr const uint8_t RCT2_CUSTOMER_HISTORY_SIZE = 10;
-constexpr const uint16_t RCT2_MAX_SPRITES = 10000;
-constexpr const uint32_t RCT2_MAX_TILE_ELEMENTS = 0x30000;
-constexpr const uint16_t RCT2_MAX_ANIMATED_OBJECTS = 2000;
-constexpr const uint8_t RCT2_MAX_RESEARCHED_RIDE_TYPE_QUADS = 8;  // With 32 bits per uint32_t, this means there is room for 256
-                                                                  // types.
-constexpr const uint8_t RCT2_MAX_RESEARCHED_RIDE_ENTRY_QUADS = 8; // With 32 bits per uint32_t, this means there is room for 256
-                                                                  // entries.
-constexpr const uint8_t RCT2_MAX_RESEARCHED_SCENERY_ITEM_QUADS = 56;
-constexpr const uint16_t RCT2_MAX_RESEARCHED_SCENERY_ITEMS = (RCT2_MAX_RESEARCHED_SCENERY_ITEM_QUADS * 32); // There are 32 bits
-                                                                                                            // per quad.
-constexpr const uint16_t RCT2_MAX_RESEARCH_ITEMS = 500;
-
-constexpr uint16_t TD6MaxTrackElements = 8192;
-
-constexpr const uint8_t RCT2_MAX_SMALL_SCENERY_OBJECTS = 252;
-constexpr const uint8_t RCT2_MAX_LARGE_SCENERY_OBJECTS = 128;
-constexpr const uint8_t RCT2_MAX_WALL_SCENERY_OBJECTS = 128;
-constexpr const uint8_t RCT2_MAX_BANNER_OBJECTS = 32;
-constexpr const uint8_t RCT2_MAX_PATH_OBJECTS = 16;
-constexpr const uint8_t RCT2_MAX_PATH_ADDITION_OBJECTS = 15;
-constexpr const uint8_t RCT2_MAX_SCENERY_GROUP_OBJECTS = 19;
-constexpr const uint8_t RCT2_MAX_PARK_ENTRANCE_OBJECTS = 1;
-constexpr const uint8_t RCT2_MAX_WATER_OBJECTS = 1;
-constexpr const uint8_t RCT2_MAX_SCENARIO_TEXT_OBJECTS = 1;
-constexpr const uint8_t RCT2_RIDE_TYPE_COUNT = 91;
-
 constexpr const rct_string_id RCT2_RIDE_STRING_START = 2;
 
-constexpr const uint16_t RCT2_MAXIMUM_MAP_SIZE_TECHNICAL = 256;
-
 // clang-format off
 constexpr const uint16_t RCT2_OBJECT_ENTRY_COUNT =
-    RCT12_MAX_RIDE_OBJECTS +
-    RCT2_MAX_SMALL_SCENERY_OBJECTS +
-    RCT2_MAX_LARGE_SCENERY_OBJECTS +
-    RCT2_MAX_WALL_SCENERY_OBJECTS +
-    RCT2_MAX_BANNER_OBJECTS +
-    RCT2_MAX_PATH_OBJECTS +
-    RCT2_MAX_PATH_ADDITION_OBJECTS +
-    RCT2_MAX_SCENERY_GROUP_OBJECTS +
-    RCT2_MAX_PARK_ENTRANCE_OBJECTS +
-    RCT2_MAX_WATER_OBJECTS +
-    RCT2_MAX_SCENARIO_TEXT_OBJECTS;
+    RCT2::Limits::MaxRideObject +
+    RCT2::Limits::MaxSmallSceneryObjects +
+    RCT2::Limits::MaxLargeSceneryObjects +
+    RCT2::Limits::MaxWallSceneryObjects +
+    RCT2::Limits::MaxBannerObjects +
+    RCT2::Limits::MaxPathObjects +
+    RCT2::Limits::MaxPathAdditionObjects +
+    RCT2::Limits::MaxScenereyGroupObjects +
+    RCT2::Limits::MaxParkEntranceObjects +
+    RCT2::Limits::MaxWaterObjects +
+    RCT2::Limits::MaxScenarioTextObjects;
 // clang-format on
 static_assert(RCT2_OBJECT_ENTRY_COUNT == 721);
 
 // clang-format off
 constexpr const int32_t rct2_object_entry_group_counts[] = {
-    RCT12_MAX_RIDE_OBJECTS,
-    RCT2_MAX_SMALL_SCENERY_OBJECTS,
-    RCT2_MAX_LARGE_SCENERY_OBJECTS,
-    RCT2_MAX_WALL_SCENERY_OBJECTS,
-    RCT2_MAX_BANNER_OBJECTS,
-    RCT2_MAX_PATH_OBJECTS,
-    RCT2_MAX_PATH_ADDITION_OBJECTS,
-    RCT2_MAX_SCENERY_GROUP_OBJECTS,
-    RCT2_MAX_PARK_ENTRANCE_OBJECTS,
-    RCT2_MAX_WATER_OBJECTS,
-    RCT2_MAX_SCENARIO_TEXT_OBJECTS,
+    RCT2::Limits::MaxRideObject,
+    RCT2::Limits::MaxSmallSceneryObjects,
+    RCT2::Limits::MaxLargeSceneryObjects,
+    RCT2::Limits::MaxWallSceneryObjects,
+    RCT2::Limits::MaxBannerObjects,
+    RCT2::Limits::MaxPathObjects,
+    RCT2::Limits::MaxPathAdditionObjects,
+    RCT2::Limits::MaxScenereyGroupObjects,
+    RCT2::Limits::MaxParkEntranceObjects,
+    RCT2::Limits::MaxWaterObjects,
+    RCT2::Limits::MaxScenarioTextObjects,
 };
 // clang-format on
 
@@ -104,12 +68,12 @@ struct rct2_ride
     uint8_t type; // 0x000
     // pointer to static info. for example, wild mouse type is 0x36, subtype is
     // 0x4c.
-    RCT12ObjectEntryIndex subtype;                               // 0x001
-    uint16_t pad_002;                                            // 0x002
-    uint8_t mode;                                                // 0x004
-    uint8_t colour_scheme_type;                                  // 0x005
-    rct_vehicle_colour vehicle_colours[RCT2_MAX_CARS_PER_TRAIN]; // 0x006
-    uint8_t pad_046[0x03];                                       // 0x046, Used to be track colours in RCT1 without expansions
+    RCT12ObjectEntryIndex subtype;                                      // 0x001
+    uint16_t pad_002;                                                   // 0x002
+    uint8_t mode;                                                       // 0x004
+    uint8_t colour_scheme_type;                                         // 0x005
+    rct_vehicle_colour vehicle_colours[RCT2::Limits::MaxTrainsPerRide]; // 0x006
+    uint8_t pad_046[0x03]; // 0x046, Used to be track colours in RCT1 without expansions
     // 0 = closed, 1 = open, 2 = test
     uint8_t status;     // 0x049
     rct_string_id name; // 0x04A
@@ -122,19 +86,20 @@ struct rct2_ride
             uint16_t name_arguments_number;         // 0x04E
         };
     };
-    RCT12xy8 overall_view;                                // 0x050
-    RCT12xy8 station_starts[RCT12_MAX_STATIONS_PER_RIDE]; // 0x052
-    uint8_t station_heights[RCT12_MAX_STATIONS_PER_RIDE]; // 0x05A
-    uint8_t station_length[RCT12_MAX_STATIONS_PER_RIDE];  // 0x05E
-    uint8_t station_depart[RCT12_MAX_STATIONS_PER_RIDE];  // 0x062
+    RCT12xy8 overall_view;                                     // 0x050
+    RCT12xy8 station_starts[RCT2::Limits::MaxStationsPerRide]; // 0x052
+    uint8_t station_heights[RCT2::Limits::MaxStationsPerRide]; // 0x05A
+    uint8_t station_length[RCT2::Limits::MaxStationsPerRide];  // 0x05E
+    uint8_t station_depart[RCT2::Limits::MaxStationsPerRide];  // 0x062
     // ride->vehicle index for current train waiting for passengers
     // at station
-    uint8_t train_at_station[RCT12_MAX_STATIONS_PER_RIDE];    // 0x066
-    RCT12xy8 entrances[RCT12_MAX_STATIONS_PER_RIDE];          // 0x06A
-    RCT12xy8 exits[RCT12_MAX_STATIONS_PER_RIDE];              // 0x072
-    uint16_t last_peep_in_queue[RCT12_MAX_STATIONS_PER_RIDE]; // 0x07A
-    uint8_t pad_082[RCT12_MAX_STATIONS_PER_RIDE]; // 0x082, Used to be number of peeps in queue in RCT1, but this has moved.
-    uint16_t vehicles[RCT2_MAX_VEHICLES_PER_RIDE + 1]; // 0x086, Points to the first car in the train
+    uint8_t train_at_station[RCT2::Limits::MaxStationsPerRide];    // 0x066
+    RCT12xy8 entrances[RCT2::Limits::MaxStationsPerRide];          // 0x06A
+    RCT12xy8 exits[RCT2::Limits::MaxStationsPerRide];              // 0x072
+    uint16_t last_peep_in_queue[RCT2::Limits::MaxStationsPerRide]; // 0x07A
+    uint8_t pad_082[RCT2::Limits::MaxStationsPerRide]; // 0x082, Used to be number of peeps in queue in RCT1, but this
+                                                       // has moved.
+    uint16_t vehicles[RCT2::Limits::MaxTrainsPerRide]; // 0x086, Points to the first car in the train
     uint8_t depart_flags;                              // 0x0C6
 
     // Not sure if these should be uint or sint.
@@ -168,20 +133,20 @@ struct rct2_ride
     uint8_t pad_0D6[2];             // 0x0D6
     // Divide this value by 29127 to get the human-readable max speed
     // (in RCT2, display_speed = (max_speed * 9) >> 18)
-    int32_t max_speed;                           // 0x0D8
-    int32_t average_speed;                       // 0x0DC
-    uint8_t current_test_segment;                // 0x0E0
-    uint8_t average_speed_test_timeout;          // 0x0E1
-    uint8_t pad_0E2[0x2];                        // 0x0E2
-    int32_t length[RCT12_MAX_STATIONS_PER_RIDE]; // 0x0E4
-    uint16_t time[RCT12_MAX_STATIONS_PER_RIDE];  // 0x0F4
-    fixed16_2dp max_positive_vertical_g;         // 0x0FC
-    fixed16_2dp max_negative_vertical_g;         // 0x0FE
-    fixed16_2dp max_lateral_g;                   // 0x100
-    fixed16_2dp previous_vertical_g;             // 0x102
-    fixed16_2dp previous_lateral_g;              // 0x104
-    uint8_t pad_106[0x2];                        // 0x106
-    uint32_t testing_flags;                      // 0x108
+    int32_t max_speed;                                // 0x0D8
+    int32_t average_speed;                            // 0x0DC
+    uint8_t current_test_segment;                     // 0x0E0
+    uint8_t average_speed_test_timeout;               // 0x0E1
+    uint8_t pad_0E2[0x2];                             // 0x0E2
+    int32_t length[RCT2::Limits::MaxStationsPerRide]; // 0x0E4
+    uint16_t time[RCT2::Limits::MaxStationsPerRide];  // 0x0F4
+    fixed16_2dp max_positive_vertical_g;              // 0x0FC
+    fixed16_2dp max_negative_vertical_g;              // 0x0FE
+    fixed16_2dp max_lateral_g;                        // 0x100
+    fixed16_2dp previous_vertical_g;                  // 0x102
+    fixed16_2dp previous_lateral_g;                   // 0x104
+    uint8_t pad_106[0x2];                             // 0x106
+    uint32_t testing_flags;                           // 0x108
     // x y map location of the current track piece during a test
     // this is to prevent counting special tracks multiple times
     RCT12xy8 cur_test_track_location; // 0x10C
@@ -212,10 +177,10 @@ struct rct2_ride
     // Counts ticks to update customer intervals, resets each 960 game ticks.
     uint16_t num_customers_timeout; // 0x122
     // Customer count in the last 10 * 960 game ticks (sliding window)
-    uint16_t num_customers[RCT2_CUSTOMER_HISTORY_SIZE]; // 0x124
-    money16 price;                                      // 0x138
-    RCT12xy8 chairlift_bullwheel_location[2];           // 0x13A
-    uint8_t chairlift_bullwheel_z[2];                   // 0x13E
+    uint16_t num_customers[RCT2::Limits::CustomerHistorySize]; // 0x124
+    money16 price;                                             // 0x138
+    RCT12xy8 chairlift_bullwheel_location[2];                  // 0x13A
+    uint8_t chairlift_bullwheel_z[2];                          // 0x13E
     union
     {
         RatingTuple ratings; // 0x140
@@ -278,42 +243,42 @@ struct rct2_ride
     // making breakdowns more and more likely.
     uint8_t unreliability_factor; // 0x198
     // Range from [0, 100]
-    uint8_t downtime;                                     // 0x199
-    uint8_t inspection_interval;                          // 0x19A
-    uint8_t last_inspection;                              // 0x19B
-    uint8_t downtime_history[RCT2_DOWNTIME_HISTORY_SIZE]; // 0x19C
-    uint32_t no_primary_items_sold;                       // 0x1A4
-    uint32_t no_secondary_items_sold;                     // 0x1A8
-    uint8_t breakdown_sound_modifier;                     // 0x1AC
+    uint8_t downtime;                                            // 0x199
+    uint8_t inspection_interval;                                 // 0x19A
+    uint8_t last_inspection;                                     // 0x19B
+    uint8_t downtime_history[RCT2::Limits::DowntimeHistorySize]; // 0x19C
+    uint32_t no_primary_items_sold;                              // 0x1A4
+    uint32_t no_secondary_items_sold;                            // 0x1A8
+    uint8_t breakdown_sound_modifier;                            // 0x1AC
     // Used to oscillate the sound when ride breaks down.
     // 0 = no change, 255 = max change
-    uint8_t not_fixed_timeout;                                 // 0x1AD
-    uint8_t last_crash_type;                                   // 0x1AE
-    uint8_t connected_message_throttle;                        // 0x1AF
-    money32 income_per_hour;                                   // 0x1B0
-    money32 profit;                                            // 0x1B4
-    uint8_t queue_time[RCT12_MAX_STATIONS_PER_RIDE];           // 0x1B8
-    uint8_t track_colour_main[RCT12_NUM_COLOUR_SCHEMES];       // 0x1BC
-    uint8_t track_colour_additional[RCT12_NUM_COLOUR_SCHEMES]; // 0x1C0
-    uint8_t track_colour_supports[RCT12_NUM_COLOUR_SCHEMES];   // 0x1C4
-    uint8_t music;                                             // 0x1C8
-    uint8_t entrance_style;                                    // 0x1C9
-    uint16_t vehicle_change_timeout;                           // 0x1CA
-    uint8_t num_block_brakes;                                  // 0x1CC
-    uint8_t lift_hill_speed;                                   // 0x1CD
-    uint16_t guests_favourite;                                 // 0x1CE
-    uint32_t lifecycle_flags;                                  // 0x1D0
-    uint8_t vehicle_colours_extended[RCT2_MAX_CARS_PER_TRAIN]; // 0x1D4
-    uint16_t total_air_time;                                   // 0x1F4
-    uint8_t current_test_station;                              // 0x1F6
-    uint8_t num_circuits;                                      // 0x1F7
-    int16_t cable_lift_x;                                      // 0x1F8
-    int16_t cable_lift_y;                                      // 0x1FA
-    uint8_t cable_lift_z;                                      // 0x1FC
-    uint8_t pad_1FD;                                           // 0x1FD
-    uint16_t cable_lift;                                       // 0x1FE
-    uint16_t queue_length[RCT12_MAX_STATIONS_PER_RIDE];        // 0x200
-    uint8_t pad_208[0x58];                                     // 0x208
+    uint8_t not_fixed_timeout;                                        // 0x1AD
+    uint8_t last_crash_type;                                          // 0x1AE
+    uint8_t connected_message_throttle;                               // 0x1AF
+    money32 income_per_hour;                                          // 0x1B0
+    money32 profit;                                                   // 0x1B4
+    uint8_t queue_time[RCT2::Limits::MaxStationsPerRide];             // 0x1B8
+    uint8_t track_colour_main[RCT2::Limits::NumColourSchemes];        // 0x1BC
+    uint8_t track_colour_additional[RCT2::Limits::NumColourSchemes];  // 0x1C0
+    uint8_t track_colour_supports[RCT2::Limits::NumColourSchemes];    // 0x1C4
+    uint8_t music;                                                    // 0x1C8
+    uint8_t entrance_style;                                           // 0x1C9
+    uint16_t vehicle_change_timeout;                                  // 0x1CA
+    uint8_t num_block_brakes;                                         // 0x1CC
+    uint8_t lift_hill_speed;                                          // 0x1CD
+    uint16_t guests_favourite;                                        // 0x1CE
+    uint32_t lifecycle_flags;                                         // 0x1D0
+    uint8_t vehicle_colours_extended[RCT2::Limits::MaxTrainsPerRide]; // 0x1D4
+    uint16_t total_air_time;                                          // 0x1F4
+    uint8_t current_test_station;                                     // 0x1F6
+    uint8_t num_circuits;                                             // 0x1F7
+    int16_t cable_lift_x;                                             // 0x1F8
+    int16_t cable_lift_y;                                             // 0x1FA
+    uint8_t cable_lift_z;                                             // 0x1FC
+    uint8_t pad_1FD;                                                  // 0x1FD
+    uint16_t cable_lift;                                              // 0x1FE
+    uint16_t queue_length[RCT2::Limits::MaxStationsPerRide];          // 0x200
+    uint8_t pad_208[0x58];                                            // 0x208
 
     uint8_t GetMinCarsPerTrain() const;
     uint8_t GetMaxCarsPerTrain() const;
@@ -367,8 +332,8 @@ struct rct_track_td6
         uint8_t ride_mode;   // 0x06
         uint8_t track_flags; // 0x06
     };
-    uint8_t version_and_colour_scheme;                           // 0x07 0b0000_VVCC
-    rct_vehicle_colour vehicle_colours[RCT2_MAX_CARS_PER_TRAIN]; // 0x08
+    uint8_t version_and_colour_scheme;                                  // 0x07 0b0000_VVCC
+    rct_vehicle_colour vehicle_colours[RCT2::Limits::MaxTrainsPerRide]; // 0x08
     union
     {
         uint8_t pad_48;
@@ -401,21 +366,21 @@ struct rct_track_td6
         uint8_t inversions; // 0x58
         uint8_t holes;      // 0x58
     };
-    uint8_t drops;                                              // 0x59
-    uint8_t highest_drop_height;                                // 0x5A
-    uint8_t excitement;                                         // 0x5B
-    uint8_t intensity;                                          // 0x5C
-    uint8_t nausea;                                             // 0x5D
-    money16 upkeep_cost;                                        // 0x5E
-    uint8_t track_spine_colour[RCT12_NUM_COLOUR_SCHEMES];       // 0x60
-    uint8_t track_rail_colour[RCT12_NUM_COLOUR_SCHEMES];        // 0x64
-    uint8_t track_support_colour[RCT12_NUM_COLOUR_SCHEMES];     // 0x68
-    uint32_t flags2;                                            // 0x6C
-    rct_object_entry vehicle_object;                            // 0x70
-    uint8_t space_required_x;                                   // 0x80
-    uint8_t space_required_y;                                   // 0x81
-    uint8_t vehicle_additional_colour[RCT2_MAX_CARS_PER_TRAIN]; // 0x82
-    uint8_t lift_hill_speed_num_circuits;                       // 0xA2 0bCCCL_LLLL
+    uint8_t drops;                                                     // 0x59
+    uint8_t highest_drop_height;                                       // 0x5A
+    uint8_t excitement;                                                // 0x5B
+    uint8_t intensity;                                                 // 0x5C
+    uint8_t nausea;                                                    // 0x5D
+    money16 upkeep_cost;                                               // 0x5E
+    uint8_t track_spine_colour[RCT2::Limits::NumColourSchemes];        // 0x60
+    uint8_t track_rail_colour[RCT2::Limits::NumColourSchemes];         // 0x64
+    uint8_t track_support_colour[RCT2::Limits::NumColourSchemes];      // 0x68
+    uint32_t flags2;                                                   // 0x6C
+    rct_object_entry vehicle_object;                                   // 0x70
+    uint8_t space_required_x;                                          // 0x80
+    uint8_t space_required_y;                                          // 0x81
+    uint8_t vehicle_additional_colour[RCT2::Limits::MaxTrainsPerRide]; // 0x82
+    uint8_t lift_hill_speed_num_circuits;                              // 0xA2 0bCCCL_LLLL
     // 0xA3 (data starts here in file)
 };
 assert_struct_size(rct_track_td6, 0xA3);
@@ -669,17 +634,17 @@ struct RCT2SpritePeep : RCT12SpriteBase
         uint8_t direction;
     };
     RCT12RideId interaction_ride_index;
-    uint16_t time_in_queue;                             // 0x7A
-    uint8_t rides_been_on[32];                          // 0x7C
-    uint32_t id;                                        // 0x9C
-    money32 cash_in_pocket;                             // 0xA0
-    money32 cash_spent;                                 // 0xA4
-    int32_t park_entry_time;                            // 0xA8
-    int8_t rejoin_queue_timeout;                        // 0xAC
-    RCT12RideId previous_ride;                          // 0xAD
-    uint16_t previous_ride_time_out;                    // 0xAE
-    RCT12PeepThought thoughts[RCT12_PEEP_MAX_THOUGHTS]; // 0xB0
-    uint8_t path_check_optimisation;                    // 0xC4
+    uint16_t time_in_queue;                                   // 0x7A
+    uint8_t rides_been_on[32];                                // 0x7C
+    uint32_t id;                                              // 0x9C
+    money32 cash_in_pocket;                                   // 0xA0
+    money32 cash_spent;                                       // 0xA4
+    int32_t park_entry_time;                                  // 0xA8
+    int8_t rejoin_queue_timeout;                              // 0xAC
+    RCT12RideId previous_ride;                                // 0xAD
+    uint16_t previous_ride_time_out;                          // 0xAE
+    RCT12PeepThought thoughts[RCT2::Limits::MaxPeepThoughts]; // 0xB0
+    uint8_t path_check_optimisation;                          // 0xC4
     union
     {
         uint8_t staff_id;                     // 0xC5
@@ -849,17 +814,17 @@ struct rct_s6_data
         rct_object_entry Objects[RCT2_OBJECT_ENTRY_COUNT];
         struct
         {
-            rct_object_entry RideObjects[RCT12_MAX_RIDE_OBJECTS];
-            rct_object_entry SceneryObjects[RCT2_MAX_SMALL_SCENERY_OBJECTS];
-            rct_object_entry LargeSceneryObjects[RCT2_MAX_LARGE_SCENERY_OBJECTS];
-            rct_object_entry WallSceneryObjects[RCT2_MAX_WALL_SCENERY_OBJECTS];
-            rct_object_entry BannerObjects[RCT2_MAX_BANNER_OBJECTS];
-            rct_object_entry PathObjects[RCT2_MAX_PATH_OBJECTS];
-            rct_object_entry PathAdditionObjects[RCT2_MAX_PATH_ADDITION_OBJECTS];
-            rct_object_entry SceneryGroupObjects[RCT2_MAX_SCENERY_GROUP_OBJECTS];
-            rct_object_entry ParkEntranceObjects[RCT2_MAX_PARK_ENTRANCE_OBJECTS];
-            rct_object_entry WaterObjects[RCT2_MAX_WATER_OBJECTS];
-            rct_object_entry ScenarioTextObjects[RCT2_MAX_SCENARIO_TEXT_OBJECTS];
+            rct_object_entry RideObjects[RCT2::Limits::MaxRideObject];
+            rct_object_entry SceneryObjects[RCT2::Limits::MaxSmallSceneryObjects];
+            rct_object_entry LargeSceneryObjects[RCT2::Limits::MaxLargeSceneryObjects];
+            rct_object_entry WallSceneryObjects[RCT2::Limits::MaxWallSceneryObjects];
+            rct_object_entry BannerObjects[RCT2::Limits::MaxBannerObjects];
+            rct_object_entry PathObjects[RCT2::Limits::MaxPathObjects];
+            rct_object_entry PathAdditionObjects[RCT2::Limits::MaxPathAdditionObjects];
+            rct_object_entry SceneryGroupObjects[RCT2::Limits::MaxScenereyGroupObjects];
+            rct_object_entry ParkEntranceObjects[RCT2::Limits::MaxParkEntranceObjects];
+            rct_object_entry WaterObjects[RCT2::Limits::MaxWaterObjects];
+            rct_object_entry ScenarioTextObjects[RCT2::Limits::MaxScenarioTextObjects];
         };
     };
 
@@ -871,11 +836,11 @@ struct rct_s6_data
     uint32_t scenario_srand_1;
 
     // SC6[5]
-    RCT12TileElement tile_elements[RCT2_MAX_TILE_ELEMENTS];
+    RCT12TileElement tile_elements[RCT2::Limits::MaxTileElements];
 
     // SC6[6]
     uint32_t next_free_tile_element_pointer_index;
-    RCT2Sprite sprites[RCT2_MAX_SPRITES];
+    RCT2Sprite sprites[RCT2::Limits::MaxEntities];
     uint16_t sprite_lists_head[static_cast<uint8_t>(EntityListId::Count)];
     uint16_t sprite_lists_count[static_cast<uint8_t>(EntityListId::Count)];
     rct_string_id park_name;
@@ -890,12 +855,12 @@ struct rct_s6_data
     uint8_t pad_013573EE[2];
     uint8_t rct1_park_entrance_z;
     uint8_t pad_013573F1;
-    rct12_peep_spawn peep_spawns[RCT12_MAX_PEEP_SPAWNS];
+    rct12_peep_spawn peep_spawns[RCT2::Limits::MaxPeepSpawns];
     uint8_t guest_count_change_modifier;
     uint8_t current_research_level;
     uint8_t pad_01357400[4];
-    uint32_t researched_ride_types[RCT2_MAX_RESEARCHED_RIDE_TYPE_QUADS];
-    uint32_t researched_ride_entries[RCT2_MAX_RESEARCHED_RIDE_ENTRY_QUADS];
+    uint32_t researched_ride_types[RCT2::Limits::MaxResearchedRideTypeQuads];
+    uint32_t researched_ride_entries[RCT2::Limits::MaxResearchedRideEntryQuads];
     uint32_t researched_track_types_a[128];
     uint32_t researched_track_types_b[128];
 
@@ -904,7 +869,7 @@ struct rct_s6_data
     uint16_t guests_heading_for_park;
 
     // Ignored in scenario
-    money32 expenditure_table[RCT12_EXPENDITURE_TABLE_MONTH_COUNT][RCT12_EXPENDITURE_TYPE_COUNT];
+    money32 expenditure_table[RCT2::Limits::ExpenditureTableMonthCount][RCT2::Limits::ExpenditureTypeCount];
 
     // SC6[8]
     uint16_t last_guests_in_park;
@@ -914,7 +879,7 @@ struct rct_s6_data
     uint8_t security_colour;
 
     // Ignored in scenario
-    uint32_t researched_scenery_items[RCT2_MAX_RESEARCHED_SCENERY_ITEM_QUADS];
+    uint32_t researched_scenery_items[RCT2::Limits::MaxResearchedSceneryItemQuads];
 
     // SC6[9]
     uint16_t park_rating;
@@ -950,7 +915,7 @@ struct rct_s6_data
     uint8_t campaign_ride_index[22];
 
     // Ignored in scenario
-    money32 balance_history[RCT12_FINANCE_GRAPH_SIZE];
+    money32 balance_history[RCT2::Limits::FinanceGraphSize];
 
     // SC6[11]
     money32 current_expenditure;
@@ -960,13 +925,13 @@ struct rct_s6_data
     uint8_t pad_0135833A[2];
 
     // Ignored in scenario
-    money32 weekly_profit_history[RCT12_FINANCE_GRAPH_SIZE];
+    money32 weekly_profit_history[RCT2::Limits::FinanceGraphSize];
 
     // SC6[12]
     money32 park_value;
 
     // Ignored in scenario
-    money32 park_value_history[RCT12_FINANCE_GRAPH_SIZE];
+    money32 park_value_history[RCT2::Limits::FinanceGraphSize];
 
     // SC6[13]
     money32 completed_company_value;
@@ -974,7 +939,7 @@ struct rct_s6_data
     money32 income_from_admissions;
     money32 company_value;
     uint8_t peep_warning_throttle[16];
-    rct12_award awards[RCT12_MAX_AWARDS];
+    rct12_award awards[RCT2::Limits::MaxAwards];
     money16 land_price;
     money16 construction_rights_price;
     uint16_t word_01358774;
@@ -1002,29 +967,29 @@ struct rct_s6_data
     uint8_t last_entrance_style;
     uint8_t rct1_water_colour;
     uint8_t pad_01358842[2];
-    RCT12ResearchItem research_items[RCT2_MAX_RESEARCH_ITEMS];
+    RCT12ResearchItem research_items[RCT2::Limits::MaxResearchItems];
     uint16_t map_base_z;
     char scenario_name[64];
     char scenario_description[256];
     uint8_t current_interest_rate;
     uint8_t pad_0135934B;
     uint32_t same_price_throughout_extended;
-    int16_t park_entrance_x[RCT12_MAX_PARK_ENTRANCES];
-    int16_t park_entrance_y[RCT12_MAX_PARK_ENTRANCES];
-    int16_t park_entrance_z[RCT12_MAX_PARK_ENTRANCES];
-    uint8_t park_entrance_direction[RCT12_MAX_PARK_ENTRANCES];
+    int16_t park_entrance_x[RCT2::Limits::MaxParkEntrances];
+    int16_t park_entrance_y[RCT2::Limits::MaxParkEntrances];
+    int16_t park_entrance_z[RCT2::Limits::MaxParkEntrances];
+    uint8_t park_entrance_direction[RCT2::Limits::MaxParkEntrances];
     char scenario_filename[256];
     uint8_t saved_expansion_pack_names[3256];
-    RCT12Banner banners[RCT2_MAX_BANNERS_IN_PARK];
-    char custom_strings[RCT12_MAX_USER_STRINGS][RCT12_USER_STRING_MAX_LENGTH];
+    RCT12Banner banners[RCT2::Limits::MaxBanners];
+    char custom_strings[RCT2::Limits::MaxUserStrings][RCT2::Limits::MaxUserStringLength];
     uint32_t game_ticks_1;
-    rct2_ride rides[RCT12_MAX_RIDES_IN_PARK];
+    rct2_ride rides[RCT2::Limits::MaxRidesInPark];
     uint16_t saved_age;
     int16_t saved_view_x;
     int16_t saved_view_y;
     uint8_t saved_view_zoom;
     uint8_t saved_view_rotation;
-    RCT12MapAnimation map_animations[RCT2_MAX_ANIMATED_OBJECTS];
+    RCT12MapAnimation map_animations[RCT2::Limits::MaxAnimatedObjects];
     uint16_t num_map_animations;
     uint8_t pad_0138B582[2];
     RCT2RideRatingCalculationData ride_ratings_calc_data;
@@ -1032,8 +997,8 @@ struct rct_s6_data
     RCT12RideMeasurement ride_measurements[8];
     uint32_t next_guest_index;
     uint16_t grass_and_scenery_tilepos;
-    uint32_t patrol_areas[(RCT2_MAX_STAFF + RCT12_STAFF_TYPE_COUNT) * RCT12_PATROL_AREA_SIZE];
-    RCT2StaffMode staff_modes[RCT2_MAX_STAFF + RCT12_STAFF_TYPE_COUNT];
+    uint32_t patrol_areas[(RCT2::Limits::MaxStaff + RCT2::Limits::StaffTypeCount) * RCT2::Limits::PatrolAreaSize];
+    RCT2StaffMode staff_modes[RCT2::Limits::MaxStaff + RCT2::Limits::StaffTypeCount];
     uint8_t pad_13CA73E;
     uint8_t pad_13CA73F;
     uint8_t byte_13CA740;
@@ -1052,7 +1017,7 @@ struct rct_s6_data
     uint8_t next_weather_gloom;
     uint8_t current_weather_level;
     uint8_t next_weather_level;
-    rct12_news_item news_items[RCT12_MAX_NEWS_ITEMS];
+    rct12_news_item news_items[RCT2::Limits::MaxNewsItems];
     char rct1_scenario_name[62];       // Unused in RCT2
     uint16_t rct1_scenario_slot_index; // Unused in RCT2
     uint32_t rct1_scenario_flags;      // Unused in RCT2
diff --git a/src/openrct2/rct2/S6Importer.cpp b/src/openrct2/rct2/S6Importer.cpp
index e25fb35359..cbbef1a7e1 100644
--- a/src/openrct2/rct2/S6Importer.cpp
+++ b/src/openrct2/rct2/S6Importer.cpp
@@ -88,7 +88,7 @@ private:
     rct_s6_data _s6{};
     uint8_t _gameVersion = 0;
     bool _isSV7 = false;
-    std::bitset<RCT12_MAX_RIDES_IN_PARK> _isFlatRide{};
+    std::bitset<RCT2::Limits::MaxRidesInPark> _isFlatRide{};
     ObjectEntryIndex _pathToSurfaceMap[16];
     ObjectEntryIndex _pathToQueueSurfaceMap[16];
     ObjectEntryIndex _pathToRailingMap[16];
@@ -264,9 +264,9 @@ public:
         gNumGuestsInPark = _s6.guests_in_park;
         gNumGuestsHeadingForPark = _s6.guests_heading_for_park;
 
-        for (size_t i = 0; i < RCT12_EXPENDITURE_TABLE_MONTH_COUNT; i++)
+        for (size_t i = 0; i < RCT2::Limits::ExpenditureTableMonthCount; i++)
         {
-            for (size_t j = 0; j < RCT12_EXPENDITURE_TYPE_COUNT; j++)
+            for (size_t j = 0; j < RCT2::Limits::ExpenditureTypeCount; j++)
             {
                 gExpenditureTable[i][j] = ToMoney64(_s6.expenditure_table[i][j]);
             }
@@ -335,7 +335,7 @@ public:
 
         gParkValue = ToMoney64(_s6.park_value);
 
-        for (size_t i = 0; i < RCT12_FINANCE_GRAPH_SIZE; i++)
+        for (size_t i = 0; i < RCT2::Limits::FinanceGraphSize; i++)
         {
             gCashHistory[i] = ToMoney64(_s6.balance_history[i]);
             gWeeklyProfitHistory[i] = ToMoney64(_s6.weekly_profit_history[i]);
@@ -349,7 +349,7 @@ public:
         std::memcpy(gPeepWarningThrottle, _s6.peep_warning_throttle, sizeof(_s6.peep_warning_throttle));
 
         // Awards
-        for (int32_t i = 0; i < RCT12_MAX_AWARDS; i++)
+        for (int32_t i = 0; i < RCT2::Limits::MaxAwards; i++)
         {
             rct12_award* src = &_s6.awards[i];
             Award* dst = &gCurrentAwards[i];
@@ -386,7 +386,7 @@ public:
         // pad_0135934B
         // Preserve compatibility with vanilla RCT2's save format.
         gParkEntrances.clear();
-        for (uint8_t i = 0; i < RCT12_MAX_PARK_ENTRANCES; i++)
+        for (uint8_t i = 0; i < RCT2::Limits::MaxParkEntrances; i++)
         {
             if (_s6.park_entrance_x[i] != LOCATION_NULL)
             {
@@ -442,7 +442,7 @@ public:
 
         // News items
         News::InitQueue();
-        for (size_t i = 0; i < RCT12_MAX_NEWS_ITEMS; i++)
+        for (size_t i = 0; i < RCT2::Limits::MaxNewsItems; i++)
         {
             const rct12_news_item* src = &_s6.news_items[i];
             News::Item* dst = &gNewsItems[i];
@@ -536,7 +536,7 @@ public:
 
     void ImportRides()
     {
-        for (uint8_t index = 0; index < RCT12_MAX_RIDES_IN_PARK; index++)
+        for (uint8_t index = 0; index < RCT2::Limits::MaxRidesInPark; index++)
         {
             auto src = &_s6.rides[index];
             if (src->type != RIDE_TYPE_NULL)
@@ -561,7 +561,7 @@ public:
      */
     void DetermineFlatRideStatus()
     {
-        for (uint8_t index = 0; index < RCT12_MAX_RIDES_IN_PARK; index++)
+        for (uint8_t index = 0; index < RCT2::Limits::MaxRidesInPark; index++)
         {
             auto src = &_s6.rides[index];
             if (src->type == RIDE_TYPE_NULL)
@@ -622,7 +622,7 @@ public:
         dst->mode = static_cast<RideMode>(src->mode);
         dst->colour_scheme_type = src->colour_scheme_type;
 
-        for (uint8_t i = 0; i < RCT2_MAX_CARS_PER_TRAIN; i++)
+        for (uint8_t i = 0; i < RCT2::Limits::MaxTrainsPerRide; i++)
         {
             dst->vehicle_colours[i].Body = src->vehicle_colours[i].body_colour;
             dst->vehicle_colours[i].Trim = src->vehicle_colours[i].trim_colour;
@@ -651,7 +651,7 @@ public:
             dst->overall_view = tileLoc.ToCoordsXY();
         }
 
-        for (int32_t i = 0; i < RCT12_MAX_STATIONS_PER_RIDE; i++)
+        for (int32_t i = 0; i < RCT2::Limits::MaxStationsPerRide; i++)
         {
             if (src->station_starts[i].IsNull())
             {
@@ -688,7 +688,7 @@ public:
             dst->stations[i].QueueLength = src->queue_length[i];
         }
         // All other values take 0 as their default. Since they're already memset to that, no need to do it again.
-        for (int32_t i = RCT12_MAX_STATIONS_PER_RIDE; i < MAX_STATIONS; i++)
+        for (int32_t i = RCT2::Limits::MaxStationsPerRide; i < MAX_STATIONS; i++)
         {
             dst->stations[i].Start.SetNull();
             dst->stations[i].TrainAtStation = RideStation::NO_TRAIN;
@@ -697,11 +697,11 @@ public:
             dst->stations[i].LastPeepInQueue = SPRITE_INDEX_NULL;
         }
 
-        for (int32_t i = 0; i <= RCT2_MAX_VEHICLES_PER_RIDE; i++)
+        for (int32_t i = 0; i < RCT2::Limits::MaxTrainsPerRide; i++)
         {
             dst->vehicles[i] = src->vehicles[i];
         }
-        for (int32_t i = RCT2_MAX_VEHICLES_PER_RIDE; i <= MAX_VEHICLES_PER_RIDE; i++)
+        for (int32_t i = RCT2::Limits::MaxTrainsPerRide - 1; i <= MAX_VEHICLES_PER_RIDE; i++)
         {
             dst->vehicles[i] = SPRITE_INDEX_NULL;
         }
@@ -770,7 +770,7 @@ public:
         dst->cur_num_customers = src->cur_num_customers;
         dst->num_customers_timeout = src->num_customers_timeout;
 
-        for (uint8_t i = 0; i < RCT2_CUSTOMER_HISTORY_SIZE; i++)
+        for (uint8_t i = 0; i < RCT2::Limits::CustomerHistorySize; i++)
         {
             dst->num_customers[i] = src->num_customers[i];
         }
@@ -834,7 +834,7 @@ public:
         dst->inspection_interval = src->inspection_interval;
         dst->last_inspection = src->last_inspection;
 
-        for (uint8_t i = 0; i < RCT2_DOWNTIME_HISTORY_SIZE; i++)
+        for (uint8_t i = 0; i < RCT2::Limits::DowntimeHistorySize; i++)
         {
             dst->downtime_history[i] = src->downtime_history[i];
         }
@@ -850,7 +850,7 @@ public:
         dst->income_per_hour = ToMoney64(src->income_per_hour);
         dst->profit = ToMoney64(src->profit);
 
-        for (uint8_t i = 0; i < RCT12_NUM_COLOUR_SCHEMES; i++)
+        for (uint8_t i = 0; i < RCT2::Limits::NumColourSchemes; i++)
         {
             dst->track_colour[i].main = src->track_colour_main[i];
             dst->track_colour[i].additional = src->track_colour_additional[i];
@@ -887,7 +887,7 @@ public:
         dst->guests_favourite = src->guests_favourite;
         dst->lifecycle_flags = src->lifecycle_flags;
 
-        for (uint8_t i = 0; i < RCT2_MAX_CARS_PER_TRAIN; i++)
+        for (uint8_t i = 0; i < RCT2::Limits::MaxTrainsPerRide; i++)
         {
             dst->vehicle_colours[i].Ternary = src->vehicle_colours_extended[i];
         }
@@ -911,7 +911,8 @@ public:
         dst.ProximityStart = { src.proximity_start_x, src.proximity_start_y, src.proximity_start_z };
         dst.CurrentRide = RCT12RideIdToOpenRCT2RideId(src.current_ride);
         dst.State = src.state;
-        if (src.current_ride < RCT12_MAX_RIDES_IN_PARK && _s6.rides[src.current_ride].type < std::size(RideTypeDescriptors))
+        if (src.current_ride < RCT2::Limits::MaxRidesInPark
+            && _s6.rides[src.current_ride].type < std::size(RideTypeDescriptors))
             dst.ProximityTrackType = RCT2TrackTypeToOpenRCT2(
                 src.proximity_track_type, _s6.rides[src.current_ride].type, IsFlatRide(src.current_ride));
         else
@@ -1052,7 +1053,7 @@ public:
         }
 
         gPeepSpawns.clear();
-        for (size_t i = 0; i < RCT12_MAX_PEEP_SPAWNS; i++)
+        for (size_t i = 0; i < RCT2::Limits::MaxPeepSpawns; i++)
         {
             if (_s6.peep_spawns[i].x != RCT12_PEEP_SPAWN_UNDEFINED)
             {
@@ -1086,12 +1087,12 @@ public:
     {
         // Build tile pointer cache (needed to get the first element at a certain location)
         auto tilePointerIndex = TilePointerIndex<RCT12TileElement>(
-            RCT2_MAXIMUM_MAP_SIZE_TECHNICAL, _s6.tile_elements, std::size(_s6.tile_elements));
+            RCT2::Limits::MaxMapSize, _s6.tile_elements, std::size(_s6.tile_elements));
 
         std::vector<TileElement> tileElements;
         bool nextElementInvisible = false;
         bool restOfTileInvisible = false;
-        const auto maxSize = std::min(RCT2_MAXIMUM_MAP_SIZE_TECHNICAL, _s6.map_size);
+        const auto maxSize = std::min(RCT2::Limits::MaxMapSize, _s6.map_size);
         for (TileCoordsXY coords = { 0, 0 }; coords.y < MAXIMUM_MAP_SIZE_TECHNICAL; coords.y++)
         {
             for (coords.x = 0; coords.x < MAXIMUM_MAP_SIZE_TECHNICAL; coords.x++)
@@ -1107,7 +1108,7 @@ public:
                     {
                         do
                         {
-                            if (srcElement->base_height == RCT12_MAX_ELEMENT_HEIGHT)
+                            if (srcElement->base_height == RCT12::Limits::MaxElementHeight)
                             {
                                 continue;
                             }
@@ -1458,8 +1459,8 @@ public:
         {
             return;
         }
-        int32_t peepOffset = staffId * RCT12_PATROL_AREA_SIZE;
-        for (int32_t i = 0; i < RCT12_PATROL_AREA_SIZE; i++)
+        int32_t peepOffset = staffId * RCT2::Limits::PatrolAreaSize;
+        for (int32_t i = 0; i < RCT2::Limits::PatrolAreaSize; i++)
         {
             if (_s6.patrol_areas[peepOffset + i] == 0)
             {
@@ -1489,7 +1490,7 @@ public:
 
     void ImportEntities()
     {
-        for (int32_t i = 0; i < RCT2_MAX_SPRITES; i++)
+        for (int32_t i = 0; i < RCT2::Limits::MaxEntities; i++)
         {
             ImportEntity(_s6.sprites[i].unknown);
         }
diff --git a/src/openrct2/rct2/T6Exporter.cpp b/src/openrct2/rct2/T6Exporter.cpp
index 5b0d2adcd2..947cf876ca 100644
--- a/src/openrct2/rct2/T6Exporter.cpp
+++ b/src/openrct2/rct2/T6Exporter.cpp
@@ -53,7 +53,7 @@ bool T6Exporter::SaveTrack(OpenRCT2::IStream* stream)
     tempStream.WriteValue<uint32_t>(_trackDesign->flags);
     tempStream.WriteValue<uint8_t>(static_cast<uint8_t>(_trackDesign->ride_mode));
     tempStream.WriteValue<uint8_t>((_trackDesign->colour_scheme & 0x3) | (2 << 2));
-    tempStream.WriteArray(_trackDesign->vehicle_colours.data(), RCT12_MAX_VEHICLE_COLOURS);
+    tempStream.WriteArray(_trackDesign->vehicle_colours.data(), RCT2::Limits::MaxVehicleColours);
     tempStream.WriteValue<uint8_t>(0);
     tempStream.WriteValue<uint8_t>(_trackDesign->entrance_style);
     tempStream.WriteValue<uint8_t>(_trackDesign->total_air_time);
@@ -76,14 +76,14 @@ bool T6Exporter::SaveTrack(OpenRCT2::IStream* stream)
     tempStream.WriteValue<uint8_t>(_trackDesign->intensity);
     tempStream.WriteValue<uint8_t>(_trackDesign->nausea);
     tempStream.WriteValue<money16>(_trackDesign->upkeep_cost);
-    tempStream.WriteArray(_trackDesign->track_spine_colour, RCT12_NUM_COLOUR_SCHEMES);
-    tempStream.WriteArray(_trackDesign->track_rail_colour, RCT12_NUM_COLOUR_SCHEMES);
-    tempStream.WriteArray(_trackDesign->track_support_colour, RCT12_NUM_COLOUR_SCHEMES);
+    tempStream.WriteArray(_trackDesign->track_spine_colour, RCT2::Limits::NumColourSchemes);
+    tempStream.WriteArray(_trackDesign->track_rail_colour, RCT2::Limits::NumColourSchemes);
+    tempStream.WriteArray(_trackDesign->track_support_colour, RCT2::Limits::NumColourSchemes);
     tempStream.WriteValue<uint32_t>(_trackDesign->flags2);
     tempStream.Write(&_trackDesign->vehicle_object.Entry, sizeof(rct_object_entry));
     tempStream.WriteValue<uint8_t>(_trackDesign->space_required_x);
     tempStream.WriteValue<uint8_t>(_trackDesign->space_required_y);
-    tempStream.WriteArray(_trackDesign->vehicle_additional_colour, RCT2_MAX_CARS_PER_TRAIN);
+    tempStream.WriteArray(_trackDesign->vehicle_additional_colour, RCT2::Limits::MaxTrainsPerRide);
     tempStream.WriteValue<uint8_t>(_trackDesign->lift_hill_speed | (_trackDesign->num_circuits << 5));
 
     if (_trackDesign->type == RIDE_TYPE_MAZE)
diff --git a/src/openrct2/rct2/T6Importer.cpp b/src/openrct2/rct2/T6Importer.cpp
index 75b912957f..85e51d36b1 100644
--- a/src/openrct2/rct2/T6Importer.cpp
+++ b/src/openrct2/rct2/T6Importer.cpp
@@ -84,7 +84,7 @@ public:
         td->ride_mode = static_cast<RideMode>(td6.ride_mode);
         td->track_flags = 0;
         td->colour_scheme = td6.version_and_colour_scheme & 0x3;
-        for (auto i = 0; i < RCT2_MAX_CARS_PER_TRAIN; ++i)
+        for (auto i = 0; i < RCT2::Limits::MaxTrainsPerRide; ++i)
         {
             td->vehicle_colours[i] = td6.vehicle_colours[i];
             td->vehicle_additional_colour[i] = td6.vehicle_additional_colour[i];
@@ -119,7 +119,7 @@ public:
         td->intensity = td6.intensity;
         td->nausea = td6.nausea;
         td->upkeep_cost = td6.upkeep_cost;
-        for (auto i = 0; i < RCT12_NUM_COLOUR_SCHEMES; ++i)
+        for (auto i = 0; i < RCT2::Limits::NumColourSchemes; ++i)
         {
             td->track_spine_colour[i] = td6.track_spine_colour[i];
             td->track_rail_colour[i] = td6.track_rail_colour[i];
diff --git a/src/openrct2/ride/Ride.h b/src/openrct2/ride/Ride.h
index 1805a8acf4..5503a2b5ee 100644
--- a/src/openrct2/ride/Ride.h
+++ b/src/openrct2/ride/Ride.h
@@ -11,12 +11,12 @@
 
 #include "../common.h"
 #include "../localisation/Formatter.h"
-#include "../rct12/RCT12.h"
-#include "../rct2/RCT2.h"
+#include "../rct2/Limits.h"
 #include "../world/Map.h"
 #include "RideColour.h"
 #include "RideRatings.h"
 #include "RideTypes.h"
+#include "VehicleColour.h"
 
 #include <limits>
 #include <string_view>
@@ -29,6 +29,7 @@ struct RideTypeDescriptor;
 struct Guest;
 struct Staff;
 struct Vehicle;
+struct rct_ride_entry;
 
 constexpr const uint8_t MAX_VEHICLES_PER_RIDE = 255; // Note: that 255 represents No Train (null) hence why this is not 256
 constexpr const uint8_t MAX_CIRCUITS_PER_RIDE = 20;
@@ -44,9 +45,9 @@ constexpr const uint16_t MAX_RIDES = 1000;
 #define RIDE_ADJACENCY_CHECK_DISTANCE 5
 
 constexpr uint16_t const MAX_STATION_LOCATIONS = MAX_STATIONS * 2; // Entrance and exit per station
-constexpr uint16_t const MAX_INVERSIONS = RCT12_MAX_INVERSIONS;
-constexpr uint16_t const MAX_GOLF_HOLES = RCT12_MAX_GOLF_HOLES;
-constexpr uint16_t const MAX_HELICES = RCT12_MAX_HELICES;
+constexpr uint16_t const MAX_INVERSIONS = RCT12::Limits::MaxInversions;
+constexpr uint16_t const MAX_GOLF_HOLES = RCT12::Limits::MaxGolfHoles;
+constexpr uint16_t const MAX_HELICES = RCT12::Limits::MaxHelices;
 
 constexpr uint16_t const MAZE_CLEARANCE_HEIGHT = 4 * COORDS_Z_STEP;
 
diff --git a/src/openrct2/ride/RideEntry.h b/src/openrct2/ride/RideEntry.h
index 724d7ae4b3..c34b504b44 100644
--- a/src/openrct2/ride/RideEntry.h
+++ b/src/openrct2/ride/RideEntry.h
@@ -9,7 +9,7 @@
 
 #pragma once
 
-#include "../rct2/RCT2.h"
+#include "../rct2/Limits.h"
 #include "RideColour.h"
 #include "ShopItem.h"
 #include "VehicleEntry.h"
@@ -50,7 +50,7 @@ struct rct_ride_entry
     // The first three images are previews. They correspond to the ride_type[] array.
     uint32_t images_offset;
     uint32_t flags;
-    uint8_t ride_type[RCT2_MAX_RIDE_TYPES_PER_RIDE_ENTRY];
+    uint8_t ride_type[RCT2::Limits::MaxRideTypesPerRideEntry];
     uint8_t min_cars_in_train;
     uint8_t max_cars_in_train;
     uint8_t cars_per_flat_ride;
@@ -65,7 +65,7 @@ struct rct_ride_entry
     uint8_t rear_vehicle;
     uint8_t third_vehicle;
     uint8_t BuildMenuPriority;
-    rct_ride_entry_vehicle vehicles[RCT2_MAX_VEHICLES_PER_RIDE_ENTRY];
+    rct_ride_entry_vehicle vehicles[RCT2::Limits::MaxVehiclesPerRideEntry];
     vehicle_colour_preset_list* vehicle_preset_list;
     int8_t excitement_multiplier;
     int8_t intensity_multiplier;
diff --git a/src/openrct2/ride/TrackDesign.cpp b/src/openrct2/ride/TrackDesign.cpp
index dcf9ce546d..ed77c8315a 100644
--- a/src/openrct2/ride/TrackDesign.cpp
+++ b/src/openrct2/ride/TrackDesign.cpp
@@ -98,14 +98,14 @@ rct_string_id TrackDesign::CreateTrackDesign(TrackDesignState& tds, const Ride&
     ride_mode = ride.mode;
     colour_scheme = ride.colour_scheme_type & 3;
 
-    for (int32_t i = 0; i < RCT2_MAX_CARS_PER_TRAIN; i++)
+    for (int32_t i = 0; i < RCT2::Limits::MaxTrainsPerRide; i++)
     {
         vehicle_colours[i].body_colour = ride.vehicle_colours[i].Body;
         vehicle_colours[i].trim_colour = ride.vehicle_colours[i].Trim;
         vehicle_additional_colour[i] = ride.vehicle_colours[i].Ternary;
     }
 
-    for (int32_t i = 0; i < RCT12_NUM_COLOUR_SCHEMES; i++)
+    for (int32_t i = 0; i < RCT12::Limits::NumColourSchemes; i++)
     {
         track_spine_colour[i] = ride.track_colour[i].main;
         track_rail_colour[i] = ride.track_colour[i].additional;
@@ -238,7 +238,7 @@ rct_string_id TrackDesign::CreateTrackDesignTrack(TrackDesignState& tds, const R
         trackElement.x = newCoords->x;
         trackElement.y = newCoords->y;
 
-        if (track_elements.size() > TD6MaxTrackElements)
+        if (track_elements.size() > RCT2::Limits::TD6MaxTrackElements)
         {
             return STR_TRACK_TOO_LARGE_OR_TOO_MUCH_SCENERY;
         }
@@ -247,7 +247,7 @@ rct_string_id TrackDesign::CreateTrackDesignTrack(TrackDesignState& tds, const R
     // First entrances, second exits
     for (int32_t i = 0; i < 2; i++)
     {
-        for (StationIndex station_index = 0; station_index < RCT12_MAX_STATIONS_PER_RIDE; station_index++)
+        for (StationIndex station_index = 0; station_index < RCT12::Limits::MaxStationsPerRide; station_index++)
         {
             z = ride.stations[station_index].GetBaseZ();
 
@@ -1984,7 +1984,7 @@ static bool TrackDesignPlacePreview(TrackDesignState& tds, TrackDesign* td6, mon
         ride->entrance_style = gLastEntranceStyle;
     }
 
-    for (int32_t i = 0; i < RCT12_NUM_COLOUR_SCHEMES; i++)
+    for (int32_t i = 0; i < RCT12::Limits::NumColourSchemes; i++)
     {
         ride->track_colour[i].main = td6->track_spine_colour[i];
         ride->track_colour[i].additional = td6->track_rail_colour[i];
@@ -1995,7 +1995,7 @@ static bool TrackDesignPlacePreview(TrackDesignState& tds, TrackDesign* td6, mon
     // in the preview window
     if (!GetRideTypeDescriptor(td6->type).HasFlag(RIDE_TYPE_FLAG_HAS_TRACK))
     {
-        for (int32_t i = 0; i < RCT12_MAX_VEHICLE_COLOURS; i++)
+        for (int32_t i = 0; i < RCT12::Limits::MaxVehicleColours; i++)
         {
             ride->vehicle_colours[i].Body = td6->vehicle_colours[i].body_colour;
             ride->vehicle_colours[i].Trim = td6->vehicle_colours[i].trim_colour;
diff --git a/src/openrct2/ride/TrackDesign.h b/src/openrct2/ride/TrackDesign.h
index 962bc1b7aa..e032db9daa 100644
--- a/src/openrct2/ride/TrackDesign.h
+++ b/src/openrct2/ride/TrackDesign.h
@@ -106,7 +106,7 @@ struct TrackDesign
     RideMode ride_mode;
     uint8_t track_flags;
     uint8_t colour_scheme;
-    std::array<rct_vehicle_colour, RCT2_MAX_CARS_PER_TRAIN> vehicle_colours;
+    std::array<rct_vehicle_colour, RCT2::Limits::MaxTrainsPerRide> vehicle_colours;
     uint8_t entrance_style;
     uint8_t total_air_time;
     uint8_t depart_flags;
@@ -129,14 +129,14 @@ struct TrackDesign
     uint8_t intensity;
     uint8_t nausea;
     money16 upkeep_cost;
-    uint8_t track_spine_colour[RCT12_NUM_COLOUR_SCHEMES];
-    uint8_t track_rail_colour[RCT12_NUM_COLOUR_SCHEMES];
-    uint8_t track_support_colour[RCT12_NUM_COLOUR_SCHEMES];
+    uint8_t track_spine_colour[RCT12::Limits::NumColourSchemes];
+    uint8_t track_rail_colour[RCT12::Limits::NumColourSchemes];
+    uint8_t track_support_colour[RCT12::Limits::NumColourSchemes];
     uint32_t flags2;
     ObjectEntryDescriptor vehicle_object;
     uint8_t space_required_x;
     uint8_t space_required_y;
-    uint8_t vehicle_additional_colour[RCT2_MAX_CARS_PER_TRAIN];
+    uint8_t vehicle_additional_colour[RCT2::Limits::MaxTrainsPerRide];
     uint8_t lift_hill_speed;
     uint8_t num_circuits;
 
diff --git a/src/openrct2/sprites.h b/src/openrct2/sprites.h
index 0965ea5fd0..653994d19b 100644
--- a/src/openrct2/sprites.h
+++ b/src/openrct2/sprites.h
@@ -10,7 +10,7 @@
 #pragma once
 
 #include "drawing/ScrollingText.h"
-#include "rct1/RCT1.h"
+#include "rct1/Limits.h"
 
 enum
 {
@@ -1091,7 +1091,7 @@ enum
     SPR_G2_END = SPR_G2_SINGLE_RAIL_END,
 
     SPR_CSG_BEGIN = SPR_G2_END,
-    SPR_CSG_END = SPR_CSG_BEGIN + RCT1::RCT1_NUM_LL_CSG_ENTRIES,
+    SPR_CSG_END = SPR_CSG_BEGIN + RCT1::Limits::Num_LL_CSG_Entries,
 
     SPR_SCROLLING_TEXT_START = SPR_CSG_END,
     SPR_SCROLLING_TEXT_END = SPR_SCROLLING_TEXT_START + OpenRCT2::MaxScrollingTextEntries,