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

Move track design statistics to their own struct

Browse Source
This commit is contained in:
Gymnasiast
2024-07-02 17:08:05 +02:00
parent 5fa007eb3b
commit 2c6491f34a
7 changed files with 149 additions and 138 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -217,21 +217,21 @@ static Widget window_install_track_widgets[] = {
// Stats
{
fixed32_2dp rating = td6->excitement * 10;
fixed32_2dp rating = td6->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->intensity * 10;
fixed32_2dp rating = td6->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->nausea * 10;
fixed32_2dp rating = td6->statistics.nausea * 10;
auto ft = Formatter();
ft.Add<int32_t>(rating);
DrawTextBasic(dpi, screenPos, STR_TRACK_LIST_NAUSEA_RATING, ft);
@@ -244,7 +244,7 @@ static Widget window_install_track_widgets[] = {
if (td6->type == RIDE_TYPE_MINI_GOLF)
{
// Holes
uint16_t holes = td6->holes & 0x1F;
uint16_t holes = td6->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->maxSpeed << 16) * 9) >> 18;
uint16_t speed = ((td6->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->averageSpeed << 16) * 9) >> 18;
uint16_t speed = ((td6->statistics.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->rideLength);
ft.Add<uint16_t>(td6->statistics.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->maxPositiveVerticalG * 32;
int32_t gForces = td6->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->maxNegativeVerticalG * 32;
int32_t gForces = td6->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->maxLateralG * 32;
int32_t gForces = td6->statistics.maxLateralG * 32;
auto ft = Formatter();
ft.Add<int32_t>(gForces);
DrawTextBasic(dpi, screenPos, STR_MAX_LATERAL_G, ft);
screenPos.y += kListRowHeight;
}
if (td6->totalAirTime != 0)
if (td6->statistics.totalAirTime != 0)
{
// Total air time
int32_t airTime = td6->totalAirTime * 25;
int32_t airTime = td6->statistics.totalAirTime * 25;
auto ft = Formatter();
ft.Add<int32_t>(airTime);
DrawTextBasic(dpi, screenPos, STR_TOTAL_AIR_TIME, ft);
@@ -318,7 +318,7 @@ static Widget window_install_track_widgets[] = {
if (GetRideTypeDescriptor(td6->type).HasFlag(RIDE_TYPE_FLAG_HAS_DROPS))
{
// Drops
uint16_t drops = td6->drops & 0x3F;
uint16_t drops = td6->statistics.drops & 0x3F;
auto ft = Formatter();
ft.Add<uint16_t>(drops);
DrawTextBasic(dpi, screenPos, STR_DROPS, ft);
@@ -331,7 +331,7 @@ static Widget window_install_track_widgets[] = {
if (td6->type != RIDE_TYPE_MINI_GOLF)
{
uint16_t inversions = td6->inversions & 0x1F;
uint16_t inversions = td6->statistics.inversions & 0x1F;
if (inversions != 0)
{
// Inversions
@@ -343,12 +343,12 @@ static Widget window_install_track_widgets[] = {
}
screenPos.y += 4;
if (td6->spaceRequiredX != 0xFF)
if (!td6->statistics.spaceRequired.IsNull())
{
// Space required
auto ft = Formatter();
ft.Add<uint16_t>(td6->spaceRequiredX);
ft.Add<uint16_t>(td6->spaceRequiredY);
ft.Add<uint16_t>(td6->statistics.spaceRequired.x);
ft.Add<uint16_t>(td6->statistics.spaceRequired.y);
DrawTextBasic(dpi, screenPos, STR_TRACK_LIST_SPACE_REQUIRED, ft);
screenPos.y += kListRowHeight;
}

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

@@ -544,17 +544,17 @@ static Widget _trackListWidgets[] = {
// Stats
ft = Formatter();
ft.Add<fixed32_2dp>(_loadedTrackDesign->excitement * 10);
ft.Add<fixed32_2dp>(_loadedTrackDesign->statistics.excitement * 10);
DrawTextBasic(dpi, screenPos, STR_TRACK_LIST_EXCITEMENT_RATING, ft);
screenPos.y += kListRowHeight;
ft = Formatter();
ft.Add<fixed32_2dp>(_loadedTrackDesign->intensity * 10);
ft.Add<fixed32_2dp>(_loadedTrackDesign->statistics.intensity * 10);
DrawTextBasic(dpi, screenPos, STR_TRACK_LIST_INTENSITY_RATING, ft);
screenPos.y += kListRowHeight;
ft = Formatter();
ft.Add<fixed32_2dp>(_loadedTrackDesign->nausea * 10);
ft.Add<fixed32_2dp>(_loadedTrackDesign->statistics.nausea * 10);
DrawTextBasic(dpi, screenPos, STR_TRACK_LIST_NAUSEA_RATING, ft);
screenPos.y += kListRowHeight + 4;
@@ -568,7 +568,7 @@ static Widget _trackListWidgets[] = {
{
// Holes
ft = Formatter();
ft.Add<uint16_t>(_loadedTrackDesign->holes & 0x1F);
ft.Add<uint16_t>(_loadedTrackDesign->statistics.holes & 0x1F);
DrawTextBasic(dpi, screenPos, STR_HOLES, ft);
screenPos.y += kListRowHeight;
}
@@ -576,13 +576,13 @@ static Widget _trackListWidgets[] = {
{
// Maximum speed
ft = Formatter();
ft.Add<uint16_t>(((_loadedTrackDesign->maxSpeed << 16) * 9) >> 18);
ft.Add<uint16_t>(((_loadedTrackDesign->statistics.maxSpeed << 16) * 9) >> 18);
DrawTextBasic(dpi, screenPos, STR_MAX_SPEED, ft);
screenPos.y += kListRowHeight;
// Average speed
ft = Formatter();
ft.Add<uint16_t>(((_loadedTrackDesign->averageSpeed << 16) * 9) >> 18);
ft.Add<uint16_t>(((_loadedTrackDesign->statistics.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->rideLength);
ft.Add<uint16_t>(_loadedTrackDesign->statistics.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->maxPositiveVerticalG * 32);
ft.Add<int32_t>(_loadedTrackDesign->statistics.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->maxNegativeVerticalG * 32);
ft.Add<int32_t>(_loadedTrackDesign->statistics.maxNegativeVerticalG * 32);
DrawTextBasic(dpi, screenPos, STR_MAX_NEGATIVE_VERTICAL_G, ft);
screenPos.y += kListRowHeight;
// Maximum lateral Gs
ft = Formatter();
ft.Add<int32_t>(_loadedTrackDesign->maxLateralG * 32);
ft.Add<int32_t>(_loadedTrackDesign->statistics.maxLateralG * 32);
DrawTextBasic(dpi, screenPos, STR_MAX_LATERAL_G, ft);
screenPos.y += kListRowHeight;
if (_loadedTrackDesign->totalAirTime != 0)
if (_loadedTrackDesign->statistics.totalAirTime != 0)
{
// Total air time
ft = Formatter();
ft.Add<int32_t>(_loadedTrackDesign->totalAirTime * 25);
ft.Add<int32_t>(_loadedTrackDesign->statistics.totalAirTime * 25);
DrawTextBasic(dpi, screenPos, STR_TOTAL_AIR_TIME, ft);
screenPos.y += kListRowHeight;
}
@@ -629,20 +629,20 @@ static Widget _trackListWidgets[] = {
{
// Drops
ft = Formatter();
ft.Add<uint16_t>(_loadedTrackDesign->drops & 0x3F);
ft.Add<uint16_t>(_loadedTrackDesign->statistics.drops & 0x3F);
DrawTextBasic(dpi, screenPos, STR_DROPS, ft);
screenPos.y += kListRowHeight;
// Drop height is multiplied by 0.75
ft = Formatter();
ft.Add<uint16_t>((_loadedTrackDesign->highestDropHeight * 3) / 4);
ft.Add<uint16_t>((_loadedTrackDesign->statistics.highestDropHeight * 3) / 4);
DrawTextBasic(dpi, screenPos, STR_HIGHEST_DROP_HEIGHT, ft);
screenPos.y += kListRowHeight;
}
if (_loadedTrackDesign->type != RIDE_TYPE_MINI_GOLF)
{
uint16_t inversions = _loadedTrackDesign->inversions & 0x1F;
uint16_t inversions = _loadedTrackDesign->statistics.inversions & 0x1F;
if (inversions != 0)
{
ft = Formatter();
@@ -655,12 +655,12 @@ static Widget _trackListWidgets[] = {
screenPos.y += 4;
}
if (_loadedTrackDesign->spaceRequiredX != 0xFF)
if (!_loadedTrackDesign->statistics.spaceRequired.IsNull())
{
// Space required
ft = Formatter();
ft.Add<uint16_t>(_loadedTrackDesign->spaceRequiredX);
ft.Add<uint16_t>(_loadedTrackDesign->spaceRequiredY);
ft.Add<uint16_t>(_loadedTrackDesign->statistics.spaceRequired.x);
ft.Add<uint16_t>(_loadedTrackDesign->statistics.spaceRequired.y);
DrawTextBasic(dpi, screenPos, STR_TRACK_LIST_SPACE_REQUIRED, ft);
screenPos.y += kListRowHeight;
}

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

@@ -208,30 +208,29 @@ namespace RCT1
td->maxWaitingTime = td4Base.MaxWaitingTime;
td->operationSetting = std::min(
td4Base.OperationSetting, GetRideTypeDescriptor(td->type).OperatingSettings.MaxValue);
td->maxSpeed = td4Base.MaxSpeed;
td->averageSpeed = td4Base.AverageSpeed;
td->rideLength = td4Base.RideLength;
td->maxPositiveVerticalG = td4Base.MaxPositiveVerticalG;
td->maxNegativeVerticalG = td4Base.MaxNegativeVerticalG;
td->maxLateralG = td4Base.MaxLateralG;
td->statistics.maxSpeed = td4Base.MaxSpeed;
td->statistics.averageSpeed = td4Base.AverageSpeed;
td->statistics.rideLength = td4Base.RideLength;
td->statistics.maxPositiveVerticalG = td4Base.MaxPositiveVerticalG;
td->statistics.maxNegativeVerticalG = td4Base.MaxNegativeVerticalG;
td->statistics.maxLateralG = td4Base.MaxLateralG;
if (td->type == RIDE_TYPE_MINI_GOLF)
{
td->holes = td4Base.NumHoles;
td->statistics.holes = td4Base.NumHoles;
}
else
{
td->inversions = td4Base.NumInversions;
td->statistics.inversions = td4Base.NumInversions;
}
td->drops = td4Base.NumDrops;
td->highestDropHeight = td4Base.HighestDropHeight / 2;
td->excitement = td4Base.Excitement;
td->intensity = td4Base.Intensity;
td->nausea = td4Base.Nausea;
td->upkeepCost = ToMoney64(td4Base.UpkeepCost);
td->spaceRequiredX = 255;
td->spaceRequiredY = 255;
td->statistics.drops = td4Base.NumDrops;
td->statistics.highestDropHeight = td4Base.HighestDropHeight / 2;
td->statistics.excitement = td4Base.Excitement;
td->statistics.intensity = td4Base.Intensity;
td->statistics.nausea = td4Base.Nausea;
td->statistics.upkeepCost = ToMoney64(td4Base.UpkeepCost);
td->statistics.spaceRequired.SetNull();
td->liftHillSpeed = 5;
td->numCircuits = 0;
td->operationSetting = std::min(td->operationSetting, GetRideTypeDescriptor(td->type).OperatingSettings.MaxValue);

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

@@ -65,34 +65,34 @@ namespace RCT2
tempStream.WriteValue<uint8_t>(0);
auto entranceStyle = GetStationStyleFromIdentifier(_trackDesign->stationObjectIdentifier);
tempStream.WriteValue<uint8_t>(entranceStyle);
tempStream.WriteValue<uint8_t>(_trackDesign->totalAirTime);
tempStream.WriteValue<uint8_t>(_trackDesign->statistics.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<int8_t>(_trackDesign->statistics.maxSpeed);
tempStream.WriteValue<int8_t>(_trackDesign->statistics.averageSpeed);
tempStream.WriteValue<uint16_t>(_trackDesign->statistics.rideLength);
tempStream.WriteValue<uint8_t>(_trackDesign->statistics.maxPositiveVerticalG);
tempStream.WriteValue<int8_t>(_trackDesign->statistics.maxNegativeVerticalG);
tempStream.WriteValue<uint8_t>(_trackDesign->statistics.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->highestDropHeight);
tempStream.WriteValue<uint8_t>(_trackDesign->excitement);
tempStream.WriteValue<uint8_t>(_trackDesign->intensity);
tempStream.WriteValue<uint8_t>(_trackDesign->nausea);
tempStream.WriteValue<money16>(ToMoney16(_trackDesign->upkeepCost));
_trackDesign->type == RIDE_TYPE_MINI_GOLF ? _trackDesign->statistics.holes : _trackDesign->statistics.inversions);
tempStream.WriteValue<uint8_t>(_trackDesign->statistics.drops);
tempStream.WriteValue<uint8_t>(_trackDesign->statistics.highestDropHeight);
tempStream.WriteValue<uint8_t>(_trackDesign->statistics.excitement);
tempStream.WriteValue<uint8_t>(_trackDesign->statistics.intensity);
tempStream.WriteValue<uint8_t>(_trackDesign->statistics.nausea);
tempStream.WriteValue<money16>(ToMoney16(_trackDesign->statistics.upkeepCost));
tempStream.WriteArray(_trackDesign->trackSpineColour, Limits::kNumColourSchemes);
tempStream.WriteArray(_trackDesign->trackRailColour, Limits::kNumColourSchemes);
tempStream.WriteArray(_trackDesign->trackSupportColour, Limits::kNumColourSchemes);
tempStream.WriteValue<uint32_t>(0);
tempStream.Write(&_trackDesign->vehicleObject.Entry, sizeof(RCTObjectEntry));
tempStream.WriteValue<uint8_t>(_trackDesign->spaceRequiredX);
tempStream.WriteValue<uint8_t>(_trackDesign->spaceRequiredY);
tempStream.WriteValue<uint8_t>(_trackDesign->statistics.spaceRequired.x);
tempStream.WriteValue<uint8_t>(_trackDesign->statistics.spaceRequired.y);
for (auto i = 0; i < RCT2::Limits::kMaxVehicleColours; i++)
{
tempStream.WriteValue<uint8_t>(_trackDesign->vehicleColours[i].Tertiary);

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

@@ -85,35 +85,35 @@ namespace RCT2
td->vehicleColours[i].Tertiary = td6.VehicleAdditionalColour[i];
}
td->stationObjectIdentifier = GetStationIdentifierFromStyle(td6.EntranceStyle);
td->totalAirTime = td6.TotalAirTime;
td->statistics.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;
td->statistics.maxSpeed = td6.MaxSpeed;
td->statistics.averageSpeed = td6.AverageSpeed;
td->statistics.rideLength = td6.RideLength;
td->statistics.maxPositiveVerticalG = td6.MaxPositiveVerticalG;
td->statistics.maxNegativeVerticalG = td6.MaxNegativeVerticalG;
td->statistics.maxLateralG = td6.MaxLateralG;
if (td->type == RIDE_TYPE_MINI_GOLF)
{
td->holes = td6.Holes;
td->statistics.holes = td6.Holes;
}
else
{
td->inversions = td6.Inversions;
td->statistics.inversions = td6.Inversions;
}
td->drops = td6.Drops;
td->highestDropHeight = td6.HighestDropHeight;
td->excitement = td6.Excitement;
td->intensity = td6.Intensity;
td->nausea = td6.Nausea;
td->upkeepCost = ToMoney64(td6.UpkeepCost);
td->statistics.drops = td6.Drops;
td->statistics.highestDropHeight = td6.HighestDropHeight;
td->statistics.excitement = td6.Excitement;
td->statistics.intensity = td6.Intensity;
td->statistics.nausea = td6.Nausea;
td->statistics.upkeepCost = ToMoney64(td6.UpkeepCost);
for (auto i = 0; i < Limits::kNumColourSchemes; ++i)
{
td->trackSpineColour[i] = td6.TrackSpineColour[i];
@@ -121,8 +121,7 @@ namespace RCT2
td->trackSupportColour[i] = td6.TrackSupportColour[i];
}
td->vehicleObject = ObjectEntryDescriptor(td6.VehicleObject);
td->spaceRequiredX = td6.SpaceRequiredX;
td->spaceRequiredY = td6.SpaceRequiredY;
td->statistics.spaceRequired = { td6.SpaceRequiredX, td6.SpaceRequiredY };
td->liftHillSpeed = td6.LiftHillSpeedNumCircuits & 0b00011111;
td->numCircuits = td6.LiftHillSpeedNumCircuits >> 5;

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

@@ -148,30 +148,30 @@ ResultWithMessage TrackDesign::CreateTrackDesign(TrackDesignState& tds, const Ri
numCircuits = ride.num_circuits;
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;
highestDropHeight = ride.highest_drop_height;
statistics.maxSpeed = static_cast<int8_t>(ride.max_speed / 65536);
statistics.averageSpeed = static_cast<int8_t>(ride.average_speed / 65536);
statistics.rideLength = ride.GetTotalLength() / 65536;
statistics.maxPositiveVerticalG = ride.max_positive_vertical_g / 32;
statistics.maxNegativeVerticalG = ride.max_negative_vertical_g / 32;
statistics.maxLateralG = ride.max_lateral_g / 32;
statistics.holes = ride.holes & 0x1F;
statistics.inversions = ride.inversions & 0x1F;
statistics.inversions |= (ride.sheltered_eighths << 5);
statistics.drops = ride.drops;
statistics.highestDropHeight = ride.highest_drop_height;
uint16_t _totalAirTime = (ride.total_air_time * 123) / 1024;
if (_totalAirTime > 255)
{
_totalAirTime = 0;
}
totalAirTime = static_cast<uint8_t>(_totalAirTime);
statistics.totalAirTime = static_cast<uint8_t>(_totalAirTime);
excitement = ride.ratings.Excitement / 10;
intensity = ride.ratings.Intensity / 10;
nausea = ride.ratings.Nausea / 10;
statistics.excitement = ride.ratings.Excitement / 10;
statistics.intensity = ride.ratings.Intensity / 10;
statistics.nausea = ride.ratings.Nausea / 10;
upkeepCost = ride.upkeep_cost;
statistics.upkeepCost = ride.upkeep_cost;
const auto& rtd = GetRideTypeDescriptor(type);
@@ -355,8 +355,7 @@ ResultWithMessage TrackDesign::CreateTrackDesignTrack(TrackDesignState& tds, con
gMapSelectFlags &= ~MAP_SELECT_FLAG_ENABLE_ARROW;
gMapSelectFlags &= ~MAP_SELECT_FLAG_GREEN;
spaceRequiredX = ((tds.previewMax.x - tds.previewMin.x) / 32) + 1;
spaceRequiredY = ((tds.previewMax.y - tds.previewMin.y) / 32) + 1;
statistics.spaceRequired = TileCoordsXY(tds.previewMax - tds.previewMin) + TileCoordsXY{ 1, 1 };
return { true, warningMessage };
}
@@ -468,8 +467,8 @@ ResultWithMessage TrackDesign::CreateTrackDesignMaze(TrackDesignState& tds, cons
gMapSelectFlags &= ~MAP_SELECT_FLAG_ENABLE_ARROW;
gMapSelectFlags &= ~MAP_SELECT_FLAG_GREEN;
spaceRequiredX = ((tds.previewMax.x - tds.previewMin.x) / 32) + 1;
spaceRequiredY = ((tds.previewMax.y - tds.previewMin.y) / 32) + 1;
statistics.spaceRequired = TileCoordsXY(tds.previewMax - tds.previewMin) + TileCoordsXY{ 1, 1 };
return { true };
}
@@ -570,33 +569,33 @@ void TrackDesign::Serialise(DataSerialiser& stream)
stream << DS_TAG(colourScheme);
stream << DS_TAG(vehicleColours);
stream << DS_TAG(stationObjectIdentifier);
stream << DS_TAG(totalAirTime);
stream << DS_TAG(statistics.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(highestDropHeight);
stream << DS_TAG(excitement);
stream << DS_TAG(intensity);
stream << DS_TAG(nausea);
stream << DS_TAG(upkeepCost);
stream << DS_TAG(statistics.maxSpeed);
stream << DS_TAG(statistics.averageSpeed);
stream << DS_TAG(statistics.rideLength);
stream << DS_TAG(statistics.maxPositiveVerticalG);
stream << DS_TAG(statistics.maxNegativeVerticalG);
stream << DS_TAG(statistics.maxLateralG);
stream << DS_TAG(statistics.inversions);
stream << DS_TAG(statistics.holes);
stream << DS_TAG(statistics.drops);
stream << DS_TAG(statistics.highestDropHeight);
stream << DS_TAG(statistics.excitement);
stream << DS_TAG(statistics.intensity);
stream << DS_TAG(statistics.nausea);
stream << DS_TAG(statistics.upkeepCost);
stream << DS_TAG(trackSpineColour);
stream << DS_TAG(trackRailColour);
stream << DS_TAG(trackSupportColour);
stream << DS_TAG(vehicleObject);
stream << DS_TAG(spaceRequiredX);
stream << DS_TAG(spaceRequiredY);
stream << DS_TAG(statistics.spaceRequired.x);
stream << DS_TAG(statistics.spaceRequired.y);
stream << DS_TAG(liftHillSpeed);
stream << DS_TAG(numCircuits);

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

@@ -129,6 +129,33 @@ struct TrackDesignMazeElement
class DataSerialiser;
enum class RideMode : uint8_t;
struct TrackDesignStatistics
{
uint8_t excitement{};
uint8_t intensity{};
uint8_t nausea{};
int8_t maxSpeed{};
int8_t averageSpeed{};
// TODO: move to a struct of its own, together with rideTime, that can be repeated for multiple stations.
uint16_t rideLength;
uint8_t maxPositiveVerticalG{};
int8_t maxNegativeVerticalG{};
uint8_t maxLateralG{};
uint8_t totalAirTime{};
uint8_t drops{};
uint8_t highestDropHeight{};
union
{
uint8_t inversions{};
uint8_t holes;
};
money64 upkeepCost;
TileCoordsXY spaceRequired{};
};
struct TrackDesign
{
uint8_t type;
@@ -139,36 +166,23 @@ struct TrackDesign
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 highestDropHeight;
uint8_t excitement;
uint8_t intensity;
uint8_t nausea;
money64 upkeepCost;
uint8_t trackSpineColour[OpenRCT2::Limits::kNumColourSchemes];
uint8_t trackRailColour[OpenRCT2::Limits::kNumColourSchemes];
uint8_t trackSupportColour[OpenRCT2::Limits::kNumColourSchemes];
ObjectEntryDescriptor vehicleObject;
uint8_t spaceRequiredX;
uint8_t spaceRequiredY;
uint8_t liftHillSpeed;
uint8_t numCircuits;
TrackDesignStatistics statistics;
std::vector<TrackDesignMazeElement> mazeElements;
std::vector<TrackDesignTrackElement> trackElements;
std::vector<TrackDesignEntranceElement> entranceElements;