mirrors/OpenRCT2
1
0
Fork 0
mirror of https://github.com/OpenRCT2/OpenRCT2 synced 2026-01-25 15:54:31 +01:00
Code Issues Releases Wiki Activity

Use “car” instead of the ambiguous “vehicle”, part 1

Browse Source 
Currently, the word “vehicle” is used for both “train” and “car”. This is a first effort towards disambiguation.
This commit is contained in:
Michael Steenbeek
2022-06-07 22:36:20 +02:00
committed by GitHub
parent 7cc2b02b7c
commit 3fae2413db
45 changed files with 595 additions and 697 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -81,20 +81,20 @@ void RideObject::ReadLegacy(IReadObjectContext* context, IStream* stream)
_legacyType.max_cars_in_train = stream->ReadValue<uint8_t>();
_legacyType.cars_per_flat_ride = stream->ReadValue<uint8_t>();
_legacyType.zero_cars = stream->ReadValue<uint8_t>();
_legacyType.tab_vehicle = stream->ReadValue<uint8_t>();
_legacyType.default_vehicle = stream->ReadValue<uint8_t>();
_legacyType.front_vehicle = stream->ReadValue<uint8_t>();
_legacyType.second_vehicle = stream->ReadValue<uint8_t>();
_legacyType.rear_vehicle = stream->ReadValue<uint8_t>();
_legacyType.third_vehicle = stream->ReadValue<uint8_t>();
_legacyType.TabCar = stream->ReadValue<uint8_t>();
_legacyType.DefaultCar = stream->ReadValue<uint8_t>();
_legacyType.FrontCar = stream->ReadValue<uint8_t>();
_legacyType.SecondCar = stream->ReadValue<uint8_t>();
_legacyType.RearCar = stream->ReadValue<uint8_t>();
_legacyType.ThirdCar = stream->ReadValue<uint8_t>();
_legacyType.BuildMenuPriority = 0;
// Skip pad_019
stream->Seek(1, STREAM_SEEK_CURRENT);
for (auto& vehicleEntry : _legacyType.vehicles)
for (auto& carEntry : _legacyType.Cars)
{
ReadLegacyVehicle(context, stream, &vehicleEntry);
ReadLegacyCar(context, stream, &carEntry);
}
stream->Seek(4, STREAM_SEEK_CURRENT);
_legacyType.excitement_multiplier = stream->ReadValue<int8_t>();
@@ -140,7 +140,7 @@ void RideObject::ReadLegacy(IReadObjectContext* context, IStream* stream)
}
// Read peep loading positions
for (int32_t i = 0; i < RCT2::ObjectLimits::MaxVehiclesPerRideEntry; i++)
for (int32_t i = 0; i < RCT2::ObjectLimits::MaxCarTypesPerRideEntry; i++)
{
_peepLoadingWaypoints[i].clear();
_peepLoadingPositions[i].clear();
@@ -151,12 +151,12 @@ void RideObject::ReadLegacy(IReadObjectContext* context, IStream* stream)
numPeepLoadingPositions = stream->ReadValue<uint16_t>();
}
if (_legacyType.vehicles[i].flags & VEHICLE_ENTRY_FLAG_LOADING_WAYPOINTS)
if (_legacyType.Cars[i].flags & CAR_ENTRY_FLAG_LOADING_WAYPOINTS)
{
_legacyType.vehicles[i].peep_loading_waypoint_segments = stream->ReadValue<int8_t>() == 0 ? 0 : 4;
_legacyType.Cars[i].peep_loading_waypoint_segments = stream->ReadValue<int8_t>() == 0 ? 0 : 4;
if (_legacyType.ride_type[0] == RIDE_TYPE_ENTERPRISE)
{
_legacyType.vehicles[i].peep_loading_waypoint_segments = 8;
_legacyType.Cars[i].peep_loading_waypoint_segments = 8;
}
Guard::Assert(((numPeepLoadingPositions - 1) % 8) == 0, "Malformed peep loading positions");
@@ -177,7 +177,7 @@ void RideObject::ReadLegacy(IReadObjectContext* context, IStream* stream)
}
else
{
_legacyType.vehicles[i].peep_loading_waypoint_segments = 0;
_legacyType.Cars[i].peep_loading_waypoint_segments = 0;
auto data = stream->ReadArray<int8_t>(numPeepLoadingPositions);
_peepLoadingPositions[i] = std::vector<int8_t>(data.get(), data.get() + numPeepLoadingPositions);
@@ -213,64 +213,62 @@ void RideObject::Load()
_legacyType.images_offset = gfx_object_allocate_images(GetImageTable().GetImages(), GetImageTable().GetCount());
_legacyType.vehicle_preset_list = &_presetColours;
int32_t cur_vehicle_images_offset = _legacyType.images_offset + RCT2::ObjectLimits::MaxRideTypesPerRideEntry;
for (int32_t i = 0; i < RCT2::ObjectLimits::MaxVehiclesPerRideEntry; i++)
int32_t currentCarImagesOffset = _legacyType.images_offset + RCT2::ObjectLimits::MaxRideTypesPerRideEntry;
for (int32_t i = 0; i < RCT2::ObjectLimits::MaxCarTypesPerRideEntry; i++)
{
rct_ride_entry_vehicle* vehicleEntry = &_legacyType.vehicles[i];
if (vehicleEntry->GroupEnabled(SpriteGroupType::SlopeFlat))
CarEntry* carEntry = &_legacyType.Cars[i];
if (carEntry->GroupEnabled(SpriteGroupType::SlopeFlat))
{
// RCT2 calculates num_vertical_frames and num_horizontal_frames and overwrites these properties on the vehicle
// RCT2 calculates num_vertical_frames and num_horizontal_frames and overwrites these properties on the car
// entry. Immediately afterwards, the two were multiplied in order to calculate base_num_frames and were never used
// again. This has been changed to use the calculation results directly - num_vertical_frames and
// num_horizontal_frames are no longer set on the vehicle entry.
// num_horizontal_frames are no longer set on the car entry.
// 0x6DE946
vehicleEntry->base_num_frames = CalculateNumVerticalFrames(vehicleEntry)
* CalculateNumHorizontalFrames(vehicleEntry);
uint32_t baseImageId = cur_vehicle_images_offset;
carEntry->base_num_frames = CalculateNumVerticalFrames(carEntry) * CalculateNumHorizontalFrames(carEntry);
uint32_t baseImageId = currentCarImagesOffset;
uint32_t imageIndex = baseImageId;
vehicleEntry->base_image_id = baseImageId;
carEntry->base_image_id = baseImageId;
for (uint8_t spriteGroup = 0; spriteGroup < EnumValue(SpriteGroupType::Count); spriteGroup++)
{
if (vehicleEntry->SpriteGroups[spriteGroup].Enabled())
if (carEntry->SpriteGroups[spriteGroup].Enabled())
{
vehicleEntry->SpriteGroups[spriteGroup].imageId = imageIndex;
const auto spriteCount = vehicleEntry->base_num_frames
* vehicleEntry->NumRotationSprites(static_cast<SpriteGroupType>(spriteGroup))
carEntry->SpriteGroups[spriteGroup].imageId = imageIndex;
const auto spriteCount = carEntry->base_num_frames
* carEntry->NumRotationSprites(static_cast<SpriteGroupType>(spriteGroup))
* SpriteGroupMultiplier[spriteGroup];
imageIndex += spriteCount;
}
}
// No vehicle images
vehicleEntry->no_vehicle_images = imageIndex - cur_vehicle_images_offset;
carEntry->NumCarImages = imageIndex - currentCarImagesOffset;
// Move the offset over this vehicles images. Including peeps
cur_vehicle_images_offset = imageIndex + vehicleEntry->no_seating_rows * vehicleEntry->no_vehicle_images;
// Move the offset over this car’s images. Including peeps
currentCarImagesOffset = imageIndex + carEntry->no_seating_rows * carEntry->NumCarImages;
// 0x6DEB0D
if (!(vehicleEntry->flags & VEHICLE_ENTRY_FLAG_RECALCULATE_SPRITE_BOUNDS))
if (!(carEntry->flags & CAR_ENTRY_FLAG_RECALCULATE_SPRITE_BOUNDS))
{
int32_t num_images = cur_vehicle_images_offset - baseImageId;
if (vehicleEntry->flags & VEHICLE_ENTRY_FLAG_SPRITE_BOUNDS_INCLUDE_INVERTED_SET)
int32_t num_images = currentCarImagesOffset - baseImageId;
if (carEntry->flags & CAR_ENTRY_FLAG_SPRITE_BOUNDS_INCLUDE_INVERTED_SET)
{
num_images *= 2;
}
if (!gOpenRCT2NoGraphics)
{
set_vehicle_type_image_max_sizes(vehicleEntry, num_images);
set_vehicle_type_image_max_sizes(carEntry, num_images);
}
}
if (!_peepLoadingPositions[i].empty())
{
vehicleEntry->peep_loading_positions = std::move(_peepLoadingPositions[i]);
carEntry->peep_loading_positions = std::move(_peepLoadingPositions[i]);
}
if (!_peepLoadingWaypoints[i].empty())
{
vehicleEntry->peep_loading_waypoints = std::move(_peepLoadingWaypoints[i]);
carEntry->peep_loading_waypoints = std::move(_peepLoadingWaypoints[i]);
}
}
}
@@ -343,56 +341,55 @@ void RideObject::SetRepositoryItem(ObjectRepositoryItem* item) const
item->RideInfo.RideFlags = 0;
}
void RideObject::ReadLegacyVehicle(
[[maybe_unused]] IReadObjectContext* context, IStream* stream, rct_ride_entry_vehicle* vehicle)
void RideObject::ReadLegacyCar([[maybe_unused]] IReadObjectContext* context, IStream* stream, CarEntry* car)
{
vehicle->TabRotationMask = stream->ReadValue<uint16_t>();
car->TabRotationMask = stream->ReadValue<uint16_t>();
stream->Seek(2 * 1, STREAM_SEEK_CURRENT);
vehicle->spacing = stream->ReadValue<uint32_t>();
vehicle->car_mass = stream->ReadValue<uint16_t>();
vehicle->tab_height = stream->ReadValue<int8_t>();
vehicle->num_seats = stream->ReadValue<uint8_t>();
car->spacing = stream->ReadValue<uint32_t>();
car->car_mass = stream->ReadValue<uint16_t>();
car->tab_height = stream->ReadValue<int8_t>();
car->num_seats = stream->ReadValue<uint8_t>();
uint16_t spriteGroups = stream->ReadValue<uint16_t>();
vehicle->sprite_width = stream->ReadValue<uint8_t>();
vehicle->sprite_height_negative = stream->ReadValue<uint8_t>();
vehicle->sprite_height_positive = stream->ReadValue<uint8_t>();
vehicle->animation = stream->ReadValue<uint8_t>();
vehicle->flags = stream->ReadValue<uint32_t>();
vehicle->base_num_frames = stream->ReadValue<uint16_t>();
car->sprite_width = stream->ReadValue<uint8_t>();
car->sprite_height_negative = stream->ReadValue<uint8_t>();
car->sprite_height_positive = stream->ReadValue<uint8_t>();
car->animation = stream->ReadValue<uint8_t>();
car->flags = stream->ReadValue<uint32_t>();
car->base_num_frames = stream->ReadValue<uint16_t>();
stream->Seek(15 * 4, STREAM_SEEK_CURRENT);
vehicle->no_seating_rows = stream->ReadValue<uint8_t>();
vehicle->spinning_inertia = stream->ReadValue<uint8_t>();
vehicle->spinning_friction = stream->ReadValue<uint8_t>();
vehicle->friction_sound_id = stream->ReadValue<OpenRCT2::Audio::SoundId>();
vehicle->log_flume_reverser_vehicle_type = stream->ReadValue<uint8_t>();
vehicle->sound_range = stream->ReadValue<uint8_t>();
vehicle->double_sound_frequency = stream->ReadValue<uint8_t>();
vehicle->powered_acceleration = stream->ReadValue<uint8_t>();
vehicle->powered_max_speed = stream->ReadValue<uint8_t>();
vehicle->PaintStyle = stream->ReadValue<uint8_t>();
vehicle->effect_visual = stream->ReadValue<uint8_t>();
vehicle->draw_order = stream->ReadValue<uint8_t>();
vehicle->num_vertical_frames_override = stream->ReadValue<uint8_t>();
car->no_seating_rows = stream->ReadValue<uint8_t>();
car->spinning_inertia = stream->ReadValue<uint8_t>();
car->spinning_friction = stream->ReadValue<uint8_t>();
car->friction_sound_id = stream->ReadValue<OpenRCT2::Audio::SoundId>();
car->ReversedCarIndex = stream->ReadValue<uint8_t>();
car->sound_range = stream->ReadValue<uint8_t>();
car->double_sound_frequency = stream->ReadValue<uint8_t>();
car->powered_acceleration = stream->ReadValue<uint8_t>();
car->powered_max_speed = stream->ReadValue<uint8_t>();
car->PaintStyle = stream->ReadValue<uint8_t>();
car->effect_visual = stream->ReadValue<uint8_t>();
car->draw_order = stream->ReadValue<uint8_t>();
car->num_vertical_frames_override = stream->ReadValue<uint8_t>();
stream->Seek(4, STREAM_SEEK_CURRENT);
ReadLegacySpriteGroups(vehicle, spriteGroups);
ReadLegacySpriteGroups(car, spriteGroups);
}
uint8_t RideObject::CalculateNumVerticalFrames(const rct_ride_entry_vehicle* vehicleEntry)
uint8_t RideObject::CalculateNumVerticalFrames(const CarEntry* vehicleEntry)
{
// 0x6DE90B
uint8_t numVerticalFrames;
if (vehicleEntry->flags & VEHICLE_ENTRY_FLAG_OVERRIDE_NUM_VERTICAL_FRAMES)
if (vehicleEntry->flags & CAR_ENTRY_FLAG_OVERRIDE_NUM_VERTICAL_FRAMES)
{
numVerticalFrames = vehicleEntry->num_vertical_frames_override;
}
else
{
if (!(vehicleEntry->flags & VEHICLE_ENTRY_FLAG_SPINNING_ADDITIONAL_FRAMES))
if (!(vehicleEntry->flags & CAR_ENTRY_FLAG_SPINNING_ADDITIONAL_FRAMES))
{
if (vehicleEntry->flags & VEHICLE_ENTRY_FLAG_VEHICLE_ANIMATION
if (vehicleEntry->flags & CAR_ENTRY_FLAG_VEHICLE_ANIMATION
&& vehicleEntry->animation != VEHICLE_ENTRY_ANIMATION_OBSERVATION_TOWER)
{
if (!(vehicleEntry->flags & VEHICLE_ENTRY_FLAG_DODGEM_INUSE_LIGHTS))
if (!(vehicleEntry->flags & CAR_ENTRY_FLAG_DODGEM_INUSE_LIGHTS))
{
numVerticalFrames = 4;
}
@@ -415,15 +412,14 @@ uint8_t RideObject::CalculateNumVerticalFrames(const rct_ride_entry_vehicle* veh
return numVerticalFrames;
}
uint8_t RideObject::CalculateNumHorizontalFrames(const rct_ride_entry_vehicle* vehicleEntry)
uint8_t RideObject::CalculateNumHorizontalFrames(const CarEntry* vehicleEntry)
{
uint8_t numHorizontalFrames;
if (vehicleEntry->flags & VEHICLE_ENTRY_FLAG_SWINGING)
if (vehicleEntry->flags & CAR_ENTRY_FLAG_SWINGING)
{
if (!(vehicleEntry->flags & VEHICLE_ENTRY_FLAG_SUSPENDED_SWING)
&& !(vehicleEntry->flags & VEHICLE_ENTRY_FLAG_SLIDE_SWING))
if (!(vehicleEntry->flags & CAR_ENTRY_FLAG_SUSPENDED_SWING) && !(vehicleEntry->flags & CAR_ENTRY_FLAG_SLIDE_SWING))
{
if (vehicleEntry->flags & VEHICLE_ENTRY_FLAG_WOODEN_WILD_MOUSE_SWING)
if (vehicleEntry->flags & CAR_ENTRY_FLAG_WOODEN_WILD_MOUSE_SWING)
{
numHorizontalFrames = 3;
}
@@ -432,9 +428,7 @@ uint8_t RideObject::CalculateNumHorizontalFrames(const rct_ride_entry_vehicle* v
numHorizontalFrames = 5;
}
}
else if (
!(vehicleEntry->flags & VEHICLE_ENTRY_FLAG_SUSPENDED_SWING)
|| !(vehicleEntry->flags & VEHICLE_ENTRY_FLAG_SLIDE_SWING))
else if (!(vehicleEntry->flags & CAR_ENTRY_FLAG_SUSPENDED_SWING) || !(vehicleEntry->flags & CAR_ENTRY_FLAG_SLIDE_SWING))
{
numHorizontalFrames = 7;
}
@@ -494,13 +488,13 @@ void RideObject::ReadJson(IReadObjectContext* context, json_t& root)
if (IsRideTypeShopOrFacility(_legacyType.ride_type[0]))
{
// Standard car info for a shop
auto& car = _legacyType.vehicles[0];
auto& car = _legacyType.Cars[0];
car.spacing = 544;
car.SpriteGroups[EnumValue(SpriteGroupType::SlopeFlat)].spritePrecision = SpritePrecision::Sprites4;
car.sprite_width = 1;
car.sprite_height_negative = 1;
car.sprite_height_positive = 1;
car.flags = VEHICLE_ENTRY_FLAG_SPINNING;
car.flags = CAR_ENTRY_FLAG_SPINNING;
car.PaintStyle = VEHICLE_VISUAL_FLAT_RIDE_OR_CAR_RIDE;
car.friction_sound_id = OpenRCT2::Audio::SoundId::Null;
car.sound_range = 0xFF;
@@ -588,8 +582,8 @@ void RideObject::ReadJsonVehicleInfo([[maybe_unused]] IReadObjectContext* contex
_legacyType.zero_cars = Json::GetNumber<uint8_t>(properties["numEmptyCars"]);
// Train formation from car indices
_legacyType.default_vehicle = Json::GetNumber<uint8_t>(properties["defaultCar"]);
_legacyType.tab_vehicle = Json::GetNumber<uint8_t>(properties["tabCar"]);
_legacyType.DefaultCar = Json::GetNumber<uint8_t>(properties["defaultCar"]);
_legacyType.TabCar = Json::GetNumber<uint8_t>(properties["tabCar"]);
float tabScale = Json::GetNumber<float>(properties["tabScale"]);
if (tabScale != 0 && tabScale <= 0.5f)
@@ -601,22 +595,22 @@ void RideObject::ReadJsonVehicleInfo([[maybe_unused]] IReadObjectContext* contex
json_t tailCars = Json::AsArray(properties["tailCars"]);
// 0xFF means N/A.
_legacyType.front_vehicle = Json::GetNumber<uint8_t>(headCars[0], 0xFF);
_legacyType.second_vehicle = Json::GetNumber<uint8_t>(headCars[1], 0xFF);
_legacyType.third_vehicle = Json::GetNumber<uint8_t>(headCars[2], 0xFF);
_legacyType.rear_vehicle = Json::GetNumber<uint8_t>(tailCars[0], 0xFF);
_legacyType.FrontCar = Json::GetNumber<uint8_t>(headCars[0], 0xFF);
_legacyType.SecondCar = Json::GetNumber<uint8_t>(headCars[1], 0xFF);
_legacyType.ThirdCar = Json::GetNumber<uint8_t>(headCars[2], 0xFF);
_legacyType.RearCar = Json::GetNumber<uint8_t>(tailCars[0], 0xFF);
auto cars = ReadJsonCars(context, properties["cars"]);
auto numCars = std::min(std::size(_legacyType.vehicles), cars.size());
auto numCars = std::min(std::size(_legacyType.Cars), cars.size());
for (size_t i = 0; i < numCars; i++)
{
_legacyType.vehicles[i] = cars[i];
_legacyType.Cars[i] = cars[i];
}
}
std::vector<rct_ride_entry_vehicle> RideObject::ReadJsonCars([[maybe_unused]] IReadObjectContext* context, json_t& jCars)
std::vector<CarEntry> RideObject::ReadJsonCars([[maybe_unused]] IReadObjectContext* context, json_t& jCars)
{
std::vector<rct_ride_entry_vehicle> cars;
std::vector<CarEntry> cars;
if (jCars.is_array())
{
@@ -636,11 +630,11 @@ std::vector<rct_ride_entry_vehicle> RideObject::ReadJsonCars([[maybe_unused]] IR
return cars;
}
rct_ride_entry_vehicle RideObject::ReadJsonCar([[maybe_unused]] IReadObjectContext* context, json_t& jCar)
CarEntry RideObject::ReadJsonCar([[maybe_unused]] IReadObjectContext* context, json_t& jCar)
{
Guard::Assert(jCar.is_object(), "RideObject::ReadJsonCar expects parameter jCar to be object");
rct_ride_entry_vehicle car = {};
CarEntry car = {};
car.TabRotationMask = Json::GetNumber<uint16_t>(jCar["rotationFrameMask"]);
car.spacing = Json::GetNumber<uint32_t>(jCar["spacing"]);
car.car_mass = Json::GetNumber<uint16_t>(jCar["mass"]);
@@ -656,12 +650,12 @@ rct_ride_entry_vehicle RideObject::ReadJsonCar([[maybe_unused]] IReadObjectConte
car.sprite_height_positive = Json::GetNumber<uint8_t>(jCar["spriteHeightPositive"]);
car.animation = Json::GetNumber<uint8_t>(jCar["animation"]);
car.base_num_frames = Json::GetNumber<uint16_t>(jCar["baseNumFrames"]);
car.no_vehicle_images = Json::GetNumber<uint32_t>(jCar["numImages"]);
car.NumCarImages = Json::GetNumber<uint32_t>(jCar["numImages"]);
car.no_seating_rows = Json::GetNumber<uint8_t>(jCar["numSeatRows"]);
car.spinning_inertia = Json::GetNumber<uint8_t>(jCar["spinningInertia"]);
car.spinning_friction = Json::GetNumber<uint8_t>(jCar["spinningFriction"]);
car.friction_sound_id = Json::GetEnum<OpenRCT2::Audio::SoundId>(jCar["frictionSoundId"], OpenRCT2::Audio::SoundId::Null);
car.log_flume_reverser_vehicle_type = Json::GetNumber<uint8_t>(jCar["logFlumeReverserVehicleType"]);
car.ReversedCarIndex = Json::GetNumber<uint8_t>(jCar["logFlumeReverserVehicleType"]);
car.sound_range = Json::GetNumber<uint8_t>(jCar["soundRange"], 255);
car.double_sound_frequency = Json::GetNumber<uint8_t>(jCar["doubleSoundFrequency"]);
car.powered_acceleration = Json::GetNumber<uint8_t>(jCar["poweredAcceleration"]);
@@ -684,7 +678,7 @@ rct_ride_entry_vehicle RideObject::ReadJsonCar([[maybe_unused]] IReadObjectConte
auto jLoadingWaypoints = jCar["loadingWaypoints"];
if (jLoadingWaypoints.is_array())
{
car.flags |= VEHICLE_ENTRY_FLAG_LOADING_WAYPOINTS;
car.flags |= CAR_ENTRY_FLAG_LOADING_WAYPOINTS;
car.peep_loading_waypoint_segments = Json::GetNumber<uint8_t>(jCar["numSegments"]);
for (auto& jRoute : jLoadingWaypoints)
@@ -713,68 +707,68 @@ rct_ride_entry_vehicle RideObject::ReadJsonCar([[maybe_unused]] IReadObjectConte
car.flags |= Json::GetFlags<uint32_t>(
jCar,
{
{ "isPoweredRideWithUnrestrictedGravity", VEHICLE_ENTRY_FLAG_POWERED_RIDE_UNRESTRICTED_GRAVITY },
{ "hasNoUpstopWheels", VEHICLE_ENTRY_FLAG_NO_UPSTOP_WHEELS },
{ "hasNoUpstopWheelsBobsleigh", VEHICLE_ENTRY_FLAG_NO_UPSTOP_BOBSLEIGH },
{ "isMiniGolf", VEHICLE_ENTRY_FLAG_MINI_GOLF },
{ "isReverserBogie", VEHICLE_ENTRY_FLAG_REVERSER_BOGIE },
{ "isReverserPassengerCar", VEHICLE_ENTRY_FLAG_REVERSER_PASSENGER_CAR },
{ "hasInvertedSpriteSet", VEHICLE_ENTRY_FLAG_HAS_INVERTED_SPRITE_SET },
{ "hasDodgemInUseLights", VEHICLE_ENTRY_FLAG_DODGEM_INUSE_LIGHTS },
{ "hasAdditionalColour2", VEHICLE_ENTRY_FLAG_ENABLE_TERNARY_COLOUR },
{ "recalculateSpriteBounds", VEHICLE_ENTRY_FLAG_RECALCULATE_SPRITE_BOUNDS },
{ "overrideNumberOfVerticalFrames", VEHICLE_ENTRY_FLAG_OVERRIDE_NUM_VERTICAL_FRAMES },
{ "spriteBoundsIncludeInvertedSet", VEHICLE_ENTRY_FLAG_SPRITE_BOUNDS_INCLUDE_INVERTED_SET },
{ "hasAdditionalSpinningFrames", VEHICLE_ENTRY_FLAG_SPINNING_ADDITIONAL_FRAMES },
{ "isLift", VEHICLE_ENTRY_FLAG_LIFT },
{ "hasAdditionalColour1", VEHICLE_ENTRY_FLAG_ENABLE_TRIM_COLOUR },
{ "hasSwinging", VEHICLE_ENTRY_FLAG_SWINGING },
{ "hasSpinning", VEHICLE_ENTRY_FLAG_SPINNING },
{ "isPowered", VEHICLE_ENTRY_FLAG_POWERED },
{ "hasScreamingRiders", VEHICLE_ENTRY_FLAG_RIDERS_SCREAM },
{ "useSuspendedSwing", VEHICLE_ENTRY_FLAG_SUSPENDED_SWING },
{ "useBoatHireCollisionDetection", VEHICLE_ENTRY_FLAG_BOAT_HIRE_COLLISION_DETECTION },
{ "hasVehicleAnimation", VEHICLE_ENTRY_FLAG_VEHICLE_ANIMATION },
{ "hasRiderAnimation", VEHICLE_ENTRY_FLAG_RIDER_ANIMATION },
{ "useWoodenWildMouseSwing", VEHICLE_ENTRY_FLAG_WOODEN_WILD_MOUSE_SWING },
{ "useSlideSwing", VEHICLE_ENTRY_FLAG_SLIDE_SWING },
{ "isChairlift", VEHICLE_ENTRY_FLAG_CHAIRLIFT },
{ "isWaterRide", VEHICLE_ENTRY_FLAG_WATER_RIDE },
{ "isGoKart", VEHICLE_ENTRY_FLAG_GO_KART },
{ "useDodgemCarPlacement", VEHICLE_ENTRY_FLAG_DODGEM_CAR_PLACEMENT },
{ "isPoweredRideWithUnrestrictedGravity", CAR_ENTRY_FLAG_POWERED_RIDE_UNRESTRICTED_GRAVITY },
{ "hasNoUpstopWheels", CAR_ENTRY_FLAG_NO_UPSTOP_WHEELS },
{ "hasNoUpstopWheelsBobsleigh", CAR_ENTRY_FLAG_NO_UPSTOP_BOBSLEIGH },
{ "isMiniGolf", CAR_ENTRY_FLAG_MINI_GOLF },
{ "isReverserBogie", CAR_ENTRY_FLAG_REVERSER_BOGIE },
{ "isReverserPassengerCar", CAR_ENTRY_FLAG_REVERSER_PASSENGER_CAR },
{ "hasInvertedSpriteSet", CAR_ENTRY_FLAG_HAS_INVERTED_SPRITE_SET },
{ "hasDodgemInUseLights", CAR_ENTRY_FLAG_DODGEM_INUSE_LIGHTS },
{ "hasAdditionalColour2", CAR_ENTRY_FLAG_ENABLE_TERNARY_COLOUR },
{ "recalculateSpriteBounds", CAR_ENTRY_FLAG_RECALCULATE_SPRITE_BOUNDS },
{ "overrideNumberOfVerticalFrames", CAR_ENTRY_FLAG_OVERRIDE_NUM_VERTICAL_FRAMES },
{ "spriteBoundsIncludeInvertedSet", CAR_ENTRY_FLAG_SPRITE_BOUNDS_INCLUDE_INVERTED_SET },
{ "hasAdditionalSpinningFrames", CAR_ENTRY_FLAG_SPINNING_ADDITIONAL_FRAMES },
{ "isLift", CAR_ENTRY_FLAG_LIFT },
{ "hasAdditionalColour1", CAR_ENTRY_FLAG_ENABLE_TRIM_COLOUR },
{ "hasSwinging", CAR_ENTRY_FLAG_SWINGING },
{ "hasSpinning", CAR_ENTRY_FLAG_SPINNING },
{ "isPowered", CAR_ENTRY_FLAG_POWERED },
{ "hasScreamingRiders", CAR_ENTRY_FLAG_RIDERS_SCREAM },
{ "useSuspendedSwing", CAR_ENTRY_FLAG_SUSPENDED_SWING },
{ "useBoatHireCollisionDetection", CAR_ENTRY_FLAG_BOAT_HIRE_COLLISION_DETECTION },
{ "hasVehicleAnimation", CAR_ENTRY_FLAG_VEHICLE_ANIMATION },
{ "hasRiderAnimation", CAR_ENTRY_FLAG_RIDER_ANIMATION },
{ "useWoodenWildMouseSwing", CAR_ENTRY_FLAG_WOODEN_WILD_MOUSE_SWING },
{ "useSlideSwing", CAR_ENTRY_FLAG_SLIDE_SWING },
{ "isChairlift", CAR_ENTRY_FLAG_CHAIRLIFT },
{ "isWaterRide", CAR_ENTRY_FLAG_WATER_RIDE },
{ "isGoKart", CAR_ENTRY_FLAG_GO_KART },
{ "useDodgemCarPlacement", CAR_ENTRY_FLAG_DODGEM_CAR_PLACEMENT },
// Obsolete flags that have been replaced with named and camelCased values, but kept for now for backward
// compatibility.
{ "VEHICLE_ENTRY_FLAG_POWERED_RIDE_UNRESTRICTED_GRAVITY", VEHICLE_ENTRY_FLAG_POWERED_RIDE_UNRESTRICTED_GRAVITY },
{ "VEHICLE_ENTRY_FLAG_NO_UPSTOP_WHEELS", VEHICLE_ENTRY_FLAG_NO_UPSTOP_WHEELS },
{ "VEHICLE_ENTRY_FLAG_NO_UPSTOP_BOBSLEIGH", VEHICLE_ENTRY_FLAG_NO_UPSTOP_BOBSLEIGH },
{ "VEHICLE_ENTRY_FLAG_MINI_GOLF", VEHICLE_ENTRY_FLAG_MINI_GOLF },
{ "VEHICLE_ENTRY_FLAG_4", VEHICLE_ENTRY_FLAG_REVERSER_BOGIE },
{ "VEHICLE_ENTRY_FLAG_5", VEHICLE_ENTRY_FLAG_REVERSER_PASSENGER_CAR },
{ "VEHICLE_ENTRY_FLAG_HAS_INVERTED_SPRITE_SET", VEHICLE_ENTRY_FLAG_HAS_INVERTED_SPRITE_SET },
{ "VEHICLE_ENTRY_FLAG_DODGEM_INUSE_LIGHTS", VEHICLE_ENTRY_FLAG_DODGEM_INUSE_LIGHTS },
{ "VEHICLE_ENTRY_FLAG_ENABLE_ADDITIONAL_COLOUR_2", VEHICLE_ENTRY_FLAG_ENABLE_TERNARY_COLOUR },
{ "VEHICLE_ENTRY_FLAG_10", VEHICLE_ENTRY_FLAG_RECALCULATE_SPRITE_BOUNDS },
{ "VEHICLE_ENTRY_FLAG_OVERRIDE_NUM_VERTICAL_FRAMES", VEHICLE_ENTRY_FLAG_OVERRIDE_NUM_VERTICAL_FRAMES },
{ "VEHICLE_ENTRY_FLAG_13", VEHICLE_ENTRY_FLAG_SPRITE_BOUNDS_INCLUDE_INVERTED_SET },
{ "VEHICLE_ENTRY_FLAG_SPINNING_ADDITIONAL_FRAMES", VEHICLE_ENTRY_FLAG_SPINNING_ADDITIONAL_FRAMES },
{ "VEHICLE_ENTRY_FLAG_LIFT", VEHICLE_ENTRY_FLAG_LIFT },
{ "VEHICLE_ENTRY_FLAG_ENABLE_ADDITIONAL_COLOUR_1", VEHICLE_ENTRY_FLAG_ENABLE_TRIM_COLOUR },
{ "VEHICLE_ENTRY_FLAG_SWINGING", VEHICLE_ENTRY_FLAG_SWINGING },
{ "VEHICLE_ENTRY_FLAG_SPINNING", VEHICLE_ENTRY_FLAG_SPINNING },
{ "VEHICLE_ENTRY_FLAG_POWERED", VEHICLE_ENTRY_FLAG_POWERED },
{ "VEHICLE_ENTRY_FLAG_RIDERS_SCREAM", VEHICLE_ENTRY_FLAG_RIDERS_SCREAM },
{ "VEHICLE_ENTRY_FLAG_21", VEHICLE_ENTRY_FLAG_SUSPENDED_SWING },
{ "VEHICLE_ENTRY_FLAG_BOAT_HIRE_COLLISION_DETECTION", VEHICLE_ENTRY_FLAG_BOAT_HIRE_COLLISION_DETECTION },
{ "VEHICLE_ENTRY_FLAG_VEHICLE_ANIMATION", VEHICLE_ENTRY_FLAG_VEHICLE_ANIMATION },
{ "VEHICLE_ENTRY_FLAG_RIDER_ANIMATION", VEHICLE_ENTRY_FLAG_RIDER_ANIMATION },
{ "VEHICLE_ENTRY_FLAG_25", VEHICLE_ENTRY_FLAG_WOODEN_WILD_MOUSE_SWING },
{ "VEHICLE_ENTRY_FLAG_SLIDE_SWING", VEHICLE_ENTRY_FLAG_SLIDE_SWING },
{ "VEHICLE_ENTRY_FLAG_CHAIRLIFT", VEHICLE_ENTRY_FLAG_CHAIRLIFT },
{ "VEHICLE_ENTRY_FLAG_WATER_RIDE", VEHICLE_ENTRY_FLAG_WATER_RIDE },
{ "VEHICLE_ENTRY_FLAG_GO_KART", VEHICLE_ENTRY_FLAG_GO_KART },
{ "VEHICLE_ENTRY_FLAG_DODGEM_CAR_PLACEMENT", VEHICLE_ENTRY_FLAG_DODGEM_CAR_PLACEMENT },
{ "VEHICLE_ENTRY_FLAG_11", VEHICLE_ENTRY_FLAG_USE_16_ROTATION_FRAMES },
{ "VEHICLE_ENTRY_FLAG_POWERED_RIDE_UNRESTRICTED_GRAVITY", CAR_ENTRY_FLAG_POWERED_RIDE_UNRESTRICTED_GRAVITY },
{ "VEHICLE_ENTRY_FLAG_NO_UPSTOP_WHEELS", CAR_ENTRY_FLAG_NO_UPSTOP_WHEELS },
{ "VEHICLE_ENTRY_FLAG_NO_UPSTOP_BOBSLEIGH", CAR_ENTRY_FLAG_NO_UPSTOP_BOBSLEIGH },
{ "VEHICLE_ENTRY_FLAG_MINI_GOLF", CAR_ENTRY_FLAG_MINI_GOLF },
{ "VEHICLE_ENTRY_FLAG_4", CAR_ENTRY_FLAG_REVERSER_BOGIE },
{ "VEHICLE_ENTRY_FLAG_5", CAR_ENTRY_FLAG_REVERSER_PASSENGER_CAR },
{ "VEHICLE_ENTRY_FLAG_HAS_INVERTED_SPRITE_SET", CAR_ENTRY_FLAG_HAS_INVERTED_SPRITE_SET },
{ "VEHICLE_ENTRY_FLAG_DODGEM_INUSE_LIGHTS", CAR_ENTRY_FLAG_DODGEM_INUSE_LIGHTS },
{ "VEHICLE_ENTRY_FLAG_ENABLE_ADDITIONAL_COLOUR_2", CAR_ENTRY_FLAG_ENABLE_TERNARY_COLOUR },
{ "VEHICLE_ENTRY_FLAG_10", CAR_ENTRY_FLAG_RECALCULATE_SPRITE_BOUNDS },
{ "VEHICLE_ENTRY_FLAG_OVERRIDE_NUM_VERTICAL_FRAMES", CAR_ENTRY_FLAG_OVERRIDE_NUM_VERTICAL_FRAMES },
{ "VEHICLE_ENTRY_FLAG_13", CAR_ENTRY_FLAG_SPRITE_BOUNDS_INCLUDE_INVERTED_SET },
{ "VEHICLE_ENTRY_FLAG_SPINNING_ADDITIONAL_FRAMES", CAR_ENTRY_FLAG_SPINNING_ADDITIONAL_FRAMES },
{ "VEHICLE_ENTRY_FLAG_LIFT", CAR_ENTRY_FLAG_LIFT },
{ "VEHICLE_ENTRY_FLAG_ENABLE_ADDITIONAL_COLOUR_1", CAR_ENTRY_FLAG_ENABLE_TRIM_COLOUR },
{ "VEHICLE_ENTRY_FLAG_SWINGING", CAR_ENTRY_FLAG_SWINGING },
{ "VEHICLE_ENTRY_FLAG_SPINNING", CAR_ENTRY_FLAG_SPINNING },
{ "VEHICLE_ENTRY_FLAG_POWERED", CAR_ENTRY_FLAG_POWERED },
{ "VEHICLE_ENTRY_FLAG_RIDERS_SCREAM", CAR_ENTRY_FLAG_RIDERS_SCREAM },
{ "VEHICLE_ENTRY_FLAG_21", CAR_ENTRY_FLAG_SUSPENDED_SWING },
{ "VEHICLE_ENTRY_FLAG_BOAT_HIRE_COLLISION_DETECTION", CAR_ENTRY_FLAG_BOAT_HIRE_COLLISION_DETECTION },
{ "VEHICLE_ENTRY_FLAG_VEHICLE_ANIMATION", CAR_ENTRY_FLAG_VEHICLE_ANIMATION },
{ "VEHICLE_ENTRY_FLAG_RIDER_ANIMATION", CAR_ENTRY_FLAG_RIDER_ANIMATION },
{ "VEHICLE_ENTRY_FLAG_25", CAR_ENTRY_FLAG_WOODEN_WILD_MOUSE_SWING },
{ "VEHICLE_ENTRY_FLAG_SLIDE_SWING", CAR_ENTRY_FLAG_SLIDE_SWING },
{ "VEHICLE_ENTRY_FLAG_CHAIRLIFT", CAR_ENTRY_FLAG_CHAIRLIFT },
{ "VEHICLE_ENTRY_FLAG_WATER_RIDE", CAR_ENTRY_FLAG_WATER_RIDE },
{ "VEHICLE_ENTRY_FLAG_GO_KART", CAR_ENTRY_FLAG_GO_KART },
{ "VEHICLE_ENTRY_FLAG_DODGEM_CAR_PLACEMENT", CAR_ENTRY_FLAG_DODGEM_CAR_PLACEMENT },
{ "VEHICLE_ENTRY_FLAG_11", CAR_ENTRY_FLAG_USE_16_ROTATION_FRAMES },
});
// legacy sprite groups
@@ -784,23 +778,22 @@ rct_ride_entry_vehicle RideObject::ReadJsonCar([[maybe_unused]] IReadObjectConte
uint16_t spriteFlags = Json::GetFlags<uint32_t>(
jFrames,
{
{ "flat", VEHICLE_SPRITE_FLAG_FLAT },
{ "gentleSlopes", VEHICLE_SPRITE_FLAG_GENTLE_SLOPES },
{ "steepSlopes", VEHICLE_SPRITE_FLAG_STEEP_SLOPES },
{ "verticalSlopes", VEHICLE_SPRITE_FLAG_VERTICAL_SLOPES },
{ "diagonalSlopes", VEHICLE_SPRITE_FLAG_DIAGONAL_SLOPES },
{ "flatBanked", VEHICLE_SPRITE_FLAG_FLAT_BANKED },
{ "inlineTwists", VEHICLE_SPRITE_FLAG_INLINE_TWISTS },
{ "flatToGentleSlopeBankedTransitions", VEHICLE_SPRITE_FLAG_FLAT_TO_GENTLE_SLOPE_BANKED_TRANSITIONS },
{ "diagonalGentleSlopeBankedTransitions", VEHICLE_SPRITE_FLAG_DIAGONAL_GENTLE_SLOPE_BANKED_TRANSITIONS },
{ "gentleSlopeBankedTransitions", VEHICLE_SPRITE_FLAG_GENTLE_SLOPE_BANKED_TRANSITIONS },
{ "gentleSlopeBankedTurns", VEHICLE_SPRITE_FLAG_GENTLE_SLOPE_BANKED_TURNS },
{ "flatToGentleSlopeWhileBankedTransitions",
VEHICLE_SPRITE_FLAG_FLAT_TO_GENTLE_SLOPE_WHILE_BANKED_TRANSITIONS },
{ "corkscrews", VEHICLE_SPRITE_FLAG_CORKSCREWS },
{ "restraintAnimation", VEHICLE_SPRITE_FLAG_RESTRAINT_ANIMATION },
{ "curvedLiftHill", VEHICLE_SPRITE_FLAG_CURVED_LIFT_HILL },
{ "VEHICLE_SPRITE_FLAG_15", VEHICLE_SPRITE_FLAG_USE_4_ROTATION_FRAMES },
{ "flat", CAR_SPRITE_FLAG_FLAT },
{ "gentleSlopes", CAR_SPRITE_FLAG_GENTLE_SLOPES },
{ "steepSlopes", CAR_SPRITE_FLAG_STEEP_SLOPES },
{ "verticalSlopes", CAR_SPRITE_FLAG_VERTICAL_SLOPES },
{ "diagonalSlopes", CAR_SPRITE_FLAG_DIAGONAL_SLOPES },
{ "flatBanked", CAR_SPRITE_FLAG_FLAT_BANKED },
{ "inlineTwists", CAR_SPRITE_FLAG_INLINE_TWISTS },
{ "flatToGentleSlopeBankedTransitions", CAR_SPRITE_FLAG_FLAT_TO_GENTLE_SLOPE_BANKED_TRANSITIONS },
{ "diagonalGentleSlopeBankedTransitions", CAR_SPRITE_FLAG_DIAGONAL_GENTLE_SLOPE_BANKED_TRANSITIONS },
{ "gentleSlopeBankedTransitions", CAR_SPRITE_FLAG_GENTLE_SLOPE_BANKED_TRANSITIONS },
{ "gentleSlopeBankedTurns", CAR_SPRITE_FLAG_GENTLE_SLOPE_BANKED_TURNS },
{ "flatToGentleSlopeWhileBankedTransitions", CAR_SPRITE_FLAG_FLAT_TO_GENTLE_SLOPE_WHILE_BANKED_TRANSITIONS },
{ "corkscrews", CAR_SPRITE_FLAG_CORKSCREWS },
{ "restraintAnimation", CAR_SPRITE_FLAG_RESTRAINT_ANIMATION },
{ "curvedLiftHill", CAR_SPRITE_FLAG_CURVED_LIFT_HILL },
{ "VEHICLE_SPRITE_FLAG_15", CAR_SPRITE_FLAG_USE_4_ROTATION_FRAMES },
});
ReadLegacySpriteGroups(&car, spriteFlags);
return car;
@@ -1073,83 +1066,83 @@ ShopItem RideObject::ParseShopItem(const std::string& s)
}
// Converts legacy sprite groups into OpenRCT2 sprite groups
void RideObject::ReadLegacySpriteGroups(rct_ride_entry_vehicle* vehicle, uint16_t spriteGroups)
void RideObject::ReadLegacySpriteGroups(CarEntry* vehicle, uint16_t spriteGroups)
{
auto baseSpritePrecision = SpritePrecision::Sprites32;
if (vehicle->flags & VEHICLE_ENTRY_FLAG_USE_16_ROTATION_FRAMES)
if (vehicle->flags & CAR_ENTRY_FLAG_USE_16_ROTATION_FRAMES)
baseSpritePrecision = SpritePrecision::Sprites16;
if (vehicle->flags & VEHICLE_SPRITE_FLAG_USE_4_ROTATION_FRAMES)
if (vehicle->flags & CAR_SPRITE_FLAG_USE_4_ROTATION_FRAMES)
baseSpritePrecision = SpritePrecision::Sprites4;
if (spriteGroups & VEHICLE_SPRITE_FLAG_FLAT)
if (spriteGroups & CAR_SPRITE_FLAG_FLAT)
{
vehicle->SpriteGroups[EnumValue(SpriteGroupType::SlopeFlat)].spritePrecision = baseSpritePrecision;
}
if (spriteGroups & VEHICLE_SPRITE_FLAG_GENTLE_SLOPES)
if (spriteGroups & CAR_SPRITE_FLAG_GENTLE_SLOPES)
{
vehicle->SpriteGroups[EnumValue(SpriteGroupType::Slopes12)].spritePrecision = SpritePrecision::Sprites4;
vehicle->SpriteGroups[EnumValue(SpriteGroupType::Slopes25)].spritePrecision = baseSpritePrecision;
if (vehicle->flags & VEHICLE_ENTRY_FLAG_SPINNING_ADDITIONAL_FRAMES)
if (vehicle->flags & CAR_ENTRY_FLAG_SPINNING_ADDITIONAL_FRAMES)
vehicle->SpriteGroups[EnumValue(SpriteGroupType::Slopes25)].spritePrecision = SpritePrecision::Sprites4;
}
if (spriteGroups & VEHICLE_SPRITE_FLAG_STEEP_SLOPES)
if (spriteGroups & CAR_SPRITE_FLAG_STEEP_SLOPES)
{
vehicle->SpriteGroups[EnumValue(SpriteGroupType::Slopes42)].spritePrecision = SpritePrecision::Sprites8;
vehicle->SpriteGroups[EnumValue(SpriteGroupType::Slopes60)].spritePrecision = baseSpritePrecision;
}
if (spriteGroups & VEHICLE_SPRITE_FLAG_VERTICAL_SLOPES)
if (spriteGroups & CAR_SPRITE_FLAG_VERTICAL_SLOPES)
{
vehicle->SpriteGroups[EnumValue(SpriteGroupType::Slopes75)].spritePrecision = SpritePrecision::Sprites4;
vehicle->SpriteGroups[EnumValue(SpriteGroupType::Slopes90)].spritePrecision = baseSpritePrecision;
vehicle->SpriteGroups[EnumValue(SpriteGroupType::SlopesLoop)].spritePrecision = SpritePrecision::Sprites4;
vehicle->SpriteGroups[EnumValue(SpriteGroupType::SlopeInverted)].spritePrecision = SpritePrecision::Sprites4;
}
if (spriteGroups & VEHICLE_SPRITE_FLAG_DIAGONAL_SLOPES)
if (spriteGroups & CAR_SPRITE_FLAG_DIAGONAL_SLOPES)
{
vehicle->SpriteGroups[EnumValue(SpriteGroupType::Slopes8)].spritePrecision = SpritePrecision::Sprites4;
vehicle->SpriteGroups[EnumValue(SpriteGroupType::Slopes16)].spritePrecision = SpritePrecision::Sprites4;
vehicle->SpriteGroups[EnumValue(SpriteGroupType::Slopes50)].spritePrecision = SpritePrecision::Sprites4;
}
if (spriteGroups & VEHICLE_SPRITE_FLAG_FLAT_BANKED)
if (spriteGroups & CAR_SPRITE_FLAG_FLAT_BANKED)
{
vehicle->SpriteGroups[EnumValue(SpriteGroupType::FlatBanked22)].spritePrecision = SpritePrecision::Sprites8;
vehicle->SpriteGroups[EnumValue(SpriteGroupType::FlatBanked45)].spritePrecision = baseSpritePrecision;
}
if (spriteGroups & VEHICLE_SPRITE_FLAG_INLINE_TWISTS)
if (spriteGroups & CAR_SPRITE_FLAG_INLINE_TWISTS)
{
vehicle->SpriteGroups[EnumValue(SpriteGroupType::FlatBanked67)].spritePrecision = SpritePrecision::Sprites4;
vehicle->SpriteGroups[EnumValue(SpriteGroupType::FlatBanked90)].spritePrecision = SpritePrecision::Sprites4;
vehicle->SpriteGroups[EnumValue(SpriteGroupType::InlineTwists)].spritePrecision = SpritePrecision::Sprites4;
}
if (spriteGroups & VEHICLE_SPRITE_FLAG_FLAT_TO_GENTLE_SLOPE_BANKED_TRANSITIONS)
if (spriteGroups & CAR_SPRITE_FLAG_FLAT_TO_GENTLE_SLOPE_BANKED_TRANSITIONS)
{
vehicle->SpriteGroups[EnumValue(SpriteGroupType::Slopes12Banked22)].spritePrecision = baseSpritePrecision;
}
if (spriteGroups & VEHICLE_SPRITE_FLAG_DIAGONAL_GENTLE_SLOPE_BANKED_TRANSITIONS)
if (spriteGroups & CAR_SPRITE_FLAG_DIAGONAL_GENTLE_SLOPE_BANKED_TRANSITIONS)
{
vehicle->SpriteGroups[EnumValue(SpriteGroupType::Slopes8Banked22)].spritePrecision = SpritePrecision::Sprites4;
}
if (spriteGroups & VEHICLE_SPRITE_FLAG_GENTLE_SLOPE_BANKED_TRANSITIONS)
if (spriteGroups & CAR_SPRITE_FLAG_GENTLE_SLOPE_BANKED_TRANSITIONS)
{
vehicle->SpriteGroups[EnumValue(SpriteGroupType::Slopes25Banked22)].spritePrecision = SpritePrecision::Sprites4;
}
if (spriteGroups & VEHICLE_SPRITE_FLAG_GENTLE_SLOPE_BANKED_TURNS)
if (spriteGroups & CAR_SPRITE_FLAG_GENTLE_SLOPE_BANKED_TURNS)
{
vehicle->SpriteGroups[EnumValue(SpriteGroupType::Slopes25Banked45)].spritePrecision = baseSpritePrecision;
}
if (spriteGroups & VEHICLE_SPRITE_FLAG_FLAT_TO_GENTLE_SLOPE_WHILE_BANKED_TRANSITIONS)
if (spriteGroups & CAR_SPRITE_FLAG_FLAT_TO_GENTLE_SLOPE_WHILE_BANKED_TRANSITIONS)
{
vehicle->SpriteGroups[EnumValue(SpriteGroupType::Slopes12Banked45)].spritePrecision = SpritePrecision::Sprites4;
}
if (spriteGroups & VEHICLE_SPRITE_FLAG_CORKSCREWS)
if (spriteGroups & CAR_SPRITE_FLAG_CORKSCREWS)
{
vehicle->SpriteGroups[EnumValue(SpriteGroupType::Corkscrews)].spritePrecision = SpritePrecision::Sprites4;
}
if (spriteGroups & VEHICLE_SPRITE_FLAG_RESTRAINT_ANIMATION)
if (spriteGroups & CAR_SPRITE_FLAG_RESTRAINT_ANIMATION)
{
vehicle->SpriteGroups[EnumValue(SpriteGroupType::RestraintAnimation)].spritePrecision = SpritePrecision::Sprites4;
}
if (spriteGroups & VEHICLE_SPRITE_FLAG_CURVED_LIFT_HILL)
if (spriteGroups & CAR_SPRITE_FLAG_CURVED_LIFT_HILL)
{
vehicle->SpriteGroups[EnumValue(SpriteGroupType::CurvedLiftHill)].spritePrecision = baseSpritePrecision;
}