mirrors
/
OpenRCT2
mirror of https://github.com/OpenRCT2/OpenRCT2.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

Introduce Limits headers. (#15329) 

* Move RCT12 limits to seperate file and namespace

* Remove prefix from constants

* Add rct1 limits file

* Rename constants to remove prefix

* Add RCT2 limits file

* Remove RCT2 prefix from constants

* Move constant to correct header

* Fix rebase mistakes

* Drop prefix
This commit is contained in:
Duncan 2021-11-27 16:20:05 +00:00 committed by GitHub
parent bcb527d331
commit eba42a9584
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
25 changed files with 490 additions and 433 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/openrct2-ui/interface/LandTool.cpp
View File

@ -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>

2
src/openrct2/Game.cpp
View File

@ -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);
}
}
}

4
src/openrct2/ParkFile.cpp
View File

@ -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)))
{

2
src/openrct2/actions/TrackDesignAction.cpp
View File

@ -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];

5
src/openrct2/config/Config.cpp
View File

@ -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)

3
src/openrct2/libopenrct2.vcxproj
View File

@ -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" />

8
src/openrct2/object/RideObject.cpp
View File

@ -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;
}

28
src/openrct2/rct1/Limits.h Normal file
View File

@ -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

188
src/openrct2/rct1/RCT1.h
View File

@ -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

60
src/openrct2/rct1/S4Importer.cpp
View File

@ -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)

6
src/openrct2/rct1/T4Importer.cpp
View File

@ -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];

4
src/openrct2/rct1/Tables.cpp
View File

@ -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",

47
src/openrct2/rct12/Limits.h Normal file
View File

@ -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

58
src/openrct2/rct12/RCT12.h
View File

@ -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)))
{

50
src/openrct2/rct2/Limits.h Normal file
View File

@ -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

2
src/openrct2/rct2/RCT2.cpp
View File

@ -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"

345
src/openrct2/rct2/RCT2.h
View File

@ -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

53
src/openrct2/rct2/S6Importer.cpp
View File

@ -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);
}

10
src/openrct2/rct2/T6Exporter.cpp
View File

@ -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)

4
src/openrct2/rct2/T6Importer.cpp
View File

@ -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];

11
src/openrct2/ride/Ride.h
View File

@ -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;

6
src/openrct2/ride/RideEntry.h
View File

@ -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;

12
src/openrct2/ride/TrackDesign.cpp
View File

@ -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;

10
src/openrct2/ride/TrackDesign.h
View File

@ -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;

4
src/openrct2/sprites.h
View File

@ -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,