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

Merge pull request #15337 from ZehMatt/refactor/s4-ridetype 

Make S4 RideType a strong enum
This commit is contained in:
Michael Steenbeek 2021-09-04 15:23:53 +02:00 committed by GitHub
parent 60d596d1f8 8f5fb9d179
commit b1ecd9e89e
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
5 changed files with 173 additions and 167 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -34,6 +34,98 @@ namespace RCT1
constexpr const uint32_t RCT1_NUM_TERRAIN_SURFACES = 16; constexpr const uint32_t RCT1_NUM_TERRAIN_SURFACES = 16;
constexpr const uint32_t RCT1_NUM_TERRAIN_EDGES = 15; constexpr const uint32_t RCT1_NUM_TERRAIN_EDGES = 15;
enum class RideType : uint8_t
{
WoodenRollerCoaster = 0,
StandUpSteelRollerCoaster,
SuspendedRollerCoaster,
InvertedRollerCoaster,
SteelMiniRollerCoaster,
MiniatureRailway,
Monorail,
SuspendedSingleRailRollerCoaster,
BoatHire,
WoodenCrazyRodentRollerCoaster,
SingleRailRollerCoaster,
CarRide,
LaunchedFreefall,
BobsledRollerCoaster,
ObservationTower,
SteelRollerCoaster,
WaterSlide,
MineTrainRollerCoaster,
Chairlift,
SteelCorkscrewRollerCoaster,
HedgeMaze,
SpiralSlide,
GoKarts,
LogFlume,
RiverRapids,
Dodgems,
SwingingShip,
SwingingInverterShip,
IceCreamStall,
ChipsStall,
DrinkStall,
CandyflossStall,
BurgerBar,
MerryGoRound,
BalloonStall,
InformationKiosk,
Toilets,
FerrisWheel,
MotionSimulator,
_3DCinema,
TopSpin,
SpaceRings,
ReverseFreefallRollerCoaster,
SouvenirStall,
VerticalRollerCoaster,
PizzaStall,
Twist,
HauntedHouse,
PopcornStall,
Circus,
GhostTrain,
SteelTwisterRollerCoaster,
WoodenTwisterRollerCoaster,
WoodenSideFrictionRollerCoaster,
SteelWildMouseRollerCoaster,
HotDogStall,
ExoticSeaFoodStall,
HatStall,
ToffeeAppleStall,
VirginiaReel,
RiverRide,
CycleMonorail,
FlyingRollerCoaster,
SuspendedMonorail,
_40,
WoodenReverseRollerCoaster,
HeartlineTwisterRollerCoaster,
MiniatureGolf,
_44,
RotoDrop,
FlyingSaucers,
CrookedHouse,
CycleRailway,
SuspendedLoopingRollerCoaster,
WaterCoaster,
AirPoweredVerticalCoaster,
InvertedWildMouseCoaster,
JetSkis,
TShirtStall,
RaftRide,
DoughnutShop,
Enterprise,
CoffeeShop,
FriedChickenStall,
LemonadeStall,
Count,
Null = 255,
};
#pragma pack(push, 1) #pragma pack(push, 1)
struct Entrance struct Entrance
{ {
@ -50,7 +142,7 @@ namespace RCT1
*/ */
struct Ride struct Ride
{ {
uint8_t type; // 0x000 RideType type; // 0x000
uint8_t vehicle_type; // 0x001 uint8_t vehicle_type; // 0x001
uint16_t lifecycle_flags; // 0x002 uint16_t lifecycle_flags; // 0x002
uint8_t operating_mode; // 0x004 uint8_t operating_mode; // 0x004
@ -720,7 +812,7 @@ namespace RCT1
*/ */
struct TD4 struct TD4
{ {
uint8_t type; // 0x00 RideType type; // 0x00
uint8_t vehicle_type; uint8_t vehicle_type;
uint32_t flags; // 0x02 uint32_t flags; // 0x02
uint8_t mode; // 0x06 uint8_t mode; // 0x06
@ -779,98 +871,6 @@ namespace RCT1
assert_struct_size(TD4AA, 0xC4); assert_struct_size(TD4AA, 0xC4);
#pragma pack(pop) #pragma pack(pop)
enum
{
RCT1_RIDE_TYPE_NULL = 255,
RCT1_RIDE_TYPE_WOODEN_ROLLER_COASTER = 0,
RCT1_RIDE_TYPE_STAND_UP_STEEL_ROLLER_COASTER,
RCT1_RIDE_TYPE_SUSPENDED_ROLLER_COASTER,
RCT1_RIDE_TYPE_INVERTED_ROLLER_COASTER,
RCT1_RIDE_TYPE_STEEL_MINI_ROLLER_COASTER,
RCT1_RIDE_TYPE_MINIATURE_RAILWAY,
RCT1_RIDE_TYPE_MONORAIL,
RCT1_RIDE_TYPE_SUSPENDED_SINGLE_RAIL_ROLLER_COASTER,
RCT1_RIDE_TYPE_BOAT_HIRE,
RCT1_RIDE_TYPE_WOODEN_CRAZY_RODENT_ROLLER_COASTER,
RCT1_RIDE_TYPE_SINGLE_RAIL_ROLLER_COASTER,
RCT1_RIDE_TYPE_CAR_RIDE,
RCT1_RIDE_TYPE_LAUNCHED_FREEFALL,
RCT1_RIDE_TYPE_BOBSLED_ROLLER_COASTER,
RCT1_RIDE_TYPE_OBSERVATION_TOWER,
RCT1_RIDE_TYPE_STEEL_ROLLER_COASTER,
RCT1_RIDE_TYPE_WATER_SLIDE,
RCT1_RIDE_TYPE_MINE_TRAIN_ROLLER_COASTER,
RCT1_RIDE_TYPE_CHAIRLIFT,
RCT1_RIDE_TYPE_STEEL_CORKSCREW_ROLLER_COASTER,
RCT1_RIDE_TYPE_HEDGE_MAZE,
RCT1_RIDE_TYPE_SPIRAL_SLIDE,
RCT1_RIDE_TYPE_GO_KARTS,
RCT1_RIDE_TYPE_LOG_FLUME,
RCT1_RIDE_TYPE_RIVER_RAPIDS,
RCT1_RIDE_TYPE_DODGEMS,
RCT1_RIDE_TYPE_SWINGING_SHIP,
RCT1_RIDE_TYPE_SWINGING_INVERTER_SHIP,
RCT1_RIDE_TYPE_ICE_CREAM_STALL,
RCT1_RIDE_TYPE_CHIPS_STALL,
RCT1_RIDE_TYPE_DRINK_STALL,
RCT1_RIDE_TYPE_CANDYFLOSS_STALL,
RCT1_RIDE_TYPE_BURGER_BAR,
RCT1_RIDE_TYPE_MERRY_GO_ROUND,
RCT1_RIDE_TYPE_BALLOON_STALL,
RCT1_RIDE_TYPE_INFORMATION_KIOSK,
RCT1_RIDE_TYPE_TOILETS,
RCT1_RIDE_TYPE_FERRIS_WHEEL,
RCT1_RIDE_TYPE_MOTION_SIMULATOR,
RCT1_RIDE_TYPE_3D_CINEMA,
RCT1_RIDE_TYPE_TOP_SPIN,
RCT1_RIDE_TYPE_SPACE_RINGS,
RCT1_RIDE_TYPE_REVERSE_FREEFALL_ROLLER_COASTER,
RCT1_RIDE_TYPE_SOUVENIR_STALL,
RCT1_RIDE_TYPE_VERTICAL_ROLLER_COASTER,
RCT1_RIDE_TYPE_PIZZA_STALL,
RCT1_RIDE_TYPE_TWIST,
RCT1_RIDE_TYPE_HAUNTED_HOUSE,
RCT1_RIDE_TYPE_POPCORN_STALL,
RCT1_RIDE_TYPE_CIRCUS,
RCT1_RIDE_TYPE_GHOST_TRAIN,
RCT1_RIDE_TYPE_STEEL_TWISTER_ROLLER_COASTER,
RCT1_RIDE_TYPE_WOODEN_TWISTER_ROLLER_COASTER,
RCT1_RIDE_TYPE_WOODEN_SIDE_FRICTION_ROLLER_COASTER,
RCT1_RIDE_TYPE_STEEL_WILD_MOUSE_ROLLER_COASTER,
RCT1_RIDE_TYPE_HOT_DOG_STALL,
RCT1_RIDE_TYPE_EXOTIC_SEA_FOOD_STALL,
RCT1_RIDE_TYPE_HAT_STALL,
RCT1_RIDE_TYPE_TOFFEE_APPLE_STALL,
RCT1_RIDE_TYPE_VIRGINIA_REEL,
RCT1_RIDE_TYPE_RIVER_RIDE,
RCT1_RIDE_TYPE_CYCLE_MONORAIL,
RCT1_RIDE_TYPE_FLYING_ROLLER_COASTER,
RCT1_RIDE_TYPE_SUSPENDED_MONORAIL,
RCT1_RIDE_TYPE_40,
RCT1_RIDE_TYPE_WOODEN_REVERSER_ROLLER_COASTER,
RCT1_RIDE_TYPE_HEARTLINE_TWISTER_ROLLER_COASTER,
RCT1_RIDE_TYPE_MINIATURE_GOLF,
RCT1_RIDE_TYPE_44,
RCT1_RIDE_TYPE_ROTO_DROP,
RCT1_RIDE_TYPE_FLYING_SAUCERS,
RCT1_RIDE_TYPE_CROOKED_HOUSE,
RCT1_RIDE_TYPE_CYCLE_RAILWAY,
RCT1_RIDE_TYPE_SUSPENDED_LOOPING_ROLLER_COASTER,
RCT1_RIDE_TYPE_WATER_COASTER,
RCT1_RIDE_TYPE_AIR_POWERED_VERTICAL_COASTER,
RCT1_RIDE_TYPE_INVERTED_WILD_MOUSE_COASTER,
RCT1_RIDE_TYPE_JET_SKIS,
RCT1_RIDE_TYPE_T_SHIRT_STALL,
RCT1_RIDE_TYPE_RAFT_RIDE,
RCT1_RIDE_TYPE_DOUGHNUT_SHOP,
RCT1_RIDE_TYPE_ENTERPRISE,
RCT1_RIDE_TYPE_COFFEE_SHOP,
RCT1_RIDE_TYPE_FRIED_CHICKEN_STALL,
RCT1_RIDE_TYPE_LEMONADE_STALL,
RCT1_RIDE_TYPE_COUNT
};
enum enum
{ {
RCT1_VEHICLE_TYPE_STEEL_ROLLER_COASTER_TRAIN = 0, RCT1_VEHICLE_TYPE_STEEL_ROLLER_COASTER_TRAIN = 0,

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

@ -133,7 +133,7 @@ namespace RCT1
EntryList _waterEntry; EntryList _waterEntry;
// Lookup tables for converting from RCT1 hard coded types to the new dynamic object entries // Lookup tables for converting from RCT1 hard coded types to the new dynamic object entries
ObjectEntryIndex _rideTypeToRideEntryMap[RCT1_RIDE_TYPE_COUNT]{}; ObjectEntryIndex _rideTypeToRideEntryMap[EnumValue(RideType::Count)]{};
ObjectEntryIndex _vehicleTypeToRideEntryMap[RCT1_VEHICLE_TYPE_COUNT]{}; ObjectEntryIndex _vehicleTypeToRideEntryMap[RCT1_VEHICLE_TYPE_COUNT]{};
ObjectEntryIndex _smallSceneryTypeToEntryMap[256]{}; ObjectEntryIndex _smallSceneryTypeToEntryMap[256]{};
ObjectEntryIndex _largeSceneryTypeToEntryMap[256]{}; ObjectEntryIndex _largeSceneryTypeToEntryMap[256]{};
@ -144,7 +144,7 @@ namespace RCT1
// Research // Research
std::bitset<MAX_RIDE_OBJECTS> _researchRideEntryUsed{}; std::bitset<MAX_RIDE_OBJECTS> _researchRideEntryUsed{};
std::bitset<RCT1_RIDE_TYPE_COUNT> _researchRideTypeUsed{}; std::bitset<EnumValue(RideType::Count)> _researchRideTypeUsed{};
// Scenario repository - used for determining scenario name // Scenario repository - used for determining scenario name
IScenarioRepository* _scenarioRepository = GetScenarioRepository(); IScenarioRepository* _scenarioRepository = GetScenarioRepository();
@ -425,7 +425,7 @@ namespace RCT1
{ {
size_t researchListCount; size_t researchListCount;
const ResearchItem* researchList = GetResearchList(&researchListCount); const ResearchItem* researchList = GetResearchList(&researchListCount);
std::bitset<RCT1_RIDE_TYPE_COUNT> rideTypeInResearch = GetRideTypesPresentInResearchList( std::bitset<EnumValue(RideType::Count)> rideTypeInResearch = GetRideTypesPresentInResearchList(
researchList, researchListCount); researchList, researchListCount);
for (size_t i = 0; i < researchListCount; i++) for (size_t i = 0; i < researchListCount; i++)
{ {
@ -450,14 +450,14 @@ namespace RCT1
AddEntriesForSceneryTheme(researchItem->item); AddEntriesForSceneryTheme(researchItem->item);
break; break;
case RCT1_RESEARCH_TYPE_RIDE: case RCT1_RESEARCH_TYPE_RIDE:
AddEntryForRideType(researchItem->item); AddEntryForRideType(static_cast<RideType>(researchItem->item));
break; break;
case RCT1_RESEARCH_TYPE_VEHICLE: case RCT1_RESEARCH_TYPE_VEHICLE:
// For some bizarre reason, RCT1 research lists contain vehicles that aren't actually researched. // For some bizarre reason, RCT1 research lists contain vehicles that aren't actually researched.
// Extra bizarrely, this does not seem to apply to Loopy Landscapes saves/scenarios. // Extra bizarrely, this does not seem to apply to Loopy Landscapes saves/scenarios.
if (rideTypeInResearch[researchItem->related_ride] || _gameVersion == FILE_VERSION_RCT1_LL) if (rideTypeInResearch[researchItem->related_ride] || _gameVersion == FILE_VERSION_RCT1_LL)
{ {
AddEntryForVehicleType(researchItem->related_ride, researchItem->item); AddEntryForVehicleType(static_cast<RideType>(researchItem->related_ride), researchItem->item);
} }
break; break;
} }
@ -516,7 +516,7 @@ namespace RCT1
for (size_t i = 0; i < std::size(_s4.rides); i++) for (size_t i = 0; i < std::size(_s4.rides); i++)
{ {
auto ride = &_s4.rides[i]; auto ride = &_s4.rides[i];
if (ride->type != RCT1_RIDE_TYPE_NULL) if (ride->type != RideType::Null)
{ {
if (RCT1::RideTypeUsesVehicles(ride->type)) if (RCT1::RideTypeUsesVehicles(ride->type))
AddEntryForVehicleType(ride->type, ride->vehicle_type); AddEntryForVehicleType(ride->type, ride->vehicle_type);
@ -584,23 +584,25 @@ namespace RCT1
_waterEntry.GetOrAddEntry(entryName); _waterEntry.GetOrAddEntry(entryName);
} }
void AddEntryForRideType(uint8_t rideType) void AddEntryForRideType(RideType rideType)
{ {
assert(rideType < std::size(_rideTypeToRideEntryMap)); Guard::Assert(EnumValue(rideType) < std::size(_rideTypeToRideEntryMap));
if (_rideTypeToRideEntryMap[rideType] == OBJECT_ENTRY_INDEX_NULL)
if (_rideTypeToRideEntryMap[EnumValue(rideType)] == OBJECT_ENTRY_INDEX_NULL)
{ {
const char* entryName = RCT1::GetRideTypeObject(rideType); const char* entryName = RCT1::GetRideTypeObject(rideType);
if (!String::Equals(entryName, " ")) if (!String::Equals(entryName, " "))
{ {
auto entryIndex = _rideEntries.GetOrAddEntry(entryName); auto entryIndex = _rideEntries.GetOrAddEntry(entryName);
_rideTypeToRideEntryMap[rideType] = entryIndex; _rideTypeToRideEntryMap[EnumValue(rideType)] = entryIndex;
} }
} }
} }
void AddEntryForVehicleType(uint8_t rideType, uint8_t vehicleType) void AddEntryForVehicleType(RideType rideType, uint8_t vehicleType)
{ {
assert(vehicleType < std::size(_vehicleTypeToRideEntryMap)); Guard::Assert(EnumValue(rideType) < std::size(_rideTypeToRideEntryMap));
if (_vehicleTypeToRideEntryMap[vehicleType] == OBJECT_ENTRY_INDEX_NULL) if (_vehicleTypeToRideEntryMap[vehicleType] == OBJECT_ENTRY_INDEX_NULL)
{ {
const char* entryName = RCT1::GetVehicleObject(vehicleType); const char* entryName = RCT1::GetVehicleObject(vehicleType);
@ -609,7 +611,7 @@ namespace RCT1
auto entryIndex = _rideEntries.GetOrAddEntry(entryName); auto entryIndex = _rideEntries.GetOrAddEntry(entryName);
_vehicleTypeToRideEntryMap[vehicleType] = entryIndex; _vehicleTypeToRideEntryMap[vehicleType] = entryIndex;
if (rideType != RIDE_TYPE_NULL) if (rideType != RideType::Null)
AddEntryForRideType(rideType); AddEntryForRideType(rideType);
} }
} }
@ -712,7 +714,7 @@ namespace RCT1
{ {
for (int32_t i = 0; i < RCT12_MAX_RIDES_IN_PARK; i++) for (int32_t i = 0; i < RCT12_MAX_RIDES_IN_PARK; i++)
{ {
if (_s4.rides[i].type != RIDE_TYPE_NULL) if (_s4.rides[i].type != RideType::Null)
{ {
ImportRide(GetOrAllocateRide(i), &_s4.rides[i], i); ImportRide(GetOrAllocateRide(i), &_s4.rides[i], i);
} }
@ -725,7 +727,7 @@ namespace RCT1
dst->id = rideIndex; dst->id = rideIndex;
// This is a peculiarity of this exact version number, which only Heide-Park seems to use. // This is a peculiarity of this exact version number, which only Heide-Park seems to use.
if (_s4.game_version == 110018 && src->type == RCT1_RIDE_TYPE_INVERTED_ROLLER_COASTER) if (_s4.game_version == 110018 && src->type == RideType::InvertedRollerCoaster)
{ {
dst->type = RIDE_TYPE_COMPACT_INVERTED_COASTER; dst->type = RIDE_TYPE_COMPACT_INVERTED_COASTER;
} }
@ -740,7 +742,7 @@ namespace RCT1
} }
else else
{ {
dst->subtype = _rideTypeToRideEntryMap[src->type]; dst->subtype = _rideTypeToRideEntryMap[EnumValue(src->type)];
} }
rct_ride_entry* rideEntry = get_ride_entry(dst->subtype); rct_ride_entry* rideEntry = get_ride_entry(dst->subtype);
@ -873,7 +875,7 @@ namespace RCT1
// Only merry-go-round and dodgems had music and used // Only merry-go-round and dodgems had music and used
// the same flag as synchronise stations for the option to enable it // the same flag as synchronise stations for the option to enable it
if (src->type == RCT1_RIDE_TYPE_MERRY_GO_ROUND || src->type == RCT1_RIDE_TYPE_DODGEMS) if (src->type == RideType::MerryGoRound || src->type == RideType::Dodgems)
{ {
if (src->depart_flags & RCT1_RIDE_DEPART_PLAY_MUSIC) if (src->depart_flags & RCT1_RIDE_DEPART_PLAY_MUSIC)
{ {
@ -1005,11 +1007,11 @@ namespace RCT1
dst->track_colour[0].supports = RCT1::GetColour(src->track_support_colour); dst->track_colour[0].supports = RCT1::GetColour(src->track_support_colour);
// Balloons were always blue in the original RCT. // Balloons were always blue in the original RCT.
if (src->type == RCT1_RIDE_TYPE_BALLOON_STALL) if (src->type == RideType::BalloonStall)
{ {
dst->track_colour[0].main = COLOUR_LIGHT_BLUE; dst->track_colour[0].main = COLOUR_LIGHT_BLUE;
} }
else if (src->type == RCT1_RIDE_TYPE_RIVER_RAPIDS) else if (src->type == RideType::RiverRapids)
{ {
dst->track_colour[0].main = COLOUR_WHITE; dst->track_colour[0].main = COLOUR_WHITE;
} }
@ -1871,8 +1873,7 @@ namespace RCT1
} }
bool researched = true; bool researched = true;
std::bitset<RCT1_RIDE_TYPE_COUNT> rideTypeInResearch = GetRideTypesPresentInResearchList( auto rideTypeInResearch = GetRideTypesPresentInResearchList(researchList, researchListCount);
researchList, researchListCount);
std::vector<RCT1::ResearchItem> vehiclesWithMissingRideTypes; std::vector<RCT1::ResearchItem> vehiclesWithMissingRideTypes;
for (size_t i = 0; i < researchListCount; i++) for (size_t i = 0; i < researchListCount; i++)
{ {
@ -1906,10 +1907,10 @@ namespace RCT1
} }
case RCT1_RESEARCH_TYPE_RIDE: case RCT1_RESEARCH_TYPE_RIDE:
{ {
uint8_t rct1RideType = researchItem.item; const auto rct1RideType = static_cast<RideType>(researchItem.item);
_researchRideTypeUsed[rct1RideType] = true; _researchRideTypeUsed[EnumValue(rct1RideType)] = true;
auto ownRideEntryIndex = _rideTypeToRideEntryMap[rct1RideType]; auto ownRideEntryIndex = _rideTypeToRideEntryMap[EnumValue(rct1RideType)];
Guard::Assert( Guard::Assert(
ownRideEntryIndex != OBJECT_ENTRY_INDEX_NULL, "ownRideEntryIndex was OBJECT_ENTRY_INDEX_NULL"); ownRideEntryIndex != OBJECT_ENTRY_INDEX_NULL, "ownRideEntryIndex was OBJECT_ENTRY_INDEX_NULL");
@ -1933,7 +1934,7 @@ namespace RCT1
} }
if (researchItem2.type == RCT1_RESEARCH_TYPE_VEHICLE if (researchItem2.type == RCT1_RESEARCH_TYPE_VEHICLE
&& researchItem2.related_ride == rct1RideType) && static_cast<RideType>(researchItem2.related_ride) == rct1RideType)
{ {
auto rideEntryIndex2 = _vehicleTypeToRideEntryMap[researchItem2.item]; auto rideEntryIndex2 = _vehicleTypeToRideEntryMap[researchItem2.item];
bool isOwnType = (ownRideEntryIndex == rideEntryIndex2); bool isOwnType = (ownRideEntryIndex == rideEntryIndex2);
@ -2051,10 +2052,10 @@ namespace RCT1
} }
} }
static std::bitset<RCT1_RIDE_TYPE_COUNT> GetRideTypesPresentInResearchList( static std::bitset<EnumValue(RideType::Count)> GetRideTypesPresentInResearchList(
const RCT1::ResearchItem* researchList, size_t researchListCount) const RCT1::ResearchItem* researchList, size_t researchListCount)
{ {
std::bitset<RCT1_RIDE_TYPE_COUNT> ret = {}; std::bitset<EnumValue(RideType::Count)> ret = {};
for (size_t i = 0; i < researchListCount; i++) for (size_t i = 0; i < researchListCount; i++)
{ {
@ -2612,7 +2613,7 @@ namespace RCT1
if (researchList[i].type == RCT1_RESEARCH_TYPE_RIDE) if (researchList[i].type == RCT1_RESEARCH_TYPE_RIDE)
{ {
return RCT1::GetRideType(researchList[i].item, 0); return RCT1::GetRideType(static_cast<RideType>(researchList[i].item), 0);
} }
} }

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

@ -122,15 +122,14 @@ namespace RCT1
td->track_support_colour[i] = RCT1::GetColour(td4.track_support_colour_v0); td->track_support_colour[i] = RCT1::GetColour(td4.track_support_colour_v0);
// Mazes were only hedges // Mazes were only hedges
switch (td4.type) if (td4.type == RideType::HedgeMaze)
{ {
case RCT1_RIDE_TYPE_HEDGE_MAZE: td->track_support_colour[i] = MAZE_WALL_TYPE_HEDGE;
td->track_support_colour[i] = MAZE_WALL_TYPE_HEDGE; }
break; else if (td4.type == RideType::RiverRapids)
case RCT1_RIDE_TYPE_RIVER_RAPIDS: {
td->track_spine_colour[i] = COLOUR_WHITE; td->track_spine_colour[i] = COLOUR_WHITE;
td->track_rail_colour[i] = COLOUR_WHITE; td->track_rail_colour[i] = COLOUR_WHITE;
break;
} }
} }
td->flags2 = 0; td->flags2 = 0;
@ -150,7 +149,7 @@ namespace RCT1
// Convert RCT1 vehicle type to RCT2 vehicle type. Initialise with a string consisting of 8 spaces. // Convert RCT1 vehicle type to RCT2 vehicle type. Initialise with a string consisting of 8 spaces.
rct_object_entry vehicleObject = { 0x80, " " }; rct_object_entry vehicleObject = { 0x80, " " };
if (td4Base.type == RIDE_TYPE_MAZE) if (td4Base.type == RideType::HedgeMaze)
{ {
const char* vehObjName = RCT1::GetRideTypeObject(td4Base.type); const char* vehObjName = RCT1::GetRideTypeObject(td4Base.type);
assert(vehObjName != nullptr); assert(vehObjName != nullptr);

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

@ -175,11 +175,11 @@ namespace RCT1
return object_manager_get_loaded_object_entry_index(ObjectEntryDescriptor(selectedEdge)); return object_manager_get_loaded_object_entry_index(ObjectEntryDescriptor(selectedEdge));
} }
uint8_t GetRideType(uint8_t rideType, uint8_t vehicleType) uint8_t GetRideType(RideType rideType, uint8_t vehicleType)
{ {
if (rideType == RCT1_RIDE_TYPE_STEEL_TWISTER_ROLLER_COASTER && vehicleType == RCT1_VEHICLE_TYPE_NON_LOOPING_STEEL_TWISTER_ROLLER_COASTER_TRAIN) if (rideType == RideType::SteelTwisterRollerCoaster && vehicleType == RCT1_VEHICLE_TYPE_NON_LOOPING_STEEL_TWISTER_ROLLER_COASTER_TRAIN)
return RIDE_TYPE_HYPER_TWISTER; return RIDE_TYPE_HYPER_TWISTER;
if (rideType == RCT1_RIDE_TYPE_STEEL_CORKSCREW_ROLLER_COASTER && vehicleType == RCT1_VEHICLE_TYPE_HYPERCOASTER_TRAIN) if (rideType == RideType::SteelCorkscrewRollerCoaster && vehicleType == RCT1_VEHICLE_TYPE_HYPERCOASTER_TRAIN)
return RIDE_TYPE_HYPERCOASTER; return RIDE_TYPE_HYPERCOASTER;
static uint8_t map[] = static uint8_t map[] =
@ -271,8 +271,10 @@ namespace RCT1
RIDE_TYPE_DRINK_STALL, // RCT1_RIDE_TYPE_LEMONADE_STALL RIDE_TYPE_DRINK_STALL, // RCT1_RIDE_TYPE_LEMONADE_STALL
}; };
Guard::ArgumentInRange<size_t>(rideType, 0, std::size(map), "Unsupported RCT1 ride type."); const auto index = EnumValue(rideType);
return map[rideType]; Guard::ArgumentInRange<size_t>(index, 0, std::size(map), "Unsupported RCT1 ride type.");
return map[index];
} }
VehicleColourSchemeCopyDescriptor GetColourSchemeCopyDescriptor(uint8_t vehicleType) VehicleColourSchemeCopyDescriptor GetColourSchemeCopyDescriptor(uint8_t vehicleType)
@ -374,33 +376,33 @@ namespace RCT1
return map[vehicleType]; return map[vehicleType];
} }
bool RideTypeUsesVehicles(uint8_t rideType) bool RideTypeUsesVehicles(RideType rideType)
{ {
switch (rideType) { switch (rideType) {
case RCT1_RIDE_TYPE_HEDGE_MAZE: case RideType::HedgeMaze:
case RCT1_RIDE_TYPE_SPIRAL_SLIDE: case RideType::SpiralSlide:
case RCT1_RIDE_TYPE_ICE_CREAM_STALL: case RideType::IceCreamStall:
case RCT1_RIDE_TYPE_CHIPS_STALL: case RideType::ChipsStall:
case RCT1_RIDE_TYPE_DRINK_STALL: case RideType::DrinkStall:
case RCT1_RIDE_TYPE_CANDYFLOSS_STALL: case RideType::CandyflossStall:
case RCT1_RIDE_TYPE_BURGER_BAR: case RideType::BurgerBar:
case RCT1_RIDE_TYPE_BALLOON_STALL: case RideType::BalloonStall:
case RCT1_RIDE_TYPE_INFORMATION_KIOSK: case RideType::InformationKiosk:
case RCT1_RIDE_TYPE_TOILETS: case RideType::Toilets:
case RCT1_RIDE_TYPE_SOUVENIR_STALL: case RideType::SouvenirStall:
case RCT1_RIDE_TYPE_PIZZA_STALL: case RideType::PizzaStall:
case RCT1_RIDE_TYPE_POPCORN_STALL: case RideType::PopcornStall:
case RCT1_RIDE_TYPE_HOT_DOG_STALL: case RideType::HotDogStall:
case RCT1_RIDE_TYPE_EXOTIC_SEA_FOOD_STALL: case RideType::ExoticSeaFoodStall:
case RCT1_RIDE_TYPE_HAT_STALL: case RideType::HatStall:
case RCT1_RIDE_TYPE_TOFFEE_APPLE_STALL: case RideType::ToffeeAppleStall:
case RCT1_RIDE_TYPE_40: case RideType::_40:
case RCT1_RIDE_TYPE_44: case RideType::_44:
case RCT1_RIDE_TYPE_T_SHIRT_STALL: case RideType::TShirtStall:
case RCT1_RIDE_TYPE_DOUGHNUT_SHOP: case RideType::DoughnutShop:
case RCT1_RIDE_TYPE_COFFEE_SHOP: case RideType::CoffeeShop:
case RCT1_RIDE_TYPE_FRIED_CHICKEN_STALL: case RideType::FriedChickenStall:
case RCT1_RIDE_TYPE_LEMONADE_STALL: case RideType::LemonadeStall:
return false; return false;
default: default:
return true; return true;
@ -696,7 +698,7 @@ namespace RCT1
return map[vehicleSubEntry]; return map[vehicleSubEntry];
} }
const char * GetRideTypeObject(uint8_t rideType) const char * GetRideTypeObject(RideType rideType)
{ {
static constexpr const char * map[] = static constexpr const char * map[] =
{ {
@ -787,8 +789,10 @@ namespace RCT1
"LEMST ", // RCT1_RIDE_TYPE_LEMONADE_STALL "LEMST ", // RCT1_RIDE_TYPE_LEMONADE_STALL
}; };
Guard::ArgumentInRange<size_t>(rideType, 0, std::size(map), "Unsupported RCT1 ride type."); const auto index = EnumValue(rideType);
return map[rideType]; Guard::ArgumentInRange<size_t>(index, 0, std::size(map), "Unsupported RCT1 ride type.");
return map[index];
} }
const char * GetVehicleObject(uint8_t vehicleType) const char * GetVehicleObject(uint8_t vehicleType)

8
src/openrct2/rct1/Tables.h
View File

@ -21,19 +21,21 @@ namespace RCT1
int8_t colour1, colour2, colour3; int8_t colour1, colour2, colour3;
}; };
enum class RideType : uint8_t;
colour_t GetColour(colour_t colour); colour_t GetColour(colour_t colour);
PeepSpriteType GetPeepSpriteType(uint8_t rct1SpriteType); PeepSpriteType GetPeepSpriteType(uint8_t rct1SpriteType);
ObjectEntryIndex GetTerrain(uint8_t terrain); ObjectEntryIndex GetTerrain(uint8_t terrain);
ObjectEntryIndex GetTerrainEdge(uint8_t terrainEdge); ObjectEntryIndex GetTerrainEdge(uint8_t terrainEdge);
uint8_t GetRideType(uint8_t rideType, uint8_t vehicleType); uint8_t GetRideType(RideType rideType, uint8_t vehicleType);
VehicleColourSchemeCopyDescriptor GetColourSchemeCopyDescriptor(uint8_t vehicleType); VehicleColourSchemeCopyDescriptor GetColourSchemeCopyDescriptor(uint8_t vehicleType);
bool RideTypeUsesVehicles(uint8_t rideType); bool RideTypeUsesVehicles(RideType rideType);
bool PathIsQueue(uint8_t pathType); bool PathIsQueue(uint8_t pathType);
uint8_t NormalisePathAddition(uint8_t pathAdditionType); uint8_t NormalisePathAddition(uint8_t pathAdditionType);
uint8_t GetVehicleSubEntryIndex(uint8_t vehicleSubEntry); uint8_t GetVehicleSubEntryIndex(uint8_t vehicleSubEntry);
const char* GetRideTypeObject(uint8_t rideType); const char* GetRideTypeObject(RideType rideType);
const char* GetVehicleObject(uint8_t vehicleType); const char* GetVehicleObject(uint8_t vehicleType);
const char* GetSmallSceneryObject(uint8_t smallSceneryType); const char* GetSmallSceneryObject(uint8_t smallSceneryType);
const char* GetLargeSceneryObject(uint8_t largeSceneryType); const char* GetLargeSceneryObject(uint8_t largeSceneryType);