mirrors/OpenRCT2
1
0
Fork 0
mirror of https://github.com/OpenRCT2/OpenRCT2 synced 2025-12-21 23:03:04 +01:00
Code Issues Releases Wiki Activity

Do not use td6 as a variable name for TrackDesign

Browse Source
This commit is contained in:
Gymnasiast
2024-07-02 19:29:19 +02:00
parent 9a616cd055
commit bc13b46f96
6 changed files with 102 additions and 102 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -169,8 +169,8 @@ static Widget window_install_track_widgets[] = {
screenPos = windowPos + ScreenCoordsXY{ widget->midX(), widget->bottom - 12 };
// Warnings
const TrackDesign* td6 = _trackDesign.get();
if (td6->trackFlags & TRACK_DESIGN_FLAG_SCENERY_UNAVAILABLE)
const TrackDesign* td = _trackDesign.get();
if (td->trackFlags & TRACK_DESIGN_FLAG_SCENERY_UNAVAILABLE)
{
if (!gTrackDesignSceneryToggle)
{
@@ -198,17 +198,17 @@ static Widget window_install_track_widgets[] = {
{
auto ft = Formatter();
const auto* objectEntry = ObjectManagerLoadObject(&td6->vehicleObject.Entry);
const auto* objectEntry = ObjectManagerLoadObject(&td->vehicleObject.Entry);
if (objectEntry != nullptr)
{
auto groupIndex = ObjectManagerGetLoadedObjectEntryIndex(objectEntry);
auto rideName = GetRideNaming(td6->type, *GetRideEntryByIndex(groupIndex));
auto rideName = GetRideNaming(td->type, *GetRideEntryByIndex(groupIndex));
ft.Add<StringId>(rideName.Name);
}
else
{
// Fall back on the technical track name if the vehicle object cannot be loaded
ft.Add<StringId>(GetRideTypeDescriptor(td6->type).Naming.Name);
ft.Add<StringId>(GetRideTypeDescriptor(td->type).Naming.Name);
}
DrawTextBasic(dpi, screenPos, STR_TRACK_DESIGN_TYPE, ft);
@@ -217,34 +217,34 @@ static Widget window_install_track_widgets[] = {
// Stats
{
fixed32_2dp rating = td6->statistics.excitement * 10;
fixed32_2dp rating = td->statistics.excitement * 10;
auto ft = Formatter();
ft.Add<int32_t>(rating);
DrawTextBasic(dpi, screenPos, STR_TRACK_LIST_EXCITEMENT_RATING, ft);
screenPos.y += kListRowHeight;
}
{
fixed32_2dp rating = td6->statistics.intensity * 10;
fixed32_2dp rating = td->statistics.intensity * 10;
auto ft = Formatter();
ft.Add<int32_t>(rating);
DrawTextBasic(dpi, screenPos, STR_TRACK_LIST_INTENSITY_RATING, ft);
screenPos.y += kListRowHeight;
}
{
fixed32_2dp rating = td6->statistics.nausea * 10;
fixed32_2dp rating = td->statistics.nausea * 10;
auto ft = Formatter();
ft.Add<int32_t>(rating);
DrawTextBasic(dpi, screenPos, STR_TRACK_LIST_NAUSEA_RATING, ft);
screenPos.y += kListRowHeight + 4;
}
const auto& rtd = GetRideTypeDescriptor(td6->type);
const auto& rtd = GetRideTypeDescriptor(td->type);
if (!rtd.HasFlag(RIDE_TYPE_FLAG_IS_MAZE))
{
if (td6->type == RIDE_TYPE_MINI_GOLF)
if (td->type == RIDE_TYPE_MINI_GOLF)
{
// Holes
uint16_t holes = td6->statistics.holes & 0x1F;
uint16_t holes = td->statistics.holes & 0x1F;
auto ft = Formatter();
ft.Add<uint16_t>(holes);
DrawTextBasic(dpi, screenPos, STR_HOLES, ft);
@@ -254,7 +254,7 @@ static Widget window_install_track_widgets[] = {
{
// Maximum speed
{
uint16_t speed = ((td6->statistics.maxSpeed << 16) * 9) >> 18;
uint16_t speed = ((td->statistics.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->statistics.averageSpeed << 16) * 9) >> 18;
uint16_t speed = ((td->statistics.averageSpeed << 16) * 9) >> 18;
auto ft = Formatter();
ft.Add<uint16_t>(speed);
DrawTextBasic(dpi, screenPos, STR_AVERAGE_SPEED, ft);
@@ -273,16 +273,16 @@ static Widget window_install_track_widgets[] = {
// Ride length
auto ft = Formatter();
ft.Add<StringId>(STR_RIDE_LENGTH_ENTRY);
ft.Add<uint16_t>(td6->statistics.rideLength);
ft.Add<uint16_t>(td->statistics.rideLength);
DrawTextEllipsised(dpi, screenPos, 214, STR_TRACK_LIST_RIDE_LENGTH, ft);
screenPos.y += kListRowHeight;
}
if (GetRideTypeDescriptor(td6->type).HasFlag(RIDE_TYPE_FLAG_HAS_G_FORCES))
if (GetRideTypeDescriptor(td->type).HasFlag(RIDE_TYPE_FLAG_HAS_G_FORCES))
{
// Maximum positive vertical Gs
{
int32_t gForces = td6->statistics.maxPositiveVerticalG * 32;
int32_t gForces = td->statistics.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->statistics.maxNegativeVerticalG * 32;
int32_t gForces = td->statistics.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->statistics.maxLateralG * 32;
int32_t gForces = td->statistics.maxLateralG * 32;
auto ft = Formatter();
ft.Add<int32_t>(gForces);
DrawTextBasic(dpi, screenPos, STR_MAX_LATERAL_G, ft);
screenPos.y += kListRowHeight;
}
if (td6->statistics.totalAirTime != 0)
if (td->statistics.totalAirTime != 0)
{
// Total air time
int32_t airTime = td6->statistics.totalAirTime * 25;
int32_t airTime = td->statistics.totalAirTime * 25;
auto ft = Formatter();
ft.Add<int32_t>(airTime);
DrawTextBasic(dpi, screenPos, STR_TOTAL_AIR_TIME, ft);
@@ -315,10 +315,10 @@ static Widget window_install_track_widgets[] = {
}
}
if (GetRideTypeDescriptor(td6->type).HasFlag(RIDE_TYPE_FLAG_HAS_DROPS))
if (GetRideTypeDescriptor(td->type).HasFlag(RIDE_TYPE_FLAG_HAS_DROPS))
{
// Drops
uint16_t drops = td6->statistics.drops & 0x3F;
uint16_t drops = td->statistics.drops & 0x3F;
auto ft = Formatter();
ft.Add<uint16_t>(drops);
DrawTextBasic(dpi, screenPos, STR_DROPS, ft);
@@ -329,9 +329,9 @@ static Widget window_install_track_widgets[] = {
screenPos.y += kListRowHeight;
}
if (td6->type != RIDE_TYPE_MINI_GOLF)
if (td->type != RIDE_TYPE_MINI_GOLF)
{
uint16_t inversions = td6->statistics.inversions & 0x1F;
uint16_t inversions = td->statistics.inversions & 0x1F;
if (inversions != 0)
{
// Inversions
@@ -343,20 +343,20 @@ static Widget window_install_track_widgets[] = {
}
screenPos.y += 4;
if (!td6->statistics.spaceRequired.IsNull())
if (!td->statistics.spaceRequired.IsNull())
{
// Space required
auto ft = Formatter();
ft.Add<uint16_t>(td6->statistics.spaceRequired.x);
ft.Add<uint16_t>(td6->statistics.spaceRequired.y);
ft.Add<uint16_t>(td->statistics.spaceRequired.x);
ft.Add<uint16_t>(td->statistics.spaceRequired.y);
DrawTextBasic(dpi, screenPos, STR_TRACK_LIST_SPACE_REQUIRED, ft);
screenPos.y += kListRowHeight;
}
if (td6->cost != 0)
if (td->cost != 0)
{
auto ft = Formatter();
ft.Add<money64>(td6->cost);
ft.Add<money64>(td->cost);
DrawTextBasic(dpi, screenPos, STR_TRACK_LIST_COST_AROUND, ft);
}
}

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

@@ -350,7 +350,7 @@ static Widget _trackPlaceWidgets[] = {
_trackDesign = std::move(trackDesign);
}
void DrawMiniPreview(TrackDesign* td6)
void DrawMiniPreview(TrackDesign* td)
{
ClearMiniPreview();
@@ -366,14 +366,14 @@ static Widget _trackPlaceWidgets[] = {
origin.y -= ((max.y + min.y) >> 6) * COORDS_XY_STEP;
}
const auto& rtd = GetRideTypeDescriptor(td6->type);
const auto& rtd = GetRideTypeDescriptor(td->type);
if (rtd.HasFlag(RIDE_TYPE_FLAG_IS_MAZE))
{
DrawMiniPreviewMaze(td6, pass, origin, min, max);
DrawMiniPreviewMaze(td, pass, origin, min, max);
}
else
{
DrawMiniPreviewTrack(td6, pass, origin, min, max);
DrawMiniPreviewTrack(td, pass, origin, min, max);
}
}
}
@@ -436,9 +436,9 @@ static Widget _trackPlaceWidgets[] = {
}
void DrawMiniPreviewEntrances(
const TrackDesign& td6, int32_t pass, const CoordsXY& origin, CoordsXY& min, CoordsXY& max, Direction rotation)
const TrackDesign& td, int32_t pass, const CoordsXY& origin, CoordsXY& min, CoordsXY& max, Direction rotation)
{
for (const auto& entrance : td6.entranceElements)
for (const auto& entrance : td.entranceElements)
{
auto rotatedAndOffsetEntrance = origin + entrance.location.ToCoordsXY().Rotate(rotation);
@@ -468,13 +468,13 @@ static Widget _trackPlaceWidgets[] = {
}
}
void DrawMiniPreviewTrack(TrackDesign* td6, int32_t pass, const CoordsXY& origin, CoordsXY& min, CoordsXY& max)
void DrawMiniPreviewTrack(TrackDesign* td, int32_t pass, const CoordsXY& origin, CoordsXY& min, CoordsXY& max)
{
const uint8_t rotation = (_currentTrackPieceDirection + GetCurrentRotation()) & 3;
CoordsXY curTrackStart = origin;
uint8_t curTrackRotation = rotation;
for (const auto& trackElement : td6->trackElements)
for (const auto& trackElement : td->trackElements)
{
// Follow a single track piece shape
const auto& ted = GetTrackElementDescriptor(trackElement.type);
@@ -539,13 +539,13 @@ static Widget _trackPlaceWidgets[] = {
}
}
DrawMiniPreviewEntrances(*td6, pass, origin, min, max, rotation);
DrawMiniPreviewEntrances(*td, pass, origin, min, max, rotation);
}
void DrawMiniPreviewMaze(TrackDesign* td6, int32_t pass, const CoordsXY& origin, CoordsXY& min, CoordsXY& max)
void DrawMiniPreviewMaze(TrackDesign* td, int32_t pass, const CoordsXY& origin, CoordsXY& min, CoordsXY& max)
{
uint8_t rotation = (_currentTrackPieceDirection + GetCurrentRotation()) & 3;
for (const auto& mazeElement : td6->mazeElements)
for (const auto& mazeElement : td->mazeElements)
{
auto rotatedMazeCoords = origin + mazeElement.location.ToCoordsXY().Rotate(rotation);
@@ -575,7 +575,7 @@ static Widget _trackPlaceWidgets[] = {
}
}
DrawMiniPreviewEntrances(*td6, pass, origin, min, max, rotation);
DrawMiniPreviewEntrances(*td, pass, origin, min, max, rotation);
}
ScreenCoordsXY DrawMiniPreviewGetPixelPosition(const CoordsXY& location)

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

@@ -69,7 +69,7 @@ GameActions::Result TrackDesignAction::Query() const
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,
// Force a fallback if the entry is not invented yet a track design of it is selected,
// which can happen in select-by-track-type mode
if (!RideEntryIsInvented(entryIndex) && !gameState.Cheats.IgnoreResearchStatus)
{

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

@@ -622,19 +622,19 @@ std::unique_ptr<TrackDesign> TrackDesignImport(const utf8* path)
*
* rct2: 0x006ABDB0
*/
static void TrackDesignLoadSceneryObjects(TrackDesign* td6)
static void TrackDesignLoadSceneryObjects(TrackDesign* td)
{
auto& objectManager = OpenRCT2::GetContext()->GetObjectManager();
objectManager.UnloadAllTransient();
// Load ride object
if (td6->vehicleObject.HasValue())
if (td->vehicleObject.HasValue())
{
objectManager.LoadObject(td6->vehicleObject);
objectManager.LoadObject(td->vehicleObject);
}
// Load scenery objects
for (const auto& scenery : td6->sceneryElements)
for (const auto& scenery : td->sceneryElements)
{
if (scenery.sceneryObject.HasValue())
{
@@ -753,10 +753,10 @@ static std::optional<TrackSceneryEntry> TrackDesignPlaceSceneryElementGetEntry(c
*
* rct2: 0x006D247A
*/
static void TrackDesignMirrorScenery(TrackDesign* td6)
static void TrackDesignMirrorScenery(TrackDesign* td)
{
auto& objectMgr = OpenRCT2::GetContext()->GetObjectManager();
for (auto& scenery : td6->sceneryElements)
for (auto& scenery : td->sceneryElements)
{
auto entryInfo = TrackDesignPlaceSceneryElementGetEntry(scenery);
if (!entryInfo)
@@ -871,9 +871,9 @@ static void TrackDesignMirrorEntrances(TrackDesign& td)
*
* rct2: 0x006D2443
*/
static void TrackDesignMirrorRide(TrackDesign* td6)
static void TrackDesignMirrorRide(TrackDesign* td)
{
for (auto& track : td6->trackElements)
for (auto& track : td->trackElements)
{
const auto& ted = GetTrackElementDescriptor(track.type);
track.type = ted.MirrorElement;
@@ -889,9 +889,9 @@ static constexpr uint8_t maze_segment_mirror_map[] = {
*
* rct2: 0x006D25FA
*/
static void TrackDesignMirrorMaze(TrackDesign* td6)
static void TrackDesignMirrorMaze(TrackDesign* td)
{
for (auto& maze : td6->mazeElements)
for (auto& maze : td->mazeElements)
{
maze.location.y = -maze.location.y;
@@ -910,19 +910,19 @@ static void TrackDesignMirrorMaze(TrackDesign* td6)
*
* rct2: 0x006D2436
*/
void TrackDesignMirror(TrackDesign* td6)
void TrackDesignMirror(TrackDesign* td)
{
const auto& rtd = GetRideTypeDescriptor(td6->type);
const auto& rtd = GetRideTypeDescriptor(td->type);
if (rtd.HasFlag(RIDE_TYPE_FLAG_IS_MAZE))
{
TrackDesignMirrorMaze(td6);
TrackDesignMirrorMaze(td);
}
else
{
TrackDesignMirrorRide(td6);
TrackDesignMirrorRide(td);
}
TrackDesignMirrorEntrances(*td6);
TrackDesignMirrorScenery(td6);
TrackDesignMirrorEntrances(*td);
TrackDesignMirrorScenery(td);
}
static void TrackDesignAddSelectedTile(const CoordsXY& coords)
@@ -1548,7 +1548,7 @@ static GameActions::Result TrackDesignPlaceMaze(
return res;
}
static GameActions::Result TrackDesignPlaceRide(TrackDesignState& tds, TrackDesign* td6, const CoordsXYZ& origin, Ride& ride)
static GameActions::Result TrackDesignPlaceRide(TrackDesignState& tds, TrackDesign* td, const CoordsXYZ& origin, Ride& ride)
{
tds.origin = origin;
if (tds.placeOperation == TrackPlaceOperation::drawOutlines)
@@ -1564,7 +1564,7 @@ static GameActions::Result TrackDesignPlaceRide(TrackDesignState& tds, TrackDesi
// Track elements
auto newCoords = origin;
for (const auto& track : td6->trackElements)
for (const auto& track : td->trackElements)
{
auto trackType = track.type;
const auto& ted = GetTrackElementDescriptor(trackType);
@@ -1710,7 +1710,7 @@ static GameActions::Result TrackDesignPlaceRide(TrackDesignState& tds, TrackDesi
}
}
auto result = TrackDesignPlaceEntrances(tds, *td6, newCoords, ride.id, totalCost);
auto result = TrackDesignPlaceEntrances(tds, *td, newCoords, ride.id, totalCost);
if (result.has_value())
{
return result.value();
@@ -1742,7 +1742,7 @@ static GameActions::Result TrackDesignPlaceRide(TrackDesignState& tds, TrackDesi
* rct2: 0x006D01B3
*/
static GameActions::Result TrackDesignPlaceVirtual(
TrackDesignState& tds, TrackDesign* td6, TrackPlaceOperation ptdOperation, bool placeScenery, Ride& ride,
TrackDesignState& tds, TrackDesign* td, TrackPlaceOperation ptdOperation, bool placeScenery, Ride& ride,
const CoordsXYZD& coords, bool isReplay = false)
{
_trackDesignPlaceStateSceneryUnavailable = false;
@@ -1771,14 +1771,14 @@ static GameActions::Result TrackDesignPlaceVirtual(
_currentTrackPieceDirection = coords.direction;
GameActions::Result trackPlaceRes;
const auto& rtd = GetRideTypeDescriptor(td6->type);
const auto& rtd = GetRideTypeDescriptor(td->type);
if (rtd.HasFlag(RIDE_TYPE_FLAG_IS_MAZE))
{
trackPlaceRes = TrackDesignPlaceMaze(tds, *td6, coords, ride);
trackPlaceRes = TrackDesignPlaceMaze(tds, *td, coords, ride);
}
else
{
trackPlaceRes = TrackDesignPlaceRide(tds, td6, coords, ride);
trackPlaceRes = TrackDesignPlaceRide(tds, td, coords, ride);
}
_currentRideIndex = savedRideId;
_currentTrackPieceDirection = savedTrackPieceDirection;
@@ -1789,7 +1789,7 @@ static GameActions::Result TrackDesignPlaceVirtual(
}
// Scenery elements
auto sceneryPlaceRes = TrackDesignPlaceAllScenery(tds, td6->sceneryElements, coords.direction);
auto sceneryPlaceRes = TrackDesignPlaceAllScenery(tds, td->sceneryElements, coords.direction);
if (sceneryPlaceRes.Error != GameActions::Status::Ok)
{
return sceneryPlaceRes;
@@ -1810,7 +1810,7 @@ static GameActions::Result TrackDesignPlaceVirtual(
return res;
}
GameActions::Result TrackDesignPlace(TrackDesign* td6, uint32_t flags, bool placeScenery, Ride& ride, const CoordsXYZD& coords)
GameActions::Result TrackDesignPlace(TrackDesign* td, uint32_t flags, bool placeScenery, Ride& ride, const CoordsXYZD& coords)
{
TrackPlaceOperation ptdOperation = (flags & GAME_COMMAND_FLAG_APPLY) != 0 ? TrackPlaceOperation::place
: TrackPlaceOperation::placeQuery;
@@ -1821,33 +1821,33 @@ GameActions::Result TrackDesignPlace(TrackDesign* td6, uint32_t flags, bool plac
bool isReplay = flags & GAME_COMMAND_FLAG_REPLAY;
TrackDesignState tds{};
return TrackDesignPlaceVirtual(tds, td6, ptdOperation, placeScenery, ride, coords, isReplay);
return TrackDesignPlaceVirtual(tds, td, ptdOperation, placeScenery, ride, coords, isReplay);
}
void TrackDesignPreviewRemoveGhosts(TrackDesign* td6, Ride& ride, const CoordsXYZD& coords)
void TrackDesignPreviewRemoveGhosts(TrackDesign* td, Ride& ride, const CoordsXYZD& coords)
{
TrackDesignState tds{};
TrackDesignPlaceVirtual(tds, td6, TrackPlaceOperation::removeGhost, true, ride, coords);
TrackDesignPlaceVirtual(tds, td, TrackPlaceOperation::removeGhost, true, ride, coords);
}
void TrackDesignPreviewDrawOutlines(TrackDesignState& tds, TrackDesign* td6, Ride& ride, const CoordsXYZD& coords)
void TrackDesignPreviewDrawOutlines(TrackDesignState& tds, TrackDesign* td, Ride& ride, const CoordsXYZD& coords)
{
TrackDesignPlaceVirtual(tds, td6, TrackPlaceOperation::drawOutlines, true, ride, coords);
TrackDesignPlaceVirtual(tds, td, TrackPlaceOperation::drawOutlines, true, ride, coords);
}
static int32_t TrackDesignGetZPlacement(TrackDesignState& tds, TrackDesign* td6, Ride& ride, const CoordsXYZD& coords)
static int32_t TrackDesignGetZPlacement(TrackDesignState& tds, TrackDesign* td, Ride& ride, const CoordsXYZD& coords)
{
TrackDesignPlaceVirtual(tds, td6, TrackPlaceOperation::getPlaceZ, true, ride, coords);
TrackDesignPlaceVirtual(tds, td, TrackPlaceOperation::getPlaceZ, true, ride, coords);
// Change from vanilla: originally, _trackDesignPlaceSceneryZ was not subtracted
// from _trackDesignPlaceZ, causing bug #259.
return tds.placeZ - tds.placeSceneryZ;
}
int32_t TrackDesignGetZPlacement(TrackDesign* td6, Ride& ride, const CoordsXYZD& coords)
int32_t TrackDesignGetZPlacement(TrackDesign* td, Ride& ride, const CoordsXYZD& coords)
{
TrackDesignState tds{};
return TrackDesignGetZPlacement(tds, td6, ride, coords);
return TrackDesignGetZPlacement(tds, td, ride, coords);
}
static money64 TrackDesignCreateRide(int32_t type, int32_t subType, int32_t flags, RideId* outRideIndex)
@@ -1875,18 +1875,18 @@ static money64 TrackDesignCreateRide(int32_t type, int32_t subType, int32_t flag
* ebx = ride_id
* cost = edi
*/
static bool TrackDesignPlacePreview(TrackDesignState& tds, TrackDesign* td6, money64* cost, Ride** outRide, uint8_t* flags)
static bool TrackDesignPlacePreview(TrackDesignState& tds, TrackDesign* td, money64* cost, Ride** outRide, uint8_t* flags)
{
*outRide = nullptr;
*flags = 0;
auto& gameState = GetGameState();
auto& objManager = GetContext()->GetObjectManager();
auto entry_index = objManager.GetLoadedObjectEntryIndex(td6->vehicleObject);
auto entry_index = objManager.GetLoadedObjectEntryIndex(td->vehicleObject);
RideId rideIndex;
uint8_t rideCreateFlags = GAME_COMMAND_FLAG_APPLY | GAME_COMMAND_FLAG_ALLOW_DURING_PAUSED | GAME_COMMAND_FLAG_NO_SPEND;
if (TrackDesignCreateRide(td6->type, entry_index, rideCreateFlags, &rideIndex) == kMoney64Undefined)
if (TrackDesignCreateRide(td->type, entry_index, rideCreateFlags, &rideIndex) == kMoney64Undefined)
{
return false;
}
@@ -1897,24 +1897,24 @@ static bool TrackDesignPlacePreview(TrackDesignState& tds, TrackDesign* td6, mon
ride->custom_name = {};
ride->entrance_style = objManager.GetLoadedObjectEntryIndex(td6->appearance.stationObjectIdentifier);
ride->entrance_style = objManager.GetLoadedObjectEntryIndex(td->appearance.stationObjectIdentifier);
if (ride->entrance_style == OBJECT_ENTRY_INDEX_NULL)
{
ride->entrance_style = gameState.LastEntranceStyle;
}
for (size_t i = 0; i < std::min(std::size(ride->track_colour), std::size(td6->appearance.trackColours)); i++)
for (size_t i = 0; i < std::min(std::size(ride->track_colour), std::size(td->appearance.trackColours)); i++)
{
ride->track_colour[i] = td6->appearance.trackColours[i];
ride->track_colour[i] = td->appearance.trackColours[i];
}
// Flat rides need their vehicle colours loaded for display
// in the preview window
if (!GetRideTypeDescriptor(td6->type).HasFlag(RIDE_TYPE_FLAG_HAS_TRACK))
if (!GetRideTypeDescriptor(td->type).HasFlag(RIDE_TYPE_FLAG_HAS_TRACK))
{
for (size_t i = 0; i < std::size(ride->vehicle_colours); i++)
{
ride->vehicle_colours[i] = td6->appearance.vehicleColours[i];
ride->vehicle_colours[i] = td->appearance.vehicleColours[i];
}
}
@@ -1926,7 +1926,7 @@ static bool TrackDesignPlacePreview(TrackDesignState& tds, TrackDesign* td6, mon
_currentTrackPieceDirection = 0;
int32_t z = TrackDesignGetZPlacement(
tds, td6, RideGetTemporaryForPreview(), { mapSize.x, mapSize.y, 16, _currentTrackPieceDirection });
tds, td, RideGetTemporaryForPreview(), { mapSize.x, mapSize.y, 16, _currentTrackPieceDirection });
if (tds.hasScenery)
{
@@ -1943,7 +1943,7 @@ static bool TrackDesignPlacePreview(TrackDesignState& tds, TrackDesign* td6, mon
}
auto res = TrackDesignPlaceVirtual(
tds, td6, TrackPlaceOperation::placeTrackPreview, placeScenery, *ride,
tds, td, TrackPlaceOperation::placeTrackPreview, placeScenery, *ride,
{ mapSize.x, mapSize.y, z, _currentTrackPieceDirection });
gameState.Park.Flags = backup_park_flags;
@@ -2060,14 +2060,14 @@ bool TrackDesignSceneryElement::operator!=(const TrackDesignSceneryElement& rhs)
*
* rct2: 0x006D1EF0
*/
void TrackDesignDrawPreview(TrackDesign* td6, uint8_t* pixels)
void TrackDesignDrawPreview(TrackDesign* td, uint8_t* pixels)
{
StashMap();
TrackDesignPreviewClearMap();
if (gScreenFlags & SCREEN_FLAGS_TRACK_MANAGER)
{
TrackDesignLoadSceneryObjects(td6);
TrackDesignLoadSceneryObjects(td);
}
TrackDesignState tds{};
@@ -2075,14 +2075,14 @@ void TrackDesignDrawPreview(TrackDesign* td6, uint8_t* pixels)
money64 cost;
Ride* ride;
uint8_t flags;
if (!TrackDesignPlacePreview(tds, td6, &cost, &ride, &flags))
if (!TrackDesignPlacePreview(tds, td, &cost, &ride, &flags))
{
std::fill_n(pixels, kTrackPreviewImageSize * 4, 0x00);
UnstashMap();
return;
}
td6->cost = cost;
td6->trackFlags = flags & 7;
td->cost = cost;
td->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 };
@@ -2093,7 +2093,7 @@ void TrackDesignDrawPreview(TrackDesign* td6, uint8_t* pixels)
// Special case for flat rides - Z-axis info is irrelevant
// and must be zeroed out lest the preview be off-centre
if (!GetRideTypeDescriptor(td6->type).HasFlag(RIDE_TYPE_FLAG_HAS_TRACK))
if (!GetRideTypeDescriptor(td->type).HasFlag(RIDE_TYPE_FLAG_HAS_TRACK))
{
centre.z = 0;
size_z = 0;

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

@@ -230,17 +230,17 @@ extern RideId gTrackDesignSaveRideIndex;
[[nodiscard]] std::unique_ptr<TrackDesign> TrackDesignImport(const utf8* path);
void TrackDesignMirror(TrackDesign* td6);
void TrackDesignMirror(TrackDesign* td);
GameActions::Result TrackDesignPlace(TrackDesign* td6, uint32_t flags, bool placeScenery, Ride& ride, const CoordsXYZD& coords);
void TrackDesignPreviewRemoveGhosts(TrackDesign* td6, Ride& ride, const CoordsXYZD& coords);
void TrackDesignPreviewDrawOutlines(TrackDesignState& tds, TrackDesign* td6, Ride& ride, const CoordsXYZD& coords);
int32_t TrackDesignGetZPlacement(TrackDesign* td6, Ride& ride, const CoordsXYZD& coords);
GameActions::Result TrackDesignPlace(TrackDesign* td, uint32_t flags, bool placeScenery, Ride& ride, const CoordsXYZD& coords);
void TrackDesignPreviewRemoveGhosts(TrackDesign* td, Ride& ride, const CoordsXYZD& coords);
void TrackDesignPreviewDrawOutlines(TrackDesignState& tds, TrackDesign* td, Ride& ride, const CoordsXYZD& coords);
int32_t TrackDesignGetZPlacement(TrackDesign* td, Ride& ride, const CoordsXYZD& coords);
///////////////////////////////////////////////////////////////////////////////
// Track design preview
///////////////////////////////////////////////////////////////////////////////
void TrackDesignDrawPreview(TrackDesign* td6, uint8_t* pixels);
void TrackDesignDrawPreview(TrackDesign* td, uint8_t* pixels);
///////////////////////////////////////////////////////////////////////////////
// Track design saving

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

@@ -73,14 +73,14 @@ public:
public:
std::optional<TrackRepositoryItem> Create(int32_t, const std::string& path) const override
{
auto td6 = TrackDesignImport(path.c_str());
if (td6 != nullptr)
auto td = TrackDesignImport(path.c_str());
if (td != nullptr)
{
TrackRepositoryItem item;
item.Name = GetNameFromTrackPath(path);
item.Path = path;
item.RideType = td6->type;
item.ObjectEntry = std::string(td6->vehicleObject.Entry.name, 8);
item.RideType = td->type;
item.ObjectEntry = std::string(td->vehicleObject.Entry.name, 8);
item.Flags = 0;
if (IsTrackReadOnly(path))
{