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

Desnake TrackDesign fields

Browse Source
This commit is contained in:
Gymnasiast
2024-06-11 22:47:25 +02:00
parent ffe142a8a7
commit cdbedeece6
11 changed files with 295 additions and 296 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
src/openrct2-ui/windows/InstallTrack.cpp
View File

@@ -170,7 +170,7 @@ static Widget window_install_track_widgets[] = {
// Warnings
const TrackDesign* td6 = _trackDesign.get();
if (td6->track_flags & TRACK_DESIGN_FLAG_SCENERY_UNAVAILABLE)
if (td6->trackFlags & TRACK_DESIGN_FLAG_SCENERY_UNAVAILABLE)
{
if (!gTrackDesignSceneryToggle)
{
@@ -198,7 +198,7 @@ static Widget window_install_track_widgets[] = {
{
auto ft = Formatter();
const auto* objectEntry = ObjectManagerLoadObject(&td6->vehicle_object.Entry);
const auto* objectEntry = ObjectManagerLoadObject(&td6->vehicleObject.Entry);
if (objectEntry != nullptr)
{
auto groupIndex = ObjectManagerGetLoadedObjectEntryIndex(objectEntry);
@@ -254,7 +254,7 @@ static Widget window_install_track_widgets[] = {
{
// Maximum speed
{
uint16_t speed = ((td6->max_speed << 16) * 9) >> 18;
uint16_t speed = ((td6->maxSpeed << 16) * 9) >> 18;
auto ft = Formatter();
ft.Add<uint16_t>(speed);
DrawTextBasic(dpi, screenPos, STR_MAX_SPEED, ft);
@@ -262,7 +262,7 @@ static Widget window_install_track_widgets[] = {
}
// Average speed
{
uint16_t speed = ((td6->average_speed << 16) * 9) >> 18;
uint16_t speed = ((td6->averageSpeed << 16) * 9) >> 18;
auto ft = Formatter();
ft.Add<uint16_t>(speed);
DrawTextBasic(dpi, screenPos, STR_AVERAGE_SPEED, ft);
@@ -273,7 +273,7 @@ static Widget window_install_track_widgets[] = {
// Ride length
auto ft = Formatter();
ft.Add<StringId>(STR_RIDE_LENGTH_ENTRY);
ft.Add<uint16_t>(td6->ride_length);
ft.Add<uint16_t>(td6->rideLength);
DrawTextEllipsised(dpi, screenPos, 214, STR_TRACK_LIST_RIDE_LENGTH, ft);
screenPos.y += kListRowHeight;
}
@@ -282,7 +282,7 @@ static Widget window_install_track_widgets[] = {
{
// Maximum positive vertical Gs
{
int32_t gForces = td6->max_positive_vertical_g * 32;
int32_t gForces = td6->maxPositiveVerticalG * 32;
auto ft = Formatter();
ft.Add<int32_t>(gForces);
DrawTextBasic(dpi, screenPos, STR_MAX_POSITIVE_VERTICAL_G, ft);
@@ -290,7 +290,7 @@ static Widget window_install_track_widgets[] = {
}
// Maximum negative vertical Gs
{
int32_t gForces = td6->max_negative_vertical_g * 32;
int32_t gForces = td6->maxNegativeVerticalG * 32;
auto ft = Formatter();
ft.Add<int32_t>(gForces);
DrawTextBasic(dpi, screenPos, STR_MAX_NEGATIVE_VERTICAL_G, ft);
@@ -298,16 +298,16 @@ static Widget window_install_track_widgets[] = {
}
// Maximum lateral Gs
{
int32_t gForces = td6->max_lateral_g * 32;
int32_t gForces = td6->maxLateralG * 32;
auto ft = Formatter();
ft.Add<int32_t>(gForces);
DrawTextBasic(dpi, screenPos, STR_MAX_LATERAL_G, ft);
screenPos.y += kListRowHeight;
}
if (td6->total_air_time != 0)
if (td6->totalAirTime != 0)
{
// Total air time
int32_t airTime = td6->total_air_time * 25;
int32_t airTime = td6->totalAirTime * 25;
auto ft = Formatter();
ft.Add<int32_t>(airTime);
DrawTextBasic(dpi, screenPos, STR_TOTAL_AIR_TIME, ft);
@@ -343,12 +343,12 @@ static Widget window_install_track_widgets[] = {
}
screenPos.y += 4;
if (td6->space_required_x != 0xFF)
if (td6->spaceRequiredX != 0xFF)
{
// Space required
auto ft = Formatter();
ft.Add<uint16_t>(td6->space_required_x);
ft.Add<uint16_t>(td6->space_required_y);
ft.Add<uint16_t>(td6->spaceRequiredX);
ft.Add<uint16_t>(td6->spaceRequiredY);
DrawTextBasic(dpi, screenPos, STR_TRACK_LIST_SPACE_REQUIRED, ft);
screenPos.y += kListRowHeight;
}
@@ -422,7 +422,7 @@ static Widget window_install_track_widgets[] = {
LOG_ERROR("Failed to load track (ride type null): %s", path);
return nullptr;
}
if (ObjectManagerLoadObject(&trackDesign->vehicle_object.Entry) == nullptr)
if (ObjectManagerLoadObject(&trackDesign->vehicleObject.Entry) == nullptr)
{
LOG_ERROR("Failed to load track (vehicle load fail): %s", path);
return nullptr;

6
src/openrct2-ui/windows/TrackDesignPlace.cpp
View File

@@ -438,7 +438,7 @@ static Widget _trackPlaceWidgets[] = {
void DrawMiniPreviewEntrances(
const TrackDesign& td6, int32_t pass, const CoordsXY& origin, CoordsXY& min, CoordsXY& max, Direction rotation)
{
for (const auto& entrance : td6.entrance_elements)
for (const auto& entrance : td6.entranceElements)
{
auto rotatedAndOffsetEntrance = origin + entrance.Location.ToCoordsXY().Rotate(rotation);
@@ -474,7 +474,7 @@ static Widget _trackPlaceWidgets[] = {
CoordsXY curTrackStart = origin;
uint8_t curTrackRotation = rotation;
for (const auto& trackElement : td6->track_elements)
for (const auto& trackElement : td6->trackElements)
{
// Follow a single track piece shape
const auto& ted = GetTrackElementDescriptor(trackElement.Type);
@@ -545,7 +545,7 @@ static Widget _trackPlaceWidgets[] = {
void DrawMiniPreviewMaze(TrackDesign* td6, int32_t pass, const CoordsXY& origin, CoordsXY& min, CoordsXY& max)
{
uint8_t rotation = (_currentTrackPieceDirection + GetCurrentRotation()) & 3;
for (const auto& mazeElement : td6->maze_elements)
for (const auto& mazeElement : td6->mazeElements)
{
auto rotatedMazeCoords = origin + TileCoordsXY{ mazeElement.x, mazeElement.y }.ToCoordsXY().Rotate(rotation);

32
src/openrct2-ui/windows/TrackList.cpp
View File

@@ -136,7 +136,7 @@ static Widget _trackListWidgets[] = {
return;
}
if (_loadedTrackDesign->track_flags & TRACK_DESIGN_FLAG_SCENERY_UNAVAILABLE)
if (_loadedTrackDesign->trackFlags & TRACK_DESIGN_FLAG_SCENERY_UNAVAILABLE)
{
gTrackDesignSceneryToggle = true;
}
@@ -152,7 +152,7 @@ static Widget _trackListWidgets[] = {
else
{
if (_loadedTrackDesignIndex != TRACK_DESIGN_INDEX_UNLOADED
&& (_loadedTrackDesign->track_flags & TRACK_DESIGN_FLAG_VEHICLE_UNAVAILABLE))
&& (_loadedTrackDesign->trackFlags & TRACK_DESIGN_FLAG_VEHICLE_UNAVAILABLE))
{
ContextShowError(STR_THIS_DESIGN_WILL_BE_BUILT_WITH_AN_ALTERNATIVE_VEHICLE_TYPE, STR_NONE, {});
}
@@ -515,7 +515,7 @@ static Widget _trackListWidgets[] = {
screenPos.y = windowPos.y + tdWidget.bottom - 12;
// Warnings
if ((_loadedTrackDesign->track_flags & TRACK_DESIGN_FLAG_VEHICLE_UNAVAILABLE)
if ((_loadedTrackDesign->trackFlags & TRACK_DESIGN_FLAG_VEHICLE_UNAVAILABLE)
&& !(gScreenFlags & SCREEN_FLAGS_TRACK_MANAGER))
{
// Vehicle design not available
@@ -523,7 +523,7 @@ static Widget _trackListWidgets[] = {
screenPos.y -= kScrollableRowHeight;
}
if (_loadedTrackDesign->track_flags & TRACK_DESIGN_FLAG_SCENERY_UNAVAILABLE)
if (_loadedTrackDesign->trackFlags & TRACK_DESIGN_FLAG_SCENERY_UNAVAILABLE)
{
if (!gTrackDesignSceneryToggle)
{
@@ -576,13 +576,13 @@ static Widget _trackListWidgets[] = {
{
// Maximum speed
ft = Formatter();
ft.Add<uint16_t>(((_loadedTrackDesign->max_speed << 16) * 9) >> 18);
ft.Add<uint16_t>(((_loadedTrackDesign->maxSpeed << 16) * 9) >> 18);
DrawTextBasic(dpi, screenPos, STR_MAX_SPEED, ft);
screenPos.y += kListRowHeight;
// Average speed
ft = Formatter();
ft.Add<uint16_t>(((_loadedTrackDesign->average_speed << 16) * 9) >> 18);
ft.Add<uint16_t>(((_loadedTrackDesign->averageSpeed << 16) * 9) >> 18);
DrawTextBasic(dpi, screenPos, STR_AVERAGE_SPEED, ft);
screenPos.y += kListRowHeight;
}
@@ -590,7 +590,7 @@ static Widget _trackListWidgets[] = {
// Ride length
ft = Formatter();
ft.Add<StringId>(STR_RIDE_LENGTH_ENTRY);
ft.Add<uint16_t>(_loadedTrackDesign->ride_length);
ft.Add<uint16_t>(_loadedTrackDesign->rideLength);
DrawTextEllipsised(dpi, screenPos, 214, STR_TRACK_LIST_RIDE_LENGTH, ft);
screenPos.y += kListRowHeight;
}
@@ -599,27 +599,27 @@ static Widget _trackListWidgets[] = {
{
// Maximum positive vertical Gs
ft = Formatter();
ft.Add<int32_t>(_loadedTrackDesign->max_positive_vertical_g * 32);
ft.Add<int32_t>(_loadedTrackDesign->maxPositiveVerticalG * 32);
DrawTextBasic(dpi, screenPos, STR_MAX_POSITIVE_VERTICAL_G, ft);
screenPos.y += kListRowHeight;
// Maximum negative vertical Gs
ft = Formatter();
ft.Add<int32_t>(_loadedTrackDesign->max_negative_vertical_g * 32);
ft.Add<int32_t>(_loadedTrackDesign->maxNegativeVerticalG * 32);
DrawTextBasic(dpi, screenPos, STR_MAX_NEGATIVE_VERTICAL_G, ft);
screenPos.y += kListRowHeight;
// Maximum lateral Gs
ft = Formatter();
ft.Add<int32_t>(_loadedTrackDesign->max_lateral_g * 32);
ft.Add<int32_t>(_loadedTrackDesign->maxLateralG * 32);
DrawTextBasic(dpi, screenPos, STR_MAX_LATERAL_G, ft);
screenPos.y += kListRowHeight;
if (_loadedTrackDesign->total_air_time != 0)
if (_loadedTrackDesign->totalAirTime != 0)
{
// Total air time
ft = Formatter();
ft.Add<int32_t>(_loadedTrackDesign->total_air_time * 25);
ft.Add<int32_t>(_loadedTrackDesign->totalAirTime * 25);
DrawTextBasic(dpi, screenPos, STR_TOTAL_AIR_TIME, ft);
screenPos.y += kListRowHeight;
}
@@ -635,7 +635,7 @@ static Widget _trackListWidgets[] = {
// Drop height is multiplied by 0.75
ft = Formatter();
ft.Add<uint16_t>((_loadedTrackDesign->highest_drop_height * 3) / 4);
ft.Add<uint16_t>((_loadedTrackDesign->highestDropHeight * 3) / 4);
DrawTextBasic(dpi, screenPos, STR_HIGHEST_DROP_HEIGHT, ft);
screenPos.y += kListRowHeight;
}
@@ -655,12 +655,12 @@ static Widget _trackListWidgets[] = {
screenPos.y += 4;
}
if (_loadedTrackDesign->space_required_x != 0xFF)
if (_loadedTrackDesign->spaceRequiredX != 0xFF)
{
// Space required
ft = Formatter();
ft.Add<uint16_t>(_loadedTrackDesign->space_required_x);
ft.Add<uint16_t>(_loadedTrackDesign->space_required_y);
ft.Add<uint16_t>(_loadedTrackDesign->spaceRequiredX);
ft.Add<uint16_t>(_loadedTrackDesign->spaceRequiredY);
DrawTextBasic(dpi, screenPos, STR_TRACK_LIST_SPACE_REQUIRED, ft);
screenPos.y += kListRowHeight;
}

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

@@ -66,7 +66,7 @@ GameActions::Result TrackDesignAction::Query() const
auto& gameState = GetGameState();
auto& objManager = GetContext()->GetObjectManager();
auto entryIndex = objManager.GetLoadedObjectEntryIndex(_td.vehicle_object);
auto entryIndex = objManager.GetLoadedObjectEntryIndex(_td.vehicleObject);
if (entryIndex == OBJECT_ENTRY_INDEX_NULL)
{
// Force a fallback if the entry is not invented yet a td6 of it is selected,
@@ -140,7 +140,7 @@ GameActions::Result TrackDesignAction::Execute() const
auto& gameState = GetGameState();
auto& objManager = GetContext()->GetObjectManager();
auto entryIndex = objManager.GetLoadedObjectEntryIndex(_td.vehicle_object);
auto entryIndex = objManager.GetLoadedObjectEntryIndex(_td.vehicleObject);
if (entryIndex != OBJECT_ENTRY_INDEX_NULL)
{
// Force a fallback if the entry is not invented yet a track design using it is selected.
@@ -224,21 +224,20 @@ GameActions::Result TrackDesignAction::Execute() const
GameActions::ExecuteNested(&rideSetVehicleAction);
}
SetOperatingSettingNested(ride->id, RideSetSetting::Mode, static_cast<uint8_t>(_td.ride_mode), GAME_COMMAND_FLAG_APPLY);
auto rideSetVehicleAction2 = RideSetVehicleAction(ride->id, RideSetVehicleType::NumTrains, _td.number_of_trains);
SetOperatingSettingNested(ride->id, RideSetSetting::Mode, static_cast<uint8_t>(_td.rideMode), GAME_COMMAND_FLAG_APPLY);
auto rideSetVehicleAction2 = RideSetVehicleAction(ride->id, RideSetVehicleType::NumTrains, _td.numberOfTrains);
GameActions::ExecuteNested(&rideSetVehicleAction2);
auto rideSetVehicleAction3 = RideSetVehicleAction(
ride->id, RideSetVehicleType::NumCarsPerTrain, _td.number_of_cars_per_train);
auto rideSetVehicleAction3 = RideSetVehicleAction(ride->id, RideSetVehicleType::NumCarsPerTrain, _td.numberOfCarsPerTrain);
GameActions::ExecuteNested(&rideSetVehicleAction3);
SetOperatingSettingNested(ride->id, RideSetSetting::Departure, _td.depart_flags, GAME_COMMAND_FLAG_APPLY);
SetOperatingSettingNested(ride->id, RideSetSetting::MinWaitingTime, _td.min_waiting_time, GAME_COMMAND_FLAG_APPLY);
SetOperatingSettingNested(ride->id, RideSetSetting::MaxWaitingTime, _td.max_waiting_time, GAME_COMMAND_FLAG_APPLY);
SetOperatingSettingNested(ride->id, RideSetSetting::Operation, _td.operation_setting, GAME_COMMAND_FLAG_APPLY);
SetOperatingSettingNested(ride->id, RideSetSetting::LiftHillSpeed, _td.lift_hill_speed & 0x1F, GAME_COMMAND_FLAG_APPLY);
SetOperatingSettingNested(ride->id, RideSetSetting::Departure, _td.departFlags, GAME_COMMAND_FLAG_APPLY);
SetOperatingSettingNested(ride->id, RideSetSetting::MinWaitingTime, _td.minWaitingTime, GAME_COMMAND_FLAG_APPLY);
SetOperatingSettingNested(ride->id, RideSetSetting::MaxWaitingTime, _td.maxWaitingTime, GAME_COMMAND_FLAG_APPLY);
SetOperatingSettingNested(ride->id, RideSetSetting::Operation, _td.operationSetting, GAME_COMMAND_FLAG_APPLY);
SetOperatingSettingNested(ride->id, RideSetSetting::LiftHillSpeed, _td.liftHillSpeed & 0x1F, GAME_COMMAND_FLAG_APPLY);
uint8_t num_circuits = _td.num_circuits;
uint8_t num_circuits = _td.numCircuits;
if (num_circuits == 0)
{
num_circuits = 1;
@@ -246,9 +245,9 @@ GameActions::Result TrackDesignAction::Execute() const
SetOperatingSettingNested(ride->id, RideSetSetting::NumCircuits, num_circuits, GAME_COMMAND_FLAG_APPLY);
ride->SetToDefaultInspectionInterval();
ride->lifecycle_flags |= RIDE_LIFECYCLE_NOT_CUSTOM_DESIGN;
ride->colour_scheme_type = _td.colour_scheme;
ride->colour_scheme_type = _td.colourScheme;
ride->entrance_style = objManager.GetLoadedObjectEntryIndex(_td.StationObjectIdentifier);
ride->entrance_style = objManager.GetLoadedObjectEntryIndex(_td.stationObjectIdentifier);
if (ride->entrance_style == OBJECT_ENTRY_INDEX_NULL)
{
ride->entrance_style = gameState.LastEntranceStyle;
@@ -256,14 +255,14 @@ GameActions::Result TrackDesignAction::Execute() const
for (int32_t i = 0; i < Limits::kNumColourSchemes; i++)
{
ride->track_colour[i].main = _td.track_spine_colour[i];
ride->track_colour[i].additional = _td.track_rail_colour[i];
ride->track_colour[i].supports = _td.track_support_colour[i];
ride->track_colour[i].main = _td.trackSpineColour[i];
ride->track_colour[i].additional = _td.trackRailColour[i];
ride->track_colour[i].supports = _td.trackSupportColour[i];
}
for (size_t i = 0; i < Limits::kMaxVehicleColours; i++)
{
ride->vehicle_colours[i] = _td.vehicle_colours[i];
ride->vehicle_colours[i] = _td.vehicleColours[i];
}
for (int32_t count = 1; count == 1 || r.Error != GameActions::Status::Ok; ++count)

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

@@ -89,9 +89,9 @@ namespace RCT1
for (int32_t i = 0; i < Limits::kNumColourSchemes; i++)
{
td->track_spine_colour[i] = RCT1::GetColour(td4aa.TrackSpineColour[i]);
td->track_rail_colour[i] = RCT1::GetColour(td4aa.TrackRailColour[i]);
td->track_support_colour[i] = RCT1::GetColour(td4aa.TrackSupportColour[i]);
td->trackSpineColour[i] = RCT1::GetColour(td4aa.TrackSpineColour[i]);
td->trackRailColour[i] = RCT1::GetColour(td4aa.TrackRailColour[i]);
td->trackSupportColour[i] = RCT1::GetColour(td4aa.TrackSupportColour[i]);
}
td->flags2 = td4aa.Flags2;
@@ -106,19 +106,19 @@ namespace RCT1
_stream.Read(&td4, sizeof(TD4));
for (int32_t i = 0; i < OpenRCT2::Limits::kNumColourSchemes; i++)
{
td->track_spine_colour[i] = RCT1::GetColour(td4.TrackSpineColourV0);
td->track_rail_colour[i] = RCT1::GetColour(td4.TrackRailColourV0);
td->track_support_colour[i] = RCT1::GetColour(td4.TrackSupportColourV0);
td->trackSpineColour[i] = RCT1::GetColour(td4.TrackSpineColourV0);
td->trackRailColour[i] = RCT1::GetColour(td4.TrackRailColourV0);
td->trackSupportColour[i] = RCT1::GetColour(td4.TrackSupportColourV0);
// Mazes were only hedges
if (td4.Type == RideType::HedgeMaze)
{
td->track_support_colour[i] = MAZE_WALL_TYPE_HEDGE;
td->trackSupportColour[i] = MAZE_WALL_TYPE_HEDGE;
}
else if (td4.Type == RideType::RiverRapids)
{
td->track_spine_colour[i] = COLOUR_WHITE;
td->track_rail_colour[i] = COLOUR_WHITE;
td->trackSpineColour[i] = COLOUR_WHITE;
td->trackRailColour[i] = COLOUR_WHITE;
}
}
td->flags2 = 0;
@@ -130,10 +130,10 @@ namespace RCT1
td->type = RCT1::GetRideType(td4Base.Type, td4Base.VehicleType);
// All TD4s that use powered launch use the type that doesn't pass the station.
td->ride_mode = static_cast<RideMode>(td4Base.Mode);
td->rideMode = static_cast<RideMode>(td4Base.Mode);
if (td4Base.Mode == RCT1_RIDE_MODE_POWERED_LAUNCH)
{
td->ride_mode = RideMode::PoweredLaunch;
td->rideMode = RideMode::PoweredLaunch;
}
std::string_view vehicleObject;
@@ -146,11 +146,11 @@ namespace RCT1
vehicleObject = RCT1::GetVehicleObject(td4Base.VehicleType);
}
assert(!vehicleObject.empty());
td->vehicle_object = ObjectEntryDescriptor(vehicleObject);
td->vehicle_type = EnumValue(td4Base.VehicleType);
td->vehicleObject = ObjectEntryDescriptor(vehicleObject);
td->vehicleType = EnumValue(td4Base.VehicleType);
td->flags = td4Base.Flags;
td->colour_scheme = td4Base.VersionAndColourScheme & 0x3;
td->colourScheme = td4Base.VersionAndColourScheme & 0x3;
// Vehicle colours
for (int32_t i = 0; i < Limits::kMaxTrainsPerRide; i++)
@@ -160,63 +160,63 @@ namespace RCT1
td4Base.VehicleType);
if (colourSchemeCopyDescriptor.colour1 == COPY_COLOUR_1)
{
td->vehicle_colours[i].Body = RCT1::GetColour(td4Base.VehicleColours[i].BodyColour);
td->vehicleColours[i].Body = RCT1::GetColour(td4Base.VehicleColours[i].BodyColour);
}
else if (colourSchemeCopyDescriptor.colour1 == COPY_COLOUR_2)
{
td->vehicle_colours[i].Body = RCT1::GetColour(td4Base.VehicleColours[i].TrimColour);
td->vehicleColours[i].Body = RCT1::GetColour(td4Base.VehicleColours[i].TrimColour);
}
else
{
td->vehicle_colours[i].Body = colourSchemeCopyDescriptor.colour1;
td->vehicleColours[i].Body = colourSchemeCopyDescriptor.colour1;
}
if (colourSchemeCopyDescriptor.colour2 == COPY_COLOUR_1)
{
td->vehicle_colours[i].Trim = RCT1::GetColour(td4Base.VehicleColours[i].BodyColour);
td->vehicleColours[i].Trim = RCT1::GetColour(td4Base.VehicleColours[i].BodyColour);
}
else if (colourSchemeCopyDescriptor.colour2 == COPY_COLOUR_2)
{
td->vehicle_colours[i].Trim = RCT1::GetColour(td4Base.VehicleColours[i].TrimColour);
td->vehicleColours[i].Trim = RCT1::GetColour(td4Base.VehicleColours[i].TrimColour);
}
else
{
td->vehicle_colours[i].Trim = colourSchemeCopyDescriptor.colour2;
td->vehicleColours[i].Trim = colourSchemeCopyDescriptor.colour2;
}
if (colourSchemeCopyDescriptor.colour3 == COPY_COLOUR_1)
{
td->vehicle_colours[i].Tertiary = RCT1::GetColour(td4Base.VehicleColours[i].BodyColour);
td->vehicleColours[i].Tertiary = RCT1::GetColour(td4Base.VehicleColours[i].BodyColour);
}
else if (colourSchemeCopyDescriptor.colour3 == COPY_COLOUR_2)
{
td->vehicle_colours[i].Tertiary = RCT1::GetColour(td4Base.VehicleColours[i].TrimColour);
td->vehicleColours[i].Tertiary = RCT1::GetColour(td4Base.VehicleColours[i].TrimColour);
}
else
{
td->vehicle_colours[i].Tertiary = colourSchemeCopyDescriptor.colour3;
td->vehicleColours[i].Tertiary = colourSchemeCopyDescriptor.colour3;
}
}
// Set remaining vehicles to same colour as first vehicle
for (size_t i = Limits::kMaxTrainsPerRide; i < std::size(td->vehicle_colours); i++)
for (size_t i = Limits::kMaxTrainsPerRide; i < std::size(td->vehicleColours); i++)
{
td->vehicle_colours[i] = td->vehicle_colours[0];
td->vehicleColours[i] = td->vehicleColours[0];
}
td->StationObjectIdentifier = GetStationIdentifierFromStyle(RCT12_STATION_STYLE_PLAIN);
td->depart_flags = td4Base.DepartFlags;
td->number_of_trains = td4Base.NumberOfTrains;
td->number_of_cars_per_train = td4Base.NumberOfCarsPerTrain;
td->min_waiting_time = td4Base.MinWaitingTime;
td->max_waiting_time = td4Base.MaxWaitingTime;
td->operation_setting = std::min(
td->stationObjectIdentifier = GetStationIdentifierFromStyle(RCT12_STATION_STYLE_PLAIN);
td->departFlags = td4Base.DepartFlags;
td->numberOfTrains = td4Base.NumberOfTrains;
td->numberOfCarsPerTrain = td4Base.NumberOfCarsPerTrain;
td->minWaitingTime = td4Base.MinWaitingTime;
td->maxWaitingTime = td4Base.MaxWaitingTime;
td->operationSetting = std::min(
td4Base.OperationSetting, GetRideTypeDescriptor(td->type).OperatingSettings.MaxValue);
td->max_speed = td4Base.MaxSpeed;
td->average_speed = td4Base.AverageSpeed;
td->ride_length = td4Base.RideLength;
td->max_positive_vertical_g = td4Base.MaxPositiveVerticalG;
td->max_negative_vertical_g = td4Base.MaxNegativeVerticalG;
td->max_lateral_g = td4Base.MaxLateralG;
td->maxSpeed = td4Base.MaxSpeed;
td->averageSpeed = td4Base.AverageSpeed;
td->rideLength = td4Base.RideLength;
td->maxPositiveVerticalG = td4Base.MaxPositiveVerticalG;
td->maxNegativeVerticalG = td4Base.MaxNegativeVerticalG;
td->maxLateralG = td4Base.MaxLateralG;
if (td->type == RIDE_TYPE_MINI_GOLF)
{
@@ -228,16 +228,16 @@ namespace RCT1
}
td->drops = td4Base.NumDrops;
td->highest_drop_height = td4Base.HighestDropHeight / 2;
td->highestDropHeight = td4Base.HighestDropHeight / 2;
td->excitement = td4Base.Excitement;
td->intensity = td4Base.Intensity;
td->nausea = td4Base.Nausea;
td->upkeep_cost = ToMoney64(td4Base.UpkeepCost);
td->space_required_x = 255;
td->space_required_y = 255;
td->lift_hill_speed = 5;
td->num_circuits = 0;
td->operation_setting = std::min(td->operation_setting, GetRideTypeDescriptor(td->type).OperatingSettings.MaxValue);
td->upkeepCost = ToMoney64(td4Base.UpkeepCost);
td->spaceRequiredX = 255;
td->spaceRequiredY = 255;
td->liftHillSpeed = 5;
td->numCircuits = 0;
td->operationSetting = std::min(td->operationSetting, GetRideTypeDescriptor(td->type).OperatingSettings.MaxValue);
const auto& rtd = GetRideTypeDescriptor(td->type);
if (rtd.HasFlag(RIDE_TYPE_FLAG_IS_MAZE))
@@ -263,7 +263,7 @@ namespace RCT1
TrackDesignTrackElement trackElement{};
trackElement.Type = RCT1TrackTypeToOpenRCT2(t4TrackElement.Type, td->type);
ConvertFromTD46Flags(trackElement, t4TrackElement.Flags);
td->track_elements.push_back(trackElement);
td->trackElements.push_back(trackElement);
}
}

4
src/openrct2/rct12/RCT12.cpp
View File

@@ -941,7 +941,7 @@ void ImportMazeElement(TrackDesign& td, const TD46MazeElement& td46MazeElement)
TrackDesignEntranceElement element{};
element.Location = TileCoordsXYZD(td46MazeElement.x, td46MazeElement.y, 0, td46MazeElement.Direction);
element.IsExit = td46MazeElement.IsExit();
td.entrance_elements.push_back(element);
td.entranceElements.push_back(element);
}
else
{
@@ -950,7 +950,7 @@ void ImportMazeElement(TrackDesign& td, const TD46MazeElement& td46MazeElement)
mazeElement.y = td46MazeElement.y;
mazeElement.direction = td46MazeElement.Direction;
mazeElement.type = td46MazeElement.Type;
td.maze_elements.push_back(mazeElement);
td.mazeElements.push_back(mazeElement);
}
}

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

@@ -53,61 +53,61 @@ namespace RCT2
{
OpenRCT2::MemoryStream tempStream;
tempStream.WriteValue<uint8_t>(OpenRCT2RideTypeToRCT2RideType(_trackDesign->type));
tempStream.WriteValue<uint8_t>(_trackDesign->vehicle_type);
tempStream.WriteValue<uint8_t>(_trackDesign->vehicleType);
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.WriteValue<uint8_t>(static_cast<uint8_t>(_trackDesign->rideMode));
tempStream.WriteValue<uint8_t>((_trackDesign->colourScheme & 0x3) | (2 << 2));
for (auto i = 0; i < RCT2::Limits::kMaxVehicleColours; i++)
{
tempStream.WriteValue<uint8_t>(_trackDesign->vehicle_colours[i].Body);
tempStream.WriteValue<uint8_t>(_trackDesign->vehicle_colours[i].Trim);
tempStream.WriteValue<uint8_t>(_trackDesign->vehicleColours[i].Body);
tempStream.WriteValue<uint8_t>(_trackDesign->vehicleColours[i].Trim);
}
tempStream.WriteValue<uint8_t>(0);
auto entranceStyle = GetStationStyleFromIdentifier(_trackDesign->StationObjectIdentifier);
auto entranceStyle = GetStationStyleFromIdentifier(_trackDesign->stationObjectIdentifier);
tempStream.WriteValue<uint8_t>(entranceStyle);
tempStream.WriteValue<uint8_t>(_trackDesign->total_air_time);
tempStream.WriteValue<uint8_t>(_trackDesign->depart_flags);
tempStream.WriteValue<uint8_t>(_trackDesign->number_of_trains);
tempStream.WriteValue<uint8_t>(_trackDesign->number_of_cars_per_train);
tempStream.WriteValue<uint8_t>(_trackDesign->min_waiting_time);
tempStream.WriteValue<uint8_t>(_trackDesign->max_waiting_time);
tempStream.WriteValue<uint8_t>(_trackDesign->operation_setting);
tempStream.WriteValue<int8_t>(_trackDesign->max_speed);
tempStream.WriteValue<int8_t>(_trackDesign->average_speed);
tempStream.WriteValue<uint16_t>(_trackDesign->ride_length);
tempStream.WriteValue<uint8_t>(_trackDesign->max_positive_vertical_g);
tempStream.WriteValue<int8_t>(_trackDesign->max_negative_vertical_g);
tempStream.WriteValue<uint8_t>(_trackDesign->max_lateral_g);
tempStream.WriteValue<uint8_t>(_trackDesign->totalAirTime);
tempStream.WriteValue<uint8_t>(_trackDesign->departFlags);
tempStream.WriteValue<uint8_t>(_trackDesign->numberOfTrains);
tempStream.WriteValue<uint8_t>(_trackDesign->numberOfCarsPerTrain);
tempStream.WriteValue<uint8_t>(_trackDesign->minWaitingTime);
tempStream.WriteValue<uint8_t>(_trackDesign->maxWaitingTime);
tempStream.WriteValue<uint8_t>(_trackDesign->operationSetting);
tempStream.WriteValue<int8_t>(_trackDesign->maxSpeed);
tempStream.WriteValue<int8_t>(_trackDesign->averageSpeed);
tempStream.WriteValue<uint16_t>(_trackDesign->rideLength);
tempStream.WriteValue<uint8_t>(_trackDesign->maxPositiveVerticalG);
tempStream.WriteValue<int8_t>(_trackDesign->maxNegativeVerticalG);
tempStream.WriteValue<uint8_t>(_trackDesign->maxLateralG);
tempStream.WriteValue<uint8_t>(
_trackDesign->type == RIDE_TYPE_MINI_GOLF ? _trackDesign->holes : _trackDesign->inversions);
tempStream.WriteValue<uint8_t>(_trackDesign->drops);
tempStream.WriteValue<uint8_t>(_trackDesign->highest_drop_height);
tempStream.WriteValue<uint8_t>(_trackDesign->highestDropHeight);
tempStream.WriteValue<uint8_t>(_trackDesign->excitement);
tempStream.WriteValue<uint8_t>(_trackDesign->intensity);
tempStream.WriteValue<uint8_t>(_trackDesign->nausea);
tempStream.WriteValue<money16>(ToMoney16(_trackDesign->upkeep_cost));
tempStream.WriteArray(_trackDesign->track_spine_colour, Limits::kNumColourSchemes);
tempStream.WriteArray(_trackDesign->track_rail_colour, Limits::kNumColourSchemes);
tempStream.WriteArray(_trackDesign->track_support_colour, Limits::kNumColourSchemes);
tempStream.WriteValue<money16>(ToMoney16(_trackDesign->upkeepCost));
tempStream.WriteArray(_trackDesign->trackSpineColour, Limits::kNumColourSchemes);
tempStream.WriteArray(_trackDesign->trackRailColour, Limits::kNumColourSchemes);
tempStream.WriteArray(_trackDesign->trackSupportColour, Limits::kNumColourSchemes);
tempStream.WriteValue<uint32_t>(_trackDesign->flags2);
tempStream.Write(&_trackDesign->vehicle_object.Entry, sizeof(RCTObjectEntry));
tempStream.WriteValue<uint8_t>(_trackDesign->space_required_x);
tempStream.WriteValue<uint8_t>(_trackDesign->space_required_y);
tempStream.Write(&_trackDesign->vehicleObject.Entry, sizeof(RCTObjectEntry));
tempStream.WriteValue<uint8_t>(_trackDesign->spaceRequiredX);
tempStream.WriteValue<uint8_t>(_trackDesign->spaceRequiredY);
for (auto i = 0; i < RCT2::Limits::kMaxVehicleColours; i++)
{
tempStream.WriteValue<uint8_t>(_trackDesign->vehicle_colours[i].Tertiary);
tempStream.WriteValue<uint8_t>(_trackDesign->vehicleColours[i].Tertiary);
}
tempStream.WriteValue<uint8_t>(_trackDesign->lift_hill_speed | (_trackDesign->num_circuits << 5));
tempStream.WriteValue<uint8_t>(_trackDesign->liftHillSpeed | (_trackDesign->numCircuits << 5));
const auto& rtd = GetRideTypeDescriptor(_trackDesign->type);
if (rtd.HasFlag(RIDE_TYPE_FLAG_IS_MAZE))
{
for (const auto& mazeElement : _trackDesign->maze_elements)
for (const auto& mazeElement : _trackDesign->mazeElements)
{
tempStream.WriteValue<uint32_t>(mazeElement.all);
}
for (const auto& entranceElement : _trackDesign->entrance_elements)
for (const auto& entranceElement : _trackDesign->entranceElements)
{
tempStream.WriteValue<int8_t>(entranceElement.Location.x);
tempStream.WriteValue<int8_t>(entranceElement.Location.y);
@@ -120,7 +120,7 @@ namespace RCT2
}
else
{
for (const auto& trackElement : _trackDesign->track_elements)
for (const auto& trackElement : _trackDesign->trackElements)
{
auto trackType = OpenRCT2TrackTypeToRCT2(trackElement.Type);
if (trackType == TrackElemType::MultiDimInvertedUp90ToFlatQuarterLoop)
@@ -134,7 +134,7 @@ namespace RCT2
tempStream.WriteValue<uint8_t>(0xFF);
for (const auto& entranceElement : _trackDesign->entrance_elements)
for (const auto& entranceElement : _trackDesign->entranceElements)
{
tempStream.WriteValue<uint8_t>(
entranceElement.Location.z == -1 ? static_cast<uint8_t>(0x80) : entranceElement.Location.z);
@@ -147,7 +147,7 @@ namespace RCT2
tempStream.WriteValue<uint8_t>(0xFF);
}
for (const auto& sceneryElement : _trackDesign->scenery_elements)
for (const auto& sceneryElement : _trackDesign->sceneryElements)
{
tempStream.Write(&sceneryElement.scenery_object.Entry, sizeof(RCTObjectEntry));
tempStream.WriteValue<int8_t>(sceneryElement.loc.x / COORDS_XY_STEP);

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

@@ -72,33 +72,33 @@ namespace RCT2
_stream.Read(&td6, 0xA3);
td->type = td6.Type; // 0x00
td->vehicle_type = td6.VehicleType;
td->vehicleType = td6.VehicleType;
td->cost = 0.00_GBP;
td->flags = td6.Flags;
td->ride_mode = static_cast<RideMode>(td6.RideMode);
td->track_flags = 0;
td->colour_scheme = td6.VersionAndColourScheme & 0x3;
td->rideMode = static_cast<RideMode>(td6.RideMode);
td->trackFlags = 0;
td->colourScheme = td6.VersionAndColourScheme & 0x3;
for (auto i = 0; i < Limits::kMaxVehicleColours; ++i)
{
td->vehicle_colours[i].Body = td6.VehicleColours[i].BodyColour;
td->vehicle_colours[i].Trim = td6.VehicleColours[i].TrimColour;
td->vehicle_colours[i].Tertiary = td6.VehicleAdditionalColour[i];
td->vehicleColours[i].Body = td6.VehicleColours[i].BodyColour;
td->vehicleColours[i].Trim = td6.VehicleColours[i].TrimColour;
td->vehicleColours[i].Tertiary = td6.VehicleAdditionalColour[i];
}
td->StationObjectIdentifier = GetStationIdentifierFromStyle(td6.EntranceStyle);
td->total_air_time = td6.TotalAirTime;
td->depart_flags = td6.DepartFlags;
td->number_of_trains = td6.NumberOfTrains;
td->number_of_cars_per_train = td6.NumberOfCarsPerTrain;
td->min_waiting_time = td6.MinWaitingTime;
td->max_waiting_time = td6.MaxWaitingTime;
td->operation_setting = td6.OperationSetting;
td->max_speed = td6.MaxSpeed;
td->average_speed = td6.AverageSpeed;
td->ride_length = td6.RideLength;
td->max_positive_vertical_g = td6.MaxPositiveVerticalG;
td->max_negative_vertical_g = td6.MaxNegativeVerticalG;
td->max_lateral_g = td6.MaxLateralG;
td->stationObjectIdentifier = GetStationIdentifierFromStyle(td6.EntranceStyle);
td->totalAirTime = td6.TotalAirTime;
td->departFlags = td6.DepartFlags;
td->numberOfTrains = td6.NumberOfTrains;
td->numberOfCarsPerTrain = td6.NumberOfCarsPerTrain;
td->minWaitingTime = td6.MinWaitingTime;
td->maxWaitingTime = td6.MaxWaitingTime;
td->operationSetting = td6.OperationSetting;
td->maxSpeed = td6.MaxSpeed;
td->averageSpeed = td6.AverageSpeed;
td->rideLength = td6.RideLength;
td->maxPositiveVerticalG = td6.MaxPositiveVerticalG;
td->maxNegativeVerticalG = td6.MaxNegativeVerticalG;
td->maxLateralG = td6.MaxLateralG;
if (td->type == RIDE_TYPE_MINI_GOLF)
{
@@ -110,23 +110,23 @@ namespace RCT2
}
td->drops = td6.Drops;
td->highest_drop_height = td6.HighestDropHeight;
td->highestDropHeight = td6.HighestDropHeight;
td->excitement = td6.Excitement;
td->intensity = td6.Intensity;
td->nausea = td6.Nausea;
td->upkeep_cost = ToMoney64(td6.UpkeepCost);
td->upkeepCost = ToMoney64(td6.UpkeepCost);
for (auto i = 0; i < Limits::kNumColourSchemes; ++i)
{
td->track_spine_colour[i] = td6.TrackSpineColour[i];
td->track_rail_colour[i] = td6.TrackRailColour[i];
td->track_support_colour[i] = td6.TrackSupportColour[i];
td->trackSpineColour[i] = td6.TrackSpineColour[i];
td->trackRailColour[i] = td6.TrackRailColour[i];
td->trackSupportColour[i] = td6.TrackSupportColour[i];
}
td->flags2 = td6.Flags2;
td->vehicle_object = ObjectEntryDescriptor(td6.VehicleObject);
td->space_required_x = td6.SpaceRequiredX;
td->space_required_y = td6.SpaceRequiredY;
td->lift_hill_speed = td6.LiftHillSpeedNumCircuits & 0b00011111;
td->num_circuits = td6.LiftHillSpeedNumCircuits >> 5;
td->vehicleObject = ObjectEntryDescriptor(td6.VehicleObject);
td->spaceRequiredX = td6.SpaceRequiredX;
td->spaceRequiredY = td6.SpaceRequiredY;
td->liftHillSpeed = td6.LiftHillSpeedNumCircuits & 0b00011111;
td->numCircuits = td6.LiftHillSpeedNumCircuits >> 5;
auto version = static_cast<RCT12TrackDesignVersion>((td6.VersionAndColourScheme >> 2) & 3);
if (version != RCT12TrackDesignVersion::TD6)
@@ -135,7 +135,7 @@ namespace RCT2
return nullptr;
}
td->operation_setting = std::min(td->operation_setting, GetRideTypeDescriptor(td->type).OperatingSettings.MaxValue);
td->operationSetting = std::min(td->operationSetting, GetRideTypeDescriptor(td->type).OperatingSettings.MaxValue);
const auto& rtd = GetRideTypeDescriptor(td->type);
if (rtd.HasFlag(RIDE_TYPE_FLAG_IS_MAZE))
@@ -168,7 +168,7 @@ namespace RCT2
trackElement.Type = trackType;
ConvertFromTD46Flags(trackElement, t6TrackElement.Flags);
td->track_elements.push_back(trackElement);
td->trackElements.push_back(trackElement);
}
TD6EntranceElement t6EntranceElement{};
@@ -181,7 +181,7 @@ namespace RCT2
auto z = (t6EntranceElement.z == -128) ? -1 : t6EntranceElement.z;
entranceElement.Location = TileCoordsXYZD(TileCoordsXY(xy), z, t6EntranceElement.GetDirection());
entranceElement.IsExit = t6EntranceElement.IsExit();
td->entrance_elements.push_back(entranceElement);
td->entranceElements.push_back(entranceElement);
}
}
@@ -198,7 +198,7 @@ namespace RCT2
sceneryElement.flags = t6SceneryElement.Flags;
sceneryElement.primary_colour = t6SceneryElement.PrimaryColour;
sceneryElement.secondary_colour = t6SceneryElement.SecondaryColour;
td->scenery_elements.push_back(std::move(sceneryElement));
td->sceneryElements.push_back(std::move(sceneryElement));
}
td->name = _name;
@@ -213,7 +213,7 @@ namespace RCT2
if (RCT2RideTypeNeedsConversion(td->type))
{
std::scoped_lock<std::mutex> lock(_objectLookupMutex);
auto rawObject = ObjectRepositoryLoadObject(&td->vehicle_object.Entry);
auto rawObject = ObjectRepositoryLoadObject(&td->vehicleObject.Entry);
if (rawObject != nullptr)
{
const auto* rideEntry = static_cast<const RideObjectEntry*>(

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

@@ -106,58 +106,58 @@ ResultWithMessage TrackDesign::CreateTrackDesign(TrackDesignState& tds, const Ri
{
return { false, STR_VEHICLE_UNSUPPORTED_TD6 };
}
vehicle_object = ObjectEntryDescriptor(entry);
vehicleObject = ObjectEntryDescriptor(entry);
}
ride_mode = ride.mode;
colour_scheme = ride.colour_scheme_type & 3;
rideMode = ride.mode;
colourScheme = ride.colour_scheme_type & 3;
for (size_t i = 0; i < std::size(vehicle_colours); i++)
for (size_t i = 0; i < std::size(vehicleColours); i++)
{
vehicle_colours[i] = ride.vehicle_colours[i];
vehicleColours[i] = ride.vehicle_colours[i];
}
for (int32_t i = 0; i < OpenRCT2::Limits::kNumColourSchemes; i++)
{
track_spine_colour[i] = ride.track_colour[i].main;
track_rail_colour[i] = ride.track_colour[i].additional;
track_support_colour[i] = ride.track_colour[i].supports;
trackSpineColour[i] = ride.track_colour[i].main;
trackRailColour[i] = ride.track_colour[i].additional;
trackSupportColour[i] = ride.track_colour[i].supports;
}
depart_flags = ride.depart_flags;
number_of_trains = ride.NumTrains;
number_of_cars_per_train = ride.num_cars_per_train;
min_waiting_time = ride.min_waiting_time;
max_waiting_time = ride.max_waiting_time;
operation_setting = ride.operation_option;
lift_hill_speed = ride.lift_hill_speed;
num_circuits = ride.num_circuits;
departFlags = ride.depart_flags;
numberOfTrains = ride.NumTrains;
numberOfCarsPerTrain = ride.num_cars_per_train;
minWaitingTime = ride.min_waiting_time;
maxWaitingTime = ride.max_waiting_time;
operationSetting = ride.operation_option;
liftHillSpeed = ride.lift_hill_speed;
numCircuits = ride.num_circuits;
StationObjectIdentifier = TrackDesignGetStationObjectIdentifier(ride);
max_speed = static_cast<int8_t>(ride.max_speed / 65536);
average_speed = static_cast<int8_t>(ride.average_speed / 65536);
ride_length = ride.GetTotalLength() / 65536;
max_positive_vertical_g = ride.max_positive_vertical_g / 32;
max_negative_vertical_g = ride.max_negative_vertical_g / 32;
max_lateral_g = ride.max_lateral_g / 32;
stationObjectIdentifier = TrackDesignGetStationObjectIdentifier(ride);
maxSpeed = static_cast<int8_t>(ride.max_speed / 65536);
averageSpeed = static_cast<int8_t>(ride.average_speed / 65536);
rideLength = ride.GetTotalLength() / 65536;
maxPositiveVerticalG = ride.max_positive_vertical_g / 32;
maxNegativeVerticalG = ride.max_negative_vertical_g / 32;
maxLateralG = ride.max_lateral_g / 32;
holes = ride.holes & 0x1F;
inversions = ride.inversions & 0x1F;
inversions |= (ride.sheltered_eighths << 5);
drops = ride.drops;
highest_drop_height = ride.highest_drop_height;
highestDropHeight = ride.highest_drop_height;
uint16_t totalAirTime = (ride.total_air_time * 123) / 1024;
if (totalAirTime > 255)
uint16_t _totalAirTime = (ride.total_air_time * 123) / 1024;
if (_totalAirTime > 255)
{
totalAirTime = 0;
_totalAirTime = 0;
}
total_air_time = static_cast<uint8_t>(totalAirTime);
totalAirTime = static_cast<uint8_t>(_totalAirTime);
excitement = ride.ratings.Excitement / 10;
intensity = ride.ratings.Intensity / 10;
nausea = ride.ratings.Nausea / 10;
upkeep_cost = ride.upkeep_cost;
upkeepCost = ride.upkeep_cost;
flags = 0;
flags2 = 0;
@@ -242,7 +242,7 @@ ResultWithMessage TrackDesign::CreateTrackDesignTrack(TrackDesignState& tds, con
track.SetFlag(TrackDesignTrackElementFlag::IsInverted);
}
track_elements.push_back(track);
trackElements.push_back(track);
if (!TrackBlockGetNext(&trackElement, &trackElement, nullptr, nullptr))
{
@@ -262,7 +262,7 @@ ResultWithMessage TrackDesign::CreateTrackDesignTrack(TrackDesignState& tds, con
trackElement.x = newCoords->x;
trackElement.y = newCoords->y;
if (track_elements.size() > RCT2::Limits::kTD6MaxTrackElements)
if (trackElements.size() > RCT2::Limits::kTD6MaxTrackElements)
{
return { false, STR_TRACK_TOO_LARGE_OR_TOO_MUCH_SCENERY };
}
@@ -330,7 +330,7 @@ ResultWithMessage TrackDesign::CreateTrackDesignTrack(TrackDesignState& tds, con
{
entrance.IsExit = true;
}
entrance_elements.push_back(entrance);
entranceElements.push_back(entrance);
}
}
@@ -343,8 +343,8 @@ ResultWithMessage TrackDesign::CreateTrackDesignTrack(TrackDesignState& tds, con
gMapSelectFlags &= ~MAP_SELECT_FLAG_ENABLE_ARROW;
gMapSelectFlags &= ~MAP_SELECT_FLAG_GREEN;
space_required_x = ((tds.PreviewMax.x - tds.PreviewMin.x) / 32) + 1;
space_required_y = ((tds.PreviewMax.y - tds.PreviewMin.y) / 32) + 1;
spaceRequiredX = ((tds.PreviewMax.x - tds.PreviewMin.x) / 32) + 1;
spaceRequiredY = ((tds.PreviewMax.y - tds.PreviewMin.y) / 32) + 1;
return { true, warningMessage };
}
@@ -382,9 +382,9 @@ ResultWithMessage TrackDesign::CreateTrackDesignMaze(TrackDesignState& tds, cons
maze.x = (x - startLoc.x) / COORDS_XY_STEP;
maze.y = (y - startLoc.y) / COORDS_XY_STEP;
_saveDirection = tileElement->GetDirection();
maze_elements.push_back(maze);
mazeElements.push_back(maze);
if (maze_elements.size() >= 2000)
if (mazeElements.size() >= 2000)
{
return { false, STR_TRACK_TOO_LARGE_OR_TOO_MUCH_SCENERY };
}
@@ -418,7 +418,7 @@ ResultWithMessage TrackDesign::CreateTrackDesignMaze(TrackDesignState& tds, cons
TrackDesignEntranceElement mazeEntrance{};
mazeEntrance.Location = TileCoordsXYZD(CoordsXYZD(entranceOffset, 0, tileElement->GetDirection()));
mazeEntrance.IsExit = false;
entrance_elements.push_back(mazeEntrance);
entranceElements.push_back(mazeEntrance);
location = ride.GetStation().Exit;
if (location.IsNull())
@@ -445,7 +445,7 @@ ResultWithMessage TrackDesign::CreateTrackDesignMaze(TrackDesignState& tds, cons
TrackDesignEntranceElement mazeExit{};
mazeExit.Location = TileCoordsXYZD(CoordsXYZD(exitOffset, 0, tileElement->GetDirection()));
mazeExit.IsExit = true;
entrance_elements.push_back(mazeExit);
entranceElements.push_back(mazeExit);
// Save global vars as they are still used by scenery????
int32_t startZ = tds.Origin.z;
@@ -456,8 +456,8 @@ ResultWithMessage TrackDesign::CreateTrackDesignMaze(TrackDesignState& tds, cons
gMapSelectFlags &= ~MAP_SELECT_FLAG_ENABLE_ARROW;
gMapSelectFlags &= ~MAP_SELECT_FLAG_GREEN;
space_required_x = ((tds.PreviewMax.x - tds.PreviewMin.x) / 32) + 1;
space_required_y = ((tds.PreviewMax.y - tds.PreviewMin.y) / 32) + 1;
spaceRequiredX = ((tds.PreviewMax.x - tds.PreviewMin.x) / 32) + 1;
spaceRequiredY = ((tds.PreviewMax.y - tds.PreviewMin.y) / 32) + 1;
return { true };
}
@@ -489,9 +489,9 @@ CoordsXYE TrackDesign::MazeGetFirstElement(const Ride& ride)
ResultWithMessage TrackDesign::CreateTrackDesignScenery(TrackDesignState& tds)
{
scenery_elements = _trackSavedTileElementsDesc;
sceneryElements = _trackSavedTileElementsDesc;
// Run an element loop
for (auto& scenery : scenery_elements)
for (auto& scenery : sceneryElements)
{
switch (scenery.scenery_object.GetType())
{
@@ -564,49 +564,49 @@ void TrackDesign::Serialise(DataSerialiser& stream)
return;
}
stream << DS_TAG(type);
stream << DS_TAG(vehicle_type);
stream << DS_TAG(vehicleType);
stream << DS_TAG(cost);
stream << DS_TAG(flags);
stream << DS_TAG(ride_mode);
stream << DS_TAG(track_flags);
stream << DS_TAG(colour_scheme);
stream << DS_TAG(vehicle_colours);
stream << DS_TAG(StationObjectIdentifier);
stream << DS_TAG(total_air_time);
stream << DS_TAG(depart_flags);
stream << DS_TAG(number_of_trains);
stream << DS_TAG(number_of_cars_per_train);
stream << DS_TAG(min_waiting_time);
stream << DS_TAG(max_waiting_time);
stream << DS_TAG(operation_setting);
stream << DS_TAG(max_speed);
stream << DS_TAG(average_speed);
stream << DS_TAG(ride_length);
stream << DS_TAG(max_positive_vertical_g);
stream << DS_TAG(max_negative_vertical_g);
stream << DS_TAG(max_lateral_g);
stream << DS_TAG(rideMode);
stream << DS_TAG(trackFlags);
stream << DS_TAG(colourScheme);
stream << DS_TAG(vehicleColours);
stream << DS_TAG(stationObjectIdentifier);
stream << DS_TAG(totalAirTime);
stream << DS_TAG(departFlags);
stream << DS_TAG(numberOfTrains);
stream << DS_TAG(numberOfCarsPerTrain);
stream << DS_TAG(minWaitingTime);
stream << DS_TAG(maxWaitingTime);
stream << DS_TAG(operationSetting);
stream << DS_TAG(maxSpeed);
stream << DS_TAG(averageSpeed);
stream << DS_TAG(rideLength);
stream << DS_TAG(maxPositiveVerticalG);
stream << DS_TAG(maxNegativeVerticalG);
stream << DS_TAG(maxLateralG);
stream << DS_TAG(inversions);
stream << DS_TAG(holes);
stream << DS_TAG(drops);
stream << DS_TAG(highest_drop_height);
stream << DS_TAG(highestDropHeight);
stream << DS_TAG(excitement);
stream << DS_TAG(intensity);
stream << DS_TAG(nausea);
stream << DS_TAG(upkeep_cost);
stream << DS_TAG(track_spine_colour);
stream << DS_TAG(track_rail_colour);
stream << DS_TAG(track_support_colour);
stream << DS_TAG(upkeepCost);
stream << DS_TAG(trackSpineColour);
stream << DS_TAG(trackRailColour);
stream << DS_TAG(trackSupportColour);
stream << DS_TAG(flags2);
stream << DS_TAG(vehicle_object);
stream << DS_TAG(space_required_x);
stream << DS_TAG(space_required_y);
stream << DS_TAG(lift_hill_speed);
stream << DS_TAG(num_circuits);
stream << DS_TAG(vehicleObject);
stream << DS_TAG(spaceRequiredX);
stream << DS_TAG(spaceRequiredY);
stream << DS_TAG(liftHillSpeed);
stream << DS_TAG(numCircuits);
stream << DS_TAG(maze_elements);
stream << DS_TAG(track_elements);
stream << DS_TAG(entrance_elements);
stream << DS_TAG(scenery_elements);
stream << DS_TAG(mazeElements);
stream << DS_TAG(trackElements);
stream << DS_TAG(entranceElements);
stream << DS_TAG(sceneryElements);
stream << DS_TAG(name);
}
@@ -637,13 +637,13 @@ static void TrackDesignLoadSceneryObjects(TrackDesign* td6)
objectManager.UnloadAllTransient();
// Load ride object
if (td6->vehicle_object.HasValue())
if (td6->vehicleObject.HasValue())
{
objectManager.LoadObject(td6->vehicle_object);
objectManager.LoadObject(td6->vehicleObject);
}
// Load scenery objects
for (const auto& scenery : td6->scenery_elements)
for (const auto& scenery : td6->sceneryElements)
{
if (scenery.scenery_object.HasValue())
{
@@ -765,7 +765,7 @@ static std::optional<TrackSceneryEntry> TrackDesignPlaceSceneryElementGetEntry(c
static void TrackDesignMirrorScenery(TrackDesign* td6)
{
auto& objectMgr = OpenRCT2::GetContext()->GetObjectManager();
for (auto& scenery : td6->scenery_elements)
for (auto& scenery : td6->sceneryElements)
{
auto entryInfo = TrackDesignPlaceSceneryElementGetEntry(scenery);
if (!entryInfo)
@@ -874,7 +874,7 @@ static void TrackDesignMirrorScenery(TrackDesign* td6)
static void TrackDesignMirrorEntrances(TrackDesign& td)
{
for (auto& entrance : td.entrance_elements)
for (auto& entrance : td.entranceElements)
{
entrance.Location.y = -entrance.Location.y;
if (entrance.Location.direction & 1)
@@ -890,7 +890,7 @@ static void TrackDesignMirrorEntrances(TrackDesign& td)
*/
static void TrackDesignMirrorRide(TrackDesign* td6)
{
for (auto& track : td6->track_elements)
for (auto& track : td6->trackElements)
{
const auto& ted = GetTrackElementDescriptor(track.Type);
track.Type = ted.MirrorElement;
@@ -908,7 +908,7 @@ static constexpr uint8_t maze_segment_mirror_map[] = {
*/
static void TrackDesignMirrorMaze(TrackDesign* td6)
{
for (auto& maze : td6->maze_elements)
for (auto& maze : td6->mazeElements)
{
maze.y = -maze.y;
@@ -1343,7 +1343,7 @@ static GameActions::Result TrackDesignPlaceAllScenery(
static std::optional<GameActions::Result> TrackDesignPlaceEntrances(
TrackDesignState& tds, const TrackDesign& td, CoordsXYZ newCoords, RideId rideId, money64& totalCost)
{
for (const auto& entrance : td.entrance_elements)
for (const auto& entrance : td.entranceElements)
{
auto rotation = _currentTrackPieceDirection & 3;
CoordsXY entranceMapPos = entrance.Location.ToCoordsXY();
@@ -1457,7 +1457,7 @@ static GameActions::Result TrackDesignPlaceMaze(
tds.PlaceZ = 0;
money64 totalCost = 0;
for (const auto& maze_element : td.maze_elements)
for (const auto& maze_element : td.mazeElements)
{
uint8_t rotation = _currentTrackPieceDirection & 3;
CoordsXY mazeMapPos = TileCoordsXY(maze_element.x, maze_element.y).ToCoordsXY();
@@ -1585,7 +1585,7 @@ static GameActions::Result TrackDesignPlaceRide(TrackDesignState& tds, TrackDesi
// Track elements
auto newCoords = origin;
for (const auto& track : td6->track_elements)
for (const auto& track : td6->trackElements)
{
auto trackType = track.Type;
const auto& ted = GetTrackElementDescriptor(trackType);
@@ -1810,7 +1810,7 @@ static GameActions::Result TrackDesignPlaceVirtual(
}
// Scenery elements
auto sceneryPlaceRes = TrackDesignPlaceAllScenery(tds, td6->scenery_elements, coords.direction);
auto sceneryPlaceRes = TrackDesignPlaceAllScenery(tds, td6->sceneryElements, coords.direction);
if (sceneryPlaceRes.Error != GameActions::Status::Ok)
{
return sceneryPlaceRes;
@@ -1903,7 +1903,7 @@ static bool TrackDesignPlacePreview(TrackDesignState& tds, TrackDesign* td6, mon
auto& gameState = GetGameState();
auto& objManager = GetContext()->GetObjectManager();
auto entry_index = objManager.GetLoadedObjectEntryIndex(td6->vehicle_object);
auto entry_index = objManager.GetLoadedObjectEntryIndex(td6->vehicleObject);
RideId rideIndex;
uint8_t rideCreateFlags = GAME_COMMAND_FLAG_APPLY | GAME_COMMAND_FLAG_ALLOW_DURING_PAUSED | GAME_COMMAND_FLAG_NO_SPEND;
@@ -1918,7 +1918,7 @@ static bool TrackDesignPlacePreview(TrackDesignState& tds, TrackDesign* td6, mon
ride->custom_name = {};
ride->entrance_style = objManager.GetLoadedObjectEntryIndex(td6->StationObjectIdentifier);
ride->entrance_style = objManager.GetLoadedObjectEntryIndex(td6->stationObjectIdentifier);
if (ride->entrance_style == OBJECT_ENTRY_INDEX_NULL)
{
ride->entrance_style = gameState.LastEntranceStyle;
@@ -1926,9 +1926,9 @@ static bool TrackDesignPlacePreview(TrackDesignState& tds, TrackDesign* td6, mon
for (int32_t i = 0; i < OpenRCT2::Limits::kNumColourSchemes; i++)
{
ride->track_colour[i].main = td6->track_spine_colour[i];
ride->track_colour[i].additional = td6->track_rail_colour[i];
ride->track_colour[i].supports = td6->track_support_colour[i];
ride->track_colour[i].main = td6->trackSpineColour[i];
ride->track_colour[i].additional = td6->trackRailColour[i];
ride->track_colour[i].supports = td6->trackSupportColour[i];
}
// Flat rides need their vehicle colours loaded for display
@@ -1937,7 +1937,7 @@ static bool TrackDesignPlacePreview(TrackDesignState& tds, TrackDesign* td6, mon
{
for (size_t i = 0; i < std::size(ride->vehicle_colours); i++)
{
ride->vehicle_colours[i] = td6->vehicle_colours[i];
ride->vehicle_colours[i] = td6->vehicleColours[i];
}
}
@@ -2022,7 +2022,7 @@ void TrackDesignDrawPreview(TrackDesign* td6, uint8_t* pixels)
return;
}
td6->cost = cost;
td6->track_flags = flags & 7;
td6->trackFlags = flags & 7;
CoordsXYZ centre = { (tds.PreviewMin.x + tds.PreviewMax.x) / 2 + 16, (tds.PreviewMin.y + tds.PreviewMax.y) / 2 + 16,
(tds.PreviewMin.z + tds.PreviewMax.z) / 2 };

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

@@ -119,49 +119,49 @@ enum class RideMode : uint8_t;
struct TrackDesign
{
uint8_t type;
uint8_t vehicle_type;
uint8_t vehicleType;
money64 cost;
uint32_t flags;
RideMode ride_mode;
uint8_t track_flags;
uint8_t colour_scheme;
std::array<VehicleColour, OpenRCT2::Limits::kMaxVehicleColours> vehicle_colours;
u8string StationObjectIdentifier{};
uint8_t total_air_time;
uint8_t depart_flags;
uint8_t number_of_trains;
uint8_t number_of_cars_per_train;
uint8_t min_waiting_time;
uint8_t max_waiting_time;
uint8_t operation_setting;
int8_t max_speed;
int8_t average_speed;
uint16_t ride_length;
uint8_t max_positive_vertical_g;
int8_t max_negative_vertical_g;
uint8_t max_lateral_g;
RideMode rideMode;
uint8_t trackFlags;
uint8_t colourScheme;
std::array<VehicleColour, OpenRCT2::Limits::kMaxVehicleColours> vehicleColours;
u8string stationObjectIdentifier{};
uint8_t totalAirTime;
uint8_t departFlags;
uint8_t numberOfTrains;
uint8_t numberOfCarsPerTrain;
uint8_t minWaitingTime;
uint8_t maxWaitingTime;
uint8_t operationSetting;
int8_t maxSpeed;
int8_t averageSpeed;
uint16_t rideLength;
uint8_t maxPositiveVerticalG;
int8_t maxNegativeVerticalG;
uint8_t maxLateralG;
uint8_t inversions;
uint8_t holes;
uint8_t drops;
uint8_t highest_drop_height;
uint8_t highestDropHeight;
uint8_t excitement;
uint8_t intensity;
uint8_t nausea;
money64 upkeep_cost;
uint8_t track_spine_colour[OpenRCT2::Limits::kNumColourSchemes];
uint8_t track_rail_colour[OpenRCT2::Limits::kNumColourSchemes];
uint8_t track_support_colour[OpenRCT2::Limits::kNumColourSchemes];
money64 upkeepCost;
uint8_t trackSpineColour[OpenRCT2::Limits::kNumColourSchemes];
uint8_t trackRailColour[OpenRCT2::Limits::kNumColourSchemes];
uint8_t trackSupportColour[OpenRCT2::Limits::kNumColourSchemes];
uint32_t flags2;
ObjectEntryDescriptor vehicle_object;
uint8_t space_required_x;
uint8_t space_required_y;
uint8_t lift_hill_speed;
uint8_t num_circuits;
ObjectEntryDescriptor vehicleObject;
uint8_t spaceRequiredX;
uint8_t spaceRequiredY;
uint8_t liftHillSpeed;
uint8_t numCircuits;
std::vector<TrackDesignMazeElement> maze_elements;
std::vector<TrackDesignTrackElement> track_elements;
std::vector<TrackDesignEntranceElement> entrance_elements;
std::vector<TrackDesignSceneryElement> scenery_elements;
std::vector<TrackDesignMazeElement> mazeElements;
std::vector<TrackDesignTrackElement> trackElements;
std::vector<TrackDesignEntranceElement> entranceElements;
std::vector<TrackDesignSceneryElement> sceneryElements;
std::string name;

2
src/openrct2/ride/TrackDesignRepository.cpp
View File

@@ -80,7 +80,7 @@ public:
item.Name = GetNameFromTrackPath(path);
item.Path = path;
item.RideType = td6->type;
item.ObjectEntry = std::string(td6->vehicle_object.Entry.name, 8);
item.ObjectEntry = std::string(td6->vehicleObject.Entry.name, 8);
item.Flags = 0;
if (IsTrackReadOnly(path))
{