From d8417fee300a560b7cd2e1dd99ba41418887100a Mon Sep 17 00:00:00 2001 From: Michael Steenbeek Date: Sun, 22 Jan 2023 20:16:41 +0100 Subject: [PATCH] Desnake the rct2/rct12 fields (#19254) --- src/openrct2/FileClassifier.cpp | 6 +- src/openrct2/rct1/RCT1.h | 20 +- src/openrct2/rct1/S4Importer.cpp | 98 +- src/openrct2/rct1/T4Importer.cpp | 26 +- src/openrct2/rct12/RCT12.cpp | 150 +-- src/openrct2/rct12/RCT12.h | 268 ++-- src/openrct2/rct2/RCT2.cpp | 12 +- src/openrct2/rct2/RCT2.h | 1136 ++++++++--------- src/openrct2/rct2/S6Importer.cpp | 1154 +++++++++--------- src/openrct2/rct2/T6Importer.cpp | 102 +- src/openrct2/scenario/ScenarioRepository.cpp | 24 +- 11 files changed, 1498 insertions(+), 1498 deletions(-) diff --git a/src/openrct2/FileClassifier.cpp b/src/openrct2/FileClassifier.cpp index 1b68ee5422..7a36c865ed 100644 --- a/src/openrct2/FileClassifier.cpp +++ b/src/openrct2/FileClassifier.cpp @@ -102,15 +102,15 @@ static bool TryClassifyAsS6(OpenRCT2::IStream* stream, ClassifiedFileInfo* resul { auto chunkReader = SawyerChunkReader(stream); auto s6Header = chunkReader.ReadChunkAs(); - if (s6Header.type == S6_TYPE_SAVEDGAME) + if (s6Header.Type == S6_TYPE_SAVEDGAME) { result->Type = FILE_TYPE::SAVED_GAME; } - else if (s6Header.type == S6_TYPE_SCENARIO) + else if (s6Header.Type == S6_TYPE_SCENARIO) { result->Type = FILE_TYPE::SCENARIO; } - result->Version = s6Header.version; + result->Version = s6Header.Version; success = true; } catch (const std::exception& e) diff --git a/src/openrct2/rct1/RCT1.h b/src/openrct2/rct1/RCT1.h index c27bef65c5..1f471463d8 100644 --- a/src/openrct2/rct1/RCT1.h +++ b/src/openrct2/rct1/RCT1.h @@ -471,14 +471,14 @@ namespace RCT1 uint8_t Mass; // 0x41 uint8_t TimeToConsume; uint8_t Intensity; // 0x43 The max intensity is stored in the first 4 bits, and the min intensity in the second 4 bits - uint8_t NauseaTolerance; // 0x44 - uint8_t WindowInvalidateFlags; // 0x45 - money16 PaidOnDrink; // 0x46 - uint8_t ride_types_been_on[16]; // 0x48 - uint8_t Pad5F[0x10]; // 0x58 - RCT12RideId CurrentRide; // 0x68 - uint8_t CurrentRideStation; // 0x69 - uint8_t CurrentTrain; // 0x6A + uint8_t NauseaTolerance; // 0x44 + uint8_t WindowInvalidateFlags; // 0x45 + money16 PaidOnDrink; // 0x46 + uint8_t RideTypesBeenOn[16]; // 0x48 + uint8_t Pad5F[0x10]; // 0x58 + RCT12RideId CurrentRide; // 0x68 + uint8_t CurrentRideStation; // 0x69 + uint8_t CurrentTrain; // 0x6A union { struct @@ -516,8 +516,8 @@ namespace RCT1 uint8_t Direction; // Direction ? }; RCT12RideId InteractionRideIndex; - uint16_t TimeInQueue; // 0x7A - uint8_t rides_been_on[32]; // 0x7C + uint16_t TimeInQueue; // 0x7A + uint8_t RidesBeenOn[32]; // 0x7C // 255 bit bitmap of every ride the peep has been on see // WindowPeepRidesUpdate for how to use. uint32_t ID; // 0x9C diff --git a/src/openrct2/rct1/S4Importer.cpp b/src/openrct2/rct1/S4Importer.cpp index faf99f2d8d..d551ff2fb6 100644 --- a/src/openrct2/rct1/S4Importer.cpp +++ b/src/openrct2/rct1/S4Importer.cpp @@ -1169,9 +1169,9 @@ namespace RCT1 { for (const auto& src : _s4.RideMeasurements) { - if (src.ride_index != RCT12_RIDE_ID_NULL) + if (src.RideIndex != RCT12_RIDE_ID_NULL) { - auto ride = GetRide(RCT12RideIdToOpenRCT2RideId(src.ride_index)); + auto ride = GetRide(RCT12RideIdToOpenRCT2RideId(src.RideIndex)); if (ride != nullptr) { ride->measurement = std::make_unique(); @@ -1183,18 +1183,18 @@ namespace RCT1 void ImportRideMeasurement(RideMeasurement& dst, const RCT12RideMeasurement& src) { - dst.flags = src.flags; - dst.last_use_tick = src.last_use_tick; - dst.num_items = src.num_items; - dst.current_item = src.current_item; - dst.vehicle_index = src.vehicle_index; - dst.current_station = StationIndex::FromUnderlying(src.current_station); - for (size_t i = 0; i < std::size(src.velocity); i++) + dst.flags = src.Flags; + dst.last_use_tick = src.LastUseTick; + dst.num_items = src.NumItems; + dst.current_item = src.CurrentItem; + dst.vehicle_index = src.VehicleIndex; + dst.current_station = StationIndex::FromUnderlying(src.CurrentStation); + for (size_t i = 0; i < std::size(src.Velocity); i++) { - dst.velocity[i] = src.velocity[i] / 2; - dst.altitude[i] = src.altitude[i] / 2; - dst.vertical[i] = src.vertical[i] / 2; - dst.lateral[i] = src.lateral[i] / 2; + dst.velocity[i] = src.Velocity[i] / 2; + dst.altitude[i] = src.Altitude[i] / 2; + dst.vertical[i] = src.Vertical[i] / 2; + dst.lateral[i] = src.Lateral[i] / 2; } } @@ -1219,11 +1219,11 @@ namespace RCT1 // RCT1 had no third colour if (colourSchemeCopyDescriptor.colour1 == COPY_COLOUR_1) { - dst->colours.Body = RCT1::GetColour(src->Colours.body_colour); + dst->colours.Body = RCT1::GetColour(src->Colours.BodyColour); } else if (colourSchemeCopyDescriptor.colour1 == COPY_COLOUR_2) { - dst->colours.Body = RCT1::GetColour(src->Colours.trim_colour); + dst->colours.Body = RCT1::GetColour(src->Colours.TrimColour); } else { @@ -1232,11 +1232,11 @@ namespace RCT1 if (colourSchemeCopyDescriptor.colour2 == COPY_COLOUR_1) { - dst->colours.Trim = RCT1::GetColour(src->Colours.body_colour); + dst->colours.Trim = RCT1::GetColour(src->Colours.BodyColour); } else if (colourSchemeCopyDescriptor.colour2 == COPY_COLOUR_2) { - dst->colours.Trim = RCT1::GetColour(src->Colours.trim_colour); + dst->colours.Trim = RCT1::GetColour(src->Colours.TrimColour); } else { @@ -1245,11 +1245,11 @@ namespace RCT1 if (colourSchemeCopyDescriptor.colour3 == COPY_COLOUR_1) { - dst->colours.Tertiary = RCT1::GetColour(src->Colours.body_colour); + dst->colours.Tertiary = RCT1::GetColour(src->Colours.BodyColour); } else if (colourSchemeCopyDescriptor.colour3 == COPY_COLOUR_2) { - dst->colours.Tertiary = RCT1::GetColour(src->Colours.trim_colour); + dst->colours.Tertiary = RCT1::GetColour(src->Colours.TrimColour); } else { @@ -2144,9 +2144,9 @@ namespace RCT1 auto& awards = GetAwards(); for (auto& src : _s4.Awards) { - if (src.time != 0) + if (src.Time != 0) { - awards.push_back(Award{ src.time, static_cast(src.type) }); + awards.push_back(Award{ src.Time, static_cast(src.Type) }); } } @@ -2389,21 +2389,21 @@ namespace RCT1 *dst = {}; dst->id = id; - dst->type = RCTEntryIndexToOpenRCT2EntryIndex(src->type); + dst->type = RCTEntryIndexToOpenRCT2EntryIndex(src->Type); dst->flags = 0; - if (src->flags & BANNER_FLAG_NO_ENTRY) + if (src->Flags & BANNER_FLAG_NO_ENTRY) { dst->flags |= BANNER_FLAG_NO_ENTRY; } - if (IsUserStringID(src->string_idx)) + if (IsUserStringID(src->StringID)) { - dst->text = GetUserString(src->string_idx); + dst->text = GetUserString(src->StringID); } - dst->colour = RCT1::GetColour(src->colour); - dst->text_colour = src->text_colour; + dst->colour = RCT1::GetColour(src->Colour); + dst->text_colour = src->TextColour; dst->position.x = src->x; dst->position.y = src->y; } @@ -2662,7 +2662,7 @@ namespace RCT1 } case RCT12EntityIdentifier::Misc: - switch (RCT12MiscEntityType(src.type)) + switch (RCT12MiscEntityType(src.Type)) { case RCT12MiscEntityType::SteamParticle: output = EntityType::SteamParticle; @@ -2720,7 +2720,7 @@ namespace RCT1 dst->ride_subtype = RCTEntryIndexToOpenRCT2EntryIndex(ride->subtype); dst->vehicle_type = vehicleEntryIndex; - dst->SubType = ::Vehicle::Type(src->type); + dst->SubType = ::Vehicle::Type(src->Type); dst->var_44 = src->Var44; dst->remaining_distance = src->RemainingDistance; @@ -2815,7 +2815,7 @@ namespace RCT1 dst->num_peeps = src->NumPeeps; dst->next_free_seat = src->NextFreeSeat; - dst->IsCrashedVehicle = src->flags & RCT12_ENTITY_FLAGS_IS_CRASHED_VEHICLE_ENTITY; + dst->IsCrashedVehicle = src->Flags & RCT12_ENTITY_FLAGS_IS_CRASHED_VEHICLE_ENTITY; } template<> void S4Importer::ImportEntity(const RCT12EntityBase& srcBase) @@ -2879,13 +2879,13 @@ namespace RCT1 { auto srcThought = &src->Thoughts[i]; auto dstThought = &dst->Thoughts[i]; - dstThought->type = static_cast(srcThought->type); - if (srcThought->item == RCT12PeepThoughtItemNone) + dstThought->type = static_cast(srcThought->Type); + if (srcThought->Item == RCT12PeepThoughtItemNone) dstThought->item = PeepThoughtItemNone; else - dstThought->item = srcThought->item; - dstThought->freshness = srcThought->freshness; - dstThought->fresh_timeout = srcThought->fresh_timeout; + dstThought->item = srcThought->Item; + dstThought->freshness = srcThought->Freshness; + dstThought->fresh_timeout = srcThought->FreshTimeout; } dst->PreviousRide = RCT12RideIdToOpenRCT2RideId(src->PreviousRide); @@ -2942,7 +2942,7 @@ namespace RCT1 auto* src = static_cast(&srcBase); ImportEntityCommonProperties(dst, src); - dst->SubType = Litter::Type(src->type); + dst->SubType = Litter::Type(src->Type); } template<> void S4Importer::ImportEntity(const RCT12EntityBase& srcBase) @@ -2951,7 +2951,7 @@ namespace RCT1 auto* src = static_cast(&srcBase); ImportEntityCommonProperties(dst, src); - dst->frame = src->frame; + dst->frame = src->Frame; } template<> void S4Importer::ImportEntity(const RCT12EntityBase& srcBase) @@ -2960,11 +2960,11 @@ namespace RCT1 auto* src = static_cast(&srcBase); ImportEntityCommonProperties(dst, src); - dst->MoveDelay = src->move_delay; - dst->NumMovements = src->num_movements; - dst->Value = src->value; - dst->OffsetX = src->offset_x; - dst->Wiggle = src->wiggle; + dst->MoveDelay = src->MoveDelay; + dst->NumMovements = src->NumMovements; + dst->Value = src->Value; + dst->OffsetX = src->OffsetX; + dst->Wiggle = src->Wiggle; } template<> void S4Importer::ImportEntity(const RCT12EntityBase& srcBase) @@ -3001,10 +3001,10 @@ namespace RCT1 auto* src = static_cast(&srcBase); ImportEntityCommonProperties(dst, src); - dst->FountainFlags = src->fountain_flags; - dst->Iteration = src->iteration; - dst->NumTicksAlive = src->num_ticks_alive; - dst->frame = src->frame; + dst->FountainFlags = src->FountainFlags; + dst->Iteration = src->Iteration; + dst->NumTicksAlive = src->NumTicksAlive; + dst->frame = src->Frame; dst->FountainType = JumpingFountainType::Water; } @@ -3021,7 +3021,7 @@ namespace RCT1 } else { - dst->colour = RCT1::GetColour(src->colour); + dst->colour = RCT1::GetColour(src->Colour); } } @@ -3031,8 +3031,8 @@ namespace RCT1 auto* src = static_cast(&srcBase); ImportEntityCommonProperties(dst, src); - dst->frame = src->frame; - dst->state = static_cast(src->state); + dst->frame = src->Frame; + dst->state = static_cast(src->State); } void S4Importer::ImportEntity(const RCT12EntityBase& src) diff --git a/src/openrct2/rct1/T4Importer.cpp b/src/openrct2/rct1/T4Importer.cpp index b72f2d99ce..5d0f7a4bdb 100644 --- a/src/openrct2/rct1/T4Importer.cpp +++ b/src/openrct2/rct1/T4Importer.cpp @@ -161,11 +161,11 @@ namespace RCT1 td4Base.VehicleType); if (colourSchemeCopyDescriptor.colour1 == COPY_COLOUR_1) { - td->vehicle_colours[i].Body = RCT1::GetColour(td4Base.VehicleColours[i].body_colour); + td->vehicle_colours[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].trim_colour); + td->vehicle_colours[i].Body = RCT1::GetColour(td4Base.VehicleColours[i].TrimColour); } else { @@ -174,11 +174,11 @@ namespace RCT1 if (colourSchemeCopyDescriptor.colour2 == COPY_COLOUR_1) { - td->vehicle_colours[i].Trim = RCT1::GetColour(td4Base.VehicleColours[i].body_colour); + td->vehicle_colours[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].trim_colour); + td->vehicle_colours[i].Trim = RCT1::GetColour(td4Base.VehicleColours[i].TrimColour); } else { @@ -187,11 +187,11 @@ namespace RCT1 if (colourSchemeCopyDescriptor.colour3 == COPY_COLOUR_1) { - td->vehicle_colours[i].Tertiary = RCT1::GetColour(td4Base.VehicleColours[i].body_colour); + td->vehicle_colours[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].trim_colour); + td->vehicle_colours[i].Tertiary = RCT1::GetColour(td4Base.VehicleColours[i].TrimColour); } else { @@ -243,17 +243,17 @@ namespace RCT1 if (rtd.HasFlag(RIDE_TYPE_FLAG_IS_MAZE)) { TD46MazeElement t4MazeElement{}; - t4MazeElement.all = !0; - while (t4MazeElement.all != 0) + t4MazeElement.All = !0; + while (t4MazeElement.All != 0) { _stream.Read(&t4MazeElement, sizeof(TD46MazeElement)); - if (t4MazeElement.all != 0) + if (t4MazeElement.All != 0) { TrackDesignMazeElement mazeElement{}; mazeElement.x = t4MazeElement.x; mazeElement.y = t4MazeElement.y; - mazeElement.direction = t4MazeElement.direction; - mazeElement.type = t4MazeElement.type; + mazeElement.direction = t4MazeElement.Direction; + mazeElement.type = t4MazeElement.Type; td->maze_elements.push_back(mazeElement); } } @@ -266,8 +266,8 @@ namespace RCT1 _stream.SetPosition(_stream.GetPosition() - 1); _stream.Read(&t4TrackElement, sizeof(TD46TrackElement)); TrackDesignTrackElement trackElement{}; - trackElement.type = RCT1TrackTypeToOpenRCT2(t4TrackElement.type, td->type); - trackElement.flags = t4TrackElement.flags; + trackElement.type = RCT1TrackTypeToOpenRCT2(t4TrackElement.Type, td->type); + trackElement.flags = t4TrackElement.Flags; td->track_elements.push_back(trackElement); } } diff --git a/src/openrct2/rct12/RCT12.cpp b/src/openrct2/rct12/RCT12.cpp index 3920d3fd5e..04ecaee387 100644 --- a/src/openrct2/rct12/RCT12.cpp +++ b/src/openrct2/rct12/RCT12.cpp @@ -73,42 +73,42 @@ bool RCT12TileElementBase::IsGhost() const uint8_t RCT12SurfaceElement::GetSlope() const { - return (slope & TILE_ELEMENT_SURFACE_SLOPE_MASK); + return (Slope & TILE_ELEMENT_SURFACE_SLOPE_MASK); } uint32_t RCT12SurfaceElement::GetSurfaceStyle() const { - uint32_t retVal = (terrain >> 5) & 7; + uint32_t retVal = (Terrain >> 5) & 7; retVal |= (Type & RCT12_SURFACE_ELEMENT_TYPE_SURFACE_MASK) << 3; return retVal; } uint32_t RCT12SurfaceElement::GetEdgeStyle() const { - uint32_t terrain_edge = (slope >> 5) & 7; + uint32_t terrainEdge = (Slope >> 5) & 7; if (Type & 128) - terrain_edge |= (1 << 3); - return terrain_edge; + terrainEdge |= (1 << 3); + return terrainEdge; } uint8_t RCT12SurfaceElement::GetGrassLength() const { - return grass_length; + return GrassLength; } uint8_t RCT12SurfaceElement::GetOwnership() const { - return (ownership & TILE_ELEMENT_SURFACE_OWNERSHIP_MASK); + return (Ownership & TILE_ELEMENT_SURFACE_OWNERSHIP_MASK); } uint32_t RCT12SurfaceElement::GetWaterHeight() const { - return (terrain & RCT12_TILE_ELEMENT_SURFACE_WATER_HEIGHT_MASK) * WATER_HEIGHT_STEP; + return (Terrain & RCT12_TILE_ELEMENT_SURFACE_WATER_HEIGHT_MASK) * WATER_HEIGHT_STEP; } uint8_t RCT12SurfaceElement::GetParkFences() const { - return (ownership & TILE_ELEMENT_SURFACE_PARK_FENCE_MASK); + return (Ownership & TILE_ELEMENT_SURFACE_PARK_FENCE_MASK); } bool RCT12SurfaceElement::HasTrackThatNeedsWater() const @@ -118,7 +118,7 @@ bool RCT12SurfaceElement::HasTrackThatNeedsWater() const uint8_t RCT12PathElement::GetEntryIndex() const { - return (entryIndex & RCT12_FOOTPATH_PROPERTIES_TYPE_MASK) >> 4; + return (EntryIndex & RCT12_FOOTPATH_PROPERTIES_TYPE_MASK) >> 4; } uint8_t RCT12PathElement::GetQueueBannerDirection() const @@ -128,22 +128,22 @@ uint8_t RCT12PathElement::GetQueueBannerDirection() const bool RCT12PathElement::IsSloped() const { - return (entryIndex & RCT12_FOOTPATH_PROPERTIES_FLAG_IS_SLOPED) != 0; + return (EntryIndex & RCT12_FOOTPATH_PROPERTIES_FLAG_IS_SLOPED) != 0; } uint8_t RCT12PathElement::GetSlopeDirection() const { - return entryIndex & RCT12_FOOTPATH_PROPERTIES_SLOPE_DIRECTION_MASK; + return EntryIndex & RCT12_FOOTPATH_PROPERTIES_SLOPE_DIRECTION_MASK; } uint8_t RCT12PathElement::GetRideIndex() const { - return rideIndex; + return RideIndex; } uint8_t RCT12PathElement::GetStationIndex() const { - return (additions & RCT12_FOOTPATH_PROPERTIES_ADDITIONS_STATION_INDEX_MASK) >> 4; + return (Additions & RCT12_FOOTPATH_PROPERTIES_ADDITIONS_STATION_INDEX_MASK) >> 4; } bool RCT12PathElement::IsWide() const @@ -158,37 +158,37 @@ bool RCT12PathElement::IsQueue() const bool RCT12PathElement::HasQueueBanner() const { - return (entryIndex & RCT12_FOOTPATH_PROPERTIES_FLAG_HAS_QUEUE_BANNER) != 0; + return (EntryIndex & RCT12_FOOTPATH_PROPERTIES_FLAG_HAS_QUEUE_BANNER) != 0; } uint8_t RCT12PathElement::GetEdges() const { - return edges & FOOTPATH_PROPERTIES_EDGES_EDGES_MASK; + return Edges & FOOTPATH_PROPERTIES_EDGES_EDGES_MASK; } uint8_t RCT12PathElement::GetCorners() const { - return edges >> 4; + return Edges >> 4; } uint8_t RCT12PathElement::GetAddition() const { - return additions & RCT12_FOOTPATH_PROPERTIES_ADDITIONS_TYPE_MASK; + return Additions & RCT12_FOOTPATH_PROPERTIES_ADDITIONS_TYPE_MASK; } bool RCT12PathElement::AdditionIsGhost() const { - return (additions & RCT12_FOOTPATH_PROPERTIES_ADDITIONS_FLAG_GHOST) != 0; + return (Additions & RCT12_FOOTPATH_PROPERTIES_ADDITIONS_FLAG_GHOST) != 0; } uint8_t RCT12PathElement::GetAdditionStatus() const { - return additionStatus; + return AdditionStatus; } uint8_t RCT12PathElement::GetRCT1PathType() const { uint8_t pathColour = Type & 3; - uint8_t pathType2 = (entryIndex & RCT12_FOOTPATH_PROPERTIES_TYPE_MASK) >> 2; + uint8_t pathType2 = (EntryIndex & RCT12_FOOTPATH_PROPERTIES_TYPE_MASK) >> 2; pathType2 = pathType2 | pathColour; return pathType2; @@ -201,29 +201,29 @@ uint8_t RCT12PathElement::GetRCT1SupportType() const uint8_t RCT12TrackElement::GetTrackType() const { - return trackType; + return TrackType; } uint8_t RCT12TrackElement::GetSequenceIndex() const { - return sequence & RCT12_TRACK_ELEMENT_SEQUENCE_SEQUENCE_MASK; + return Sequence & RCT12_TRACK_ELEMENT_SEQUENCE_SEQUENCE_MASK; } uint8_t RCT12TrackElement::GetRideIndex() const { - return rideIndex; + return RideIndex; } uint8_t RCT12TrackElement::GetColourScheme() const { - return colour & 0x3; + return Colour & 0x3; } uint8_t RCT12TrackElement::GetStationIndex() const { - if (TrackTypeIsStation(trackType) || trackType == TrackElemType::TowerBase) + if (TrackTypeIsStation(TrackType) || TrackType == TrackElemType::TowerBase) { - return (sequence & RCT12_TRACK_ELEMENT_SEQUENCE_STATION_INDEX_MASK) >> 4; + return (Sequence & RCT12_TRACK_ELEMENT_SEQUENCE_STATION_INDEX_MASK) >> 4; } return 0; } @@ -235,59 +235,59 @@ bool RCT12TrackElement::HasChain() const bool RCT12TrackElement::HasCableLift() const { - return colour & RCT12_TRACK_ELEMENT_COLOUR_FLAG_CABLE_LIFT; + return Colour & RCT12_TRACK_ELEMENT_COLOUR_FLAG_CABLE_LIFT; } bool RCT12TrackElement::IsInverted() const { - return colour & RCT12_TRACK_ELEMENT_COLOUR_FLAG_INVERTED; + return Colour & RCT12_TRACK_ELEMENT_COLOUR_FLAG_INVERTED; } uint8_t RCT12TrackElement::GetBrakeBoosterSpeed() const { if (TrackTypeHasSpeedSetting(GetTrackType())) { - return (sequence >> 4) << 1; + return (Sequence >> 4) << 1; } return 0; } bool RCT12TrackElement::HasGreenLight() const { - if (TrackTypeIsStation(trackType)) + if (TrackTypeIsStation(TrackType)) { - return (sequence & MAP_ELEM_TRACK_SEQUENCE_GREEN_LIGHT) != 0; + return (Sequence & MAP_ELEM_TRACK_SEQUENCE_GREEN_LIGHT) != 0; } return false; } uint8_t RCT12TrackElement::GetSeatRotation() const { - return colour >> 4; + return Colour >> 4; } uint16_t RCT12TrackElement::GetMazeEntry() const { - return mazeEntry; + return MazeEntry; } uint8_t RCT12TrackElement::GetPhotoTimeout() const { if (GetTrackType() == TrackElemType::OnRidePhoto) { - return sequence >> 4; + return Sequence >> 4; } return 0; } uint8_t RCT12TrackElement::GetDoorAState() const { - return (colour & RCT12_TRACK_ELEMENT_DOOR_A_MASK) >> 2; + return (Colour & RCT12_TRACK_ELEMENT_DOOR_A_MASK) >> 2; } uint8_t RCT12TrackElement::GetDoorBState() const { - return (colour & RCT12_TRACK_ELEMENT_DOOR_B_MASK) >> 5; + return (Colour & RCT12_TRACK_ELEMENT_DOOR_B_MASK) >> 5; } bool RCT12TrackElement::IsIndestructible() const @@ -297,12 +297,12 @@ bool RCT12TrackElement::IsIndestructible() const uint8_t RCT12SmallSceneryElement::GetEntryIndex() const { - return this->entryIndex; + return this->EntryIndex; } uint8_t RCT12SmallSceneryElement::GetAge() const { - return this->age; + return this->Age; } uint8_t RCT12SmallSceneryElement::GetSceneryQuadrant() const @@ -312,46 +312,46 @@ uint8_t RCT12SmallSceneryElement::GetSceneryQuadrant() const colour_t RCT12SmallSceneryElement::GetPrimaryColour() const { - return colour_1 & TILE_ELEMENT_COLOUR_MASK; + return Colour1 & TILE_ELEMENT_COLOUR_MASK; } colour_t RCT12SmallSceneryElement::GetSecondaryColour() const { - return colour_2 & TILE_ELEMENT_COLOUR_MASK; + return Colour2 & TILE_ELEMENT_COLOUR_MASK; } bool RCT12SmallSceneryElement::NeedsSupports() const { - return colour_1 & MAP_ELEM_SMALL_SCENERY_COLOUR_FLAG_NEEDS_SUPPORTS; + return Colour1 & MAP_ELEM_SMALL_SCENERY_COLOUR_FLAG_NEEDS_SUPPORTS; } uint32_t RCT12LargeSceneryElement::GetEntryIndex() const { - return entryIndex & RCT12_TILE_ELEMENT_LARGE_TYPE_MASK; + return EntryIndex & RCT12_TILE_ELEMENT_LARGE_TYPE_MASK; } uint16_t RCT12LargeSceneryElement::GetSequenceIndex() const { - return (entryIndex >> 10); + return (EntryIndex >> 10); } colour_t RCT12LargeSceneryElement::GetPrimaryColour() const { - return colour[0] & TILE_ELEMENT_COLOUR_MASK; + return Colour[0] & TILE_ELEMENT_COLOUR_MASK; } colour_t RCT12LargeSceneryElement::GetSecondaryColour() const { - return colour[1] & TILE_ELEMENT_COLOUR_MASK; + return Colour[1] & TILE_ELEMENT_COLOUR_MASK; } uint8_t RCT12LargeSceneryElement::GetBannerIndex() const { - return (Type & 0xC0) | (((colour[0]) & ~TILE_ELEMENT_COLOUR_MASK) >> 2) | (((colour[1]) & ~TILE_ELEMENT_COLOUR_MASK) >> 5); + return (Type & 0xC0) | (((Colour[0]) & ~TILE_ELEMENT_COLOUR_MASK) >> 2) | (((Colour[1]) & ~TILE_ELEMENT_COLOUR_MASK) >> 5); } uint8_t RCT12WallElement::GetEntryIndex() const { - return entryIndex; + return EntryIndex; } uint8_t RCT12WallElement::GetSlope() const @@ -361,45 +361,45 @@ uint8_t RCT12WallElement::GetSlope() const colour_t RCT12WallElement::GetPrimaryColour() const { - return colour_1 & TILE_ELEMENT_COLOUR_MASK; + return Colour1 & TILE_ELEMENT_COLOUR_MASK; } colour_t RCT12WallElement::GetSecondaryColour() const { - uint8_t secondaryColour = (colour_1 & ~TILE_ELEMENT_COLOUR_MASK) >> 5; + uint8_t secondaryColour = (Colour1 & ~TILE_ELEMENT_COLOUR_MASK) >> 5; secondaryColour |= (Flags & 0x60) >> 2; return secondaryColour; } colour_t RCT12WallElement::GetTertiaryColour() const { - return colour_3 & TILE_ELEMENT_COLOUR_MASK; + return Colour3 & TILE_ELEMENT_COLOUR_MASK; } uint8_t RCT12WallElement::GetAnimationFrame() const { - return (animation >> 3) & 0xF; + return (Animation >> 3) & 0xF; } uint8_t RCT12WallElement::GetBannerIndex() const { - return banner_index; + return BannerIndex; } bool RCT12WallElement::IsAcrossTrack() const { - return (animation & WALL_ANIMATION_FLAG_ACROSS_TRACK) != 0; + return (Animation & WALL_ANIMATION_FLAG_ACROSS_TRACK) != 0; } bool RCT12WallElement::AnimationIsBackwards() const { - return (animation & WALL_ANIMATION_FLAG_DIRECTION_BACKWARD) != 0; + return (Animation & WALL_ANIMATION_FLAG_DIRECTION_BACKWARD) != 0; } int32_t RCT12WallElement::GetRCT1WallType(int32_t edge) const { - uint8_t var_05 = colour_3; - uint16_t var_06 = colour_1 | (animation << 8); + uint8_t var_05 = Colour3; + uint16_t var_06 = Colour1 | (Animation << 8); int32_t typeA = (var_05 >> (edge * 2)) & 3; int32_t typeB = (var_06 >> (edge * 4)) & 0x0F; @@ -414,47 +414,47 @@ int32_t RCT12WallElement::GetRCT1WallType(int32_t edge) const colour_t RCT12WallElement::GetRCT1WallColour() const { - return ((Type & 0xC0) >> 3) | ((entryIndex & 0xE0) >> 5); + return ((Type & 0xC0) >> 3) | ((EntryIndex & 0xE0) >> 5); } uint8_t RCT12WallElement::GetRCT1Slope() const { - return entryIndex & 0b00011111; + return EntryIndex & 0b00011111; } uint8_t RCT12EntranceElement::GetEntranceType() const { - return entranceType; + return EntranceType; } uint8_t RCT12EntranceElement::GetRideIndex() const { - return rideIndex; + return RideIndex; } uint8_t RCT12EntranceElement::GetStationIndex() const { - return (index & RCT12_TRACK_ELEMENT_SEQUENCE_STATION_INDEX_MASK) >> 4; + return (Index & RCT12_TRACK_ELEMENT_SEQUENCE_STATION_INDEX_MASK) >> 4; } uint8_t RCT12EntranceElement::GetSequenceIndex() const { - return index & 0xF; + return Index & 0xF; } uint8_t RCT12EntranceElement::GetPathType() const { - return pathType; + return PathType; } uint8_t RCT12BannerElement::GetIndex() const { - return index; + return Index; } uint8_t RCT12BannerElement::GetPosition() const { - return position; + return Position; } uint8_t RCT12BannerElement::GetAllowedEdges() const @@ -484,17 +484,17 @@ bool RCT12TrackElement::BlockBrakeClosed() const bool RCT12ResearchItem::IsInventedEndMarker() const { - return rawValue == RCT12_RESEARCHED_ITEMS_SEPARATOR; + return RawValue == RCT12_RESEARCHED_ITEMS_SEPARATOR; } bool RCT12ResearchItem::IsUninventedEndMarker() const { - return rawValue == RCT12_RESEARCHED_ITEMS_END; + return RawValue == RCT12_RESEARCHED_ITEMS_END; } bool RCT12ResearchItem::IsRandomEndMarker() const { - return rawValue == RCT12_RESEARCHED_ITEMS_END_2; + return RawValue == RCT12_RESEARCHED_ITEMS_END_2; } ObjectEntryIndex RCTEntryIndexToOpenRCT2EntryIndex(const RCT12ObjectEntryIndex index) @@ -841,15 +841,15 @@ ResearchItem RCT12ResearchItem::ToResearchItem() const } else { - newResearchItem.type = Research::EntryType{ type }; - newResearchItem.entryIndex = RCTEntryIndexToOpenRCT2EntryIndex(entryIndex); - newResearchItem.flags = flags; - newResearchItem.category = static_cast(category); + newResearchItem.type = Research::EntryType{ Type }; + newResearchItem.entryIndex = RCTEntryIndexToOpenRCT2EntryIndex(EntryIndex); + newResearchItem.flags = Flags; + newResearchItem.category = static_cast(Category); if (newResearchItem.type == Research::EntryType::Ride) { auto* rideEntry = GetRideEntryByIndex(newResearchItem.entryIndex); - newResearchItem.baseRideType = rideEntry != nullptr ? RCT2::RCT2RideTypeToOpenRCT2RideType(baseRideType, *rideEntry) - : baseRideType; + newResearchItem.baseRideType = rideEntry != nullptr ? RCT2::RCT2RideTypeToOpenRCT2RideType(BaseRideType, *rideEntry) + : BaseRideType; } else { diff --git a/src/openrct2/rct12/RCT12.h b/src/openrct2/rct12/RCT12.h index 73931515ae..4f6b2103bd 100644 --- a/src/openrct2/rct12/RCT12.h +++ b/src/openrct2/rct12/RCT12.h @@ -123,7 +123,7 @@ enum RCT12_TRACK_ELEMENT_DOOR_B_MASK = 0b11100000, }; -// Masks and flags for values stored in TileElement.properties.path.type +// Masks and Flags for values stored in TileElement.properties.path.type enum { RCT12_FOOTPATH_PROPERTIES_SLOPE_DIRECTION_MASK = (1 << 0) | (1 << 1), @@ -132,7 +132,7 @@ enum RCT12_FOOTPATH_PROPERTIES_TYPE_MASK = (1 << 4) | (1 << 5) | (1 << 6) | (1 << 7), }; -// Masks and flags for values stored in RCT12TileElement.properties.path.additions +// Masks and Flags for values stored in RCT12TileElement.properties.path.additions enum { RCT12_FOOTPATH_PROPERTIES_ADDITIONS_TYPE_MASK = (1 << 0) | (1 << 1) | (1 << 2) | (1 << 3), @@ -194,18 +194,18 @@ struct TD46MazeElement { union { - uint32_t all; + uint32_t All; struct { int8_t x; int8_t y; union { - uint16_t maze_entry; + uint16_t MazeEntry; struct { - uint8_t direction; - uint8_t type; + uint8_t Direction; + uint8_t Type; }; }; }; @@ -216,15 +216,15 @@ assert_struct_size(TD46MazeElement, 0x04); /* Track Element entry size: 0x02 */ struct TD46TrackElement { - uint8_t type; // 0x00 - uint8_t flags; // 0x01 + uint8_t Type; // 0x00 + uint8_t Flags; // 0x01 }; assert_struct_size(TD46TrackElement, 0x02); struct RCT12Award { - uint16_t time; - uint16_t type; + uint16_t Time; + uint16_t Type; }; assert_struct_size(RCT12Award, 4); @@ -311,7 +311,7 @@ struct RCT12EightCarsCorruptElement15; struct RCT12TileElementBase { uint8_t Type; // 0 - uint8_t Flags; // 1. Upper nibble: flags. Lower nibble: occupied quadrants (one bit per quadrant). + uint8_t Flags; // 1. Upper nibble: Flags. Lower nibble: occupied quadrants (one bit per quadrant). uint8_t BaseHeight; // 2 uint8_t ClearanceHeight; // 3 RCT12TileElementType GetType() const; @@ -407,10 +407,10 @@ assert_struct_size(RCT12TileElement, 8); struct RCT12SurfaceElement : RCT12TileElementBase { private: - uint8_t slope; // 4 0xE0 Edge Style, 0x1F Slope - uint8_t terrain; // 5 0xE0 Terrain Style, 0x1F Water height - uint8_t grass_length; // 6 - uint8_t ownership; // 7 + uint8_t Slope; // 4 0xE0 Edge Style, 0x1F Slope + uint8_t Terrain; // 5 0xE0 Terrain Style, 0x1F Water height + uint8_t GrassLength; // 6 + uint8_t Ownership; // 7 public: uint8_t GetSlope() const; uint32_t GetSurfaceStyle() const; @@ -425,13 +425,13 @@ assert_struct_size(RCT12SurfaceElement, 8); struct RCT12PathElement : RCT12TileElementBase { private: - uint8_t entryIndex; // 4, 0xF0 Path type, 0x08 Ride sign, 0x04 Set when path is sloped, 0x03 Rotation - uint8_t additions; // 5, 0bGSSSAAAA: G = Ghost, S = station index, A = addition (0 means no addition) - uint8_t edges; // 6 + uint8_t EntryIndex; // 4, 0xF0 Path type, 0x08 Ride sign, 0x04 Set when path is sloped, 0x03 Rotation + uint8_t Additions; // 5, 0bGSSSAAAA: G = Ghost, S = station index, A = addition (0 means no addition) + uint8_t Edges; // 6 union { - uint8_t additionStatus; // 7 - uint8_t rideIndex; + uint8_t AdditionStatus; // 7 + uint8_t RideIndex; }; public: @@ -460,7 +460,7 @@ assert_struct_size(RCT12PathElement, 8); struct RCT12TrackElement : RCT12TileElementBase { private: - uint8_t trackType; // 4 + uint8_t TrackType; // 4 union { struct @@ -476,12 +476,12 @@ private: // - Bits 7 and 8 are never set // - Bits 5 and 6 are set when a vehicle triggers the on-ride photo and act like a countdown from 3. // - If any of the bits 5-8 are set, the game counts it as a photo being taken. - uint8_t sequence; // 5. - uint8_t colour; // 6 + uint8_t Sequence; // 5. + uint8_t Colour; // 6 }; - uint16_t mazeEntry; // 5 + uint16_t MazeEntry; // 5 }; - uint8_t rideIndex; // 7 + uint8_t RideIndex; // 7 public: uint8_t GetTrackType() const; uint8_t GetSequenceIndex() const; @@ -507,10 +507,10 @@ assert_struct_size(RCT12TrackElement, 8); struct RCT12SmallSceneryElement : RCT12TileElementBase { private: - uint8_t entryIndex; // 4 - uint8_t age; // 5 - uint8_t colour_1; // 6 - uint8_t colour_2; // 7 + uint8_t EntryIndex; // 4 + uint8_t Age; // 5 + uint8_t Colour1; // 6 + uint8_t Colour2; // 7 public: RCT12ObjectEntryIndex GetEntryIndex() const; uint8_t GetAge() const; @@ -523,8 +523,8 @@ assert_struct_size(RCT12SmallSceneryElement, 8); struct RCT12LargeSceneryElement : RCT12TileElementBase { private: - uint16_t entryIndex; // 4 - uint8_t colour[2]; // 6 + uint16_t EntryIndex; // 4 + uint8_t Colour[2]; // 6 public: uint32_t GetEntryIndex() const; uint16_t GetSequenceIndex() const; @@ -536,14 +536,14 @@ assert_struct_size(RCT12LargeSceneryElement, 8); struct RCT12WallElement : RCT12TileElementBase { private: - uint8_t entryIndex; // 4 + uint8_t EntryIndex; // 4 union { - uint8_t colour_3; // 5 - uint8_t banner_index; // 5 + uint8_t Colour3; // 5 + uint8_t BannerIndex; // 5 }; - uint8_t colour_1; // 6 0b_2221_1111 2 = colour_2 (uses flags for rest of colour2), 1 = colour_1 - uint8_t animation; // 7 0b_dfff_ft00 d = direction, f = frame num, t = across track flag (not used) + uint8_t Colour1; // 6 0b_2221_1111 2 = colour_2 (uses Flags for rest of colour2), 1 = colour_1 + uint8_t Animation; // 7 0b_dfff_ft00 d = direction, f = frame num, t = across track flag (not used) public: RCT12ObjectEntryIndex GetEntryIndex() const; uint8_t GetSlope() const; @@ -562,10 +562,10 @@ assert_struct_size(RCT12WallElement, 8); struct RCT12EntranceElement : RCT12TileElementBase { private: - uint8_t entranceType; // 4 - uint8_t index; // 5. 0bUSSS????, S = station index. - uint8_t pathType; // 6 - uint8_t rideIndex; // 7 + uint8_t EntranceType; // 4 + uint8_t Index; // 5. 0bUSSS????, S = station index. + uint8_t PathType; // 6 + uint8_t RideIndex; // 7 public: uint8_t GetEntranceType() const; uint8_t GetRideIndex() const; @@ -577,12 +577,12 @@ assert_struct_size(RCT12EntranceElement, 8); struct RCT12BannerElement : RCT12TileElementBase { private: - uint8_t index; // 4 - uint8_t position; // 5 + uint8_t Index; // 4 + uint8_t Position; // 5 uint8_t AllowedEdges; // 6 #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wunused-private-field" - uint8_t unused; // 7 + uint8_t Unused; // 7 #pragma clang diagnostic pop public: uint8_t GetIndex() const; @@ -593,19 +593,19 @@ assert_struct_size(RCT12BannerElement, 8); struct RCT12CorruptElement : RCT12TileElementBase { - uint8_t pad[4]; + uint8_t Pad[4]; }; assert_struct_size(RCT12CorruptElement, 8); struct RCT12EightCarsCorruptElement14 : RCT12TileElementBase { - uint8_t pad[4]; + uint8_t Pad[4]; }; assert_struct_size(RCT12EightCarsCorruptElement14, 8); struct RCT12EightCarsCorruptElement15 : RCT12TileElementBase { - uint8_t pad[4]; + uint8_t Pad[4]; }; assert_struct_size(RCT12EightCarsCorruptElement15, 8); @@ -653,170 +653,170 @@ enum class RCT12PeepType : uint8_t struct RCT12EntityBase { - RCT12EntityIdentifier EntityIdentifier; // 0x00 - uint8_t type; // 0x01 - uint16_t next_in_quadrant; // 0x02 - uint16_t next; // 0x04 - uint16_t previous; // 0x06 - RCT12EntityLinkListOffset linked_list_type_offset; // 0x08 - uint8_t SpriteHeightNegative; // 0x09 - uint16_t EntityIndex; // 0x0A - uint16_t flags; // 0x0C - int16_t x; // 0x0E - int16_t y; // 0x10 - int16_t z; // 0x12 - uint8_t SpriteWidth; // 0x14 - uint8_t SpriteHeightPositive; // 0x15 - int16_t SpriteLeft; // 0x16 - int16_t SpriteTop; // 0x18 - int16_t SpriteRight; // 0x1A - int16_t SpriteBottom; // 0x1C - uint8_t EntityDirection; // 0x1E + RCT12EntityIdentifier EntityIdentifier; // 0x00 + uint8_t Type; // 0x01 + uint16_t NextInQuadrant; // 0x02 + uint16_t Next; // 0x04 + uint16_t Previous; // 0x06 + RCT12EntityLinkListOffset LinkedListTypeOffset; // 0x08 + uint8_t SpriteHeightNegative; // 0x09 + uint16_t EntityIndex; // 0x0A + uint16_t Flags; // 0x0C + int16_t x; // 0x0E + int16_t y; // 0x10 + int16_t z; // 0x12 + uint8_t SpriteWidth; // 0x14 + uint8_t SpriteHeightPositive; // 0x15 + int16_t SpriteLeft; // 0x16 + int16_t SpriteTop; // 0x18 + int16_t SpriteRight; // 0x1A + int16_t SpriteBottom; // 0x1C + uint8_t EntityDirection; // 0x1E }; assert_struct_size(RCT12EntityBase, 0x1F); struct RCT12EntityBalloon : RCT12EntityBase { uint8_t Pad1F[0x24 - 0x1F]; - uint16_t popped; // 0x24 - uint8_t time_to_move; // 0x26 - uint8_t frame; // 0x27 + uint16_t Popped; // 0x24 + uint8_t TimeToMove; // 0x26 + uint8_t Frame; // 0x27 uint8_t Pad28[4]; - uint8_t colour; // 0x2C + uint8_t Colour; // 0x2C }; assert_struct_size(RCT12EntityBalloon, 0x2D); struct RCT12EntityDuck : RCT12EntityBase { uint8_t Pad1F[0x26 - 0x1F]; - uint16_t frame; // 0x26 + uint16_t Frame; // 0x26 uint8_t Pad28[0x30 - 0x28]; - int16_t target_x; // 0x30 - int16_t target_y; // 0x32 + int16_t TargetX; // 0x30 + int16_t TargetY; // 0x32 uint8_t Pad34[0x14]; - uint8_t state; // 0x48 + uint8_t State; // 0x48 }; assert_struct_size(RCT12EntityDuck, 0x49); struct RCT12EntityLitter : RCT12EntityBase { uint8_t Pad1F[0x24 - 0x1F]; - uint32_t creationTick; // 0x24 + uint32_t CreationTick; // 0x24 }; assert_struct_size(RCT12EntityLitter, 0x28); struct RCT12EntityParticle : RCT12EntityBase { uint8_t Pad1F[0x26 - 0x1F]; - uint16_t frame; // 0x26 + uint16_t Frame; // 0x26 }; assert_struct_size(RCT12EntityParticle, 0x28); struct RCT12EntityJumpingFountain : RCT12EntityBase { uint8_t Pad1F[0x26 - 0x1F]; - uint8_t num_ticks_alive; // 0x26 - uint8_t frame; // 0x27 + uint8_t NumTicksAlive; // 0x26 + uint8_t Frame; // 0x27 uint8_t Pad28[0x2F - 0x28]; - uint8_t fountain_flags; // 0x2F - int16_t target_x; // 0x30 - int16_t target_y; // 0x32 + uint8_t FountainFlags; // 0x2F + int16_t TargetX; // 0x30 + int16_t TargetY; // 0x32 uint8_t Pad34[0x46 - 0x34]; - uint16_t iteration; // 0x46 + uint16_t Iteration; // 0x46 }; assert_struct_size(RCT12EntityJumpingFountain, 0x48); struct RCT12EntityMoneyEffect : RCT12EntityBase { uint8_t Pad1F[0x24 - 0x1F]; - uint16_t move_delay; // 0x24 - uint8_t num_movements; // 0x26 - uint8_t vertical; - money32 value; // 0x28 + uint16_t MoveDelay; // 0x24 + uint8_t NumMovements; // 0x26 + uint8_t Vertical; + money32 Value; // 0x28 uint8_t Pad2C[0x44 - 0x2C]; - int16_t offset_x; // 0x44 - uint16_t wiggle; // 0x46 + int16_t OffsetX; // 0x44 + uint16_t Wiggle; // 0x46 }; assert_struct_size(RCT12EntityMoneyEffect, 0x48); struct RCT12EntityCrashedVehicleParticle : RCT12EntityBase { uint8_t Pad1F[0x24 - 0x1F]; - uint16_t time_to_live; // 0x24 - uint16_t frame; // 0x26 + uint16_t TimeToLive; // 0x24 + uint16_t Frame; // 0x26 uint8_t Pad28[0x2C - 0x28]; - uint8_t colour[2]; // 0x2C + uint8_t Colour[2]; // 0x2C uint16_t CrashedEntityBase; // 0x2E - int16_t velocity_x; // 0x30 - int16_t velocity_y; // 0x32 - int16_t velocity_z; // 0x34 + int16_t VelocityX; // 0x30 + int16_t VelocityY; // 0x32 + int16_t VelocityZ; // 0x34 uint8_t Pad36[0x38 - 0x36]; - int32_t acceleration_x; // 0x38 - int32_t acceleration_y; // 0x3C - int32_t acceleration_z; // 0x40 + int32_t AccelerationX; // 0x38 + int32_t AccelerationY; // 0x3C + int32_t AccelerationZ; // 0x40 }; assert_struct_size(RCT12EntityCrashedVehicleParticle, 0x44); struct RCT12EntityCrashSplash : RCT12EntityBase { uint8_t Pad1F[0x26 - 0x1F]; - uint16_t frame; // 0x26 + uint16_t Frame; // 0x26 }; assert_struct_size(RCT12EntityCrashSplash, 0x28); struct RCT12EntitySteamParticle : RCT12EntityBase { uint8_t Pad1F[0x24 - 0x1F]; - uint16_t time_to_move; // 0x24 - uint16_t frame; // 0x26 + uint16_t TimeToMove; // 0x24 + uint16_t Frame; // 0x26 }; assert_struct_size(RCT12EntitySteamParticle, 0x28); struct RCT12PeepThought { - uint8_t type; - uint8_t item; - uint8_t freshness; - uint8_t fresh_timeout; + uint8_t Type; + uint8_t Item; + uint8_t Freshness; + uint8_t FreshTimeout; }; assert_struct_size(RCT12PeepThought, 4); struct RCT12RideMeasurement { - uint8_t ride_index; // 0x0000 - uint8_t flags; // 0x0001 - uint32_t last_use_tick; // 0x0002 - uint16_t num_items; // 0x0006 - uint16_t current_item; // 0x0008 - uint8_t vehicle_index; // 0x000A - uint8_t current_station; // 0x000B - int8_t vertical[RCT12::Limits::RideMeasurementMaxItems]; // 0x000C - int8_t lateral[RCT12::Limits::RideMeasurementMaxItems]; // 0x12CC - uint8_t velocity[RCT12::Limits::RideMeasurementMaxItems]; // 0x258C - uint8_t altitude[RCT12::Limits::RideMeasurementMaxItems]; // 0x384C + uint8_t RideIndex; // 0x0000 + uint8_t Flags; // 0x0001 + uint32_t LastUseTick; // 0x0002 + uint16_t NumItems; // 0x0006 + uint16_t CurrentItem; // 0x0008 + uint8_t VehicleIndex; // 0x000A + uint8_t CurrentStation; // 0x000B + int8_t Vertical[RCT12::Limits::RideMeasurementMaxItems]; // 0x000C + int8_t Lateral[RCT12::Limits::RideMeasurementMaxItems]; // 0x12CC + uint8_t Velocity[RCT12::Limits::RideMeasurementMaxItems]; // 0x258C + uint8_t Altitude[RCT12::Limits::RideMeasurementMaxItems]; // 0x384C }; assert_struct_size(RCT12RideMeasurement, 0x4B0C); struct RCT12Banner { - RCT12ObjectEntryIndex type; - uint8_t flags; // 0x01 - StringId string_idx; // 0x02 + RCT12ObjectEntryIndex Type; + uint8_t Flags; // 0x01 + ::StringId StringID; // 0x02 union { - uint8_t colour; // 0x04 - uint8_t ride_index; // 0x04 + uint8_t Colour; // 0x04 + uint8_t RideIndex; // 0x04 }; - uint8_t text_colour; // 0x05 - uint8_t x; // 0x06 - uint8_t y; // 0x07 + uint8_t TextColour; // 0x05 + uint8_t x; // 0x06 + uint8_t y; // 0x07 }; assert_struct_size(RCT12Banner, 8); struct RCT12MapAnimation { - uint8_t baseZ; - uint8_t type; + uint8_t BaseZ; + uint8_t Type; uint16_t x; uint16_t y; }; @@ -827,16 +827,16 @@ struct RCT12ResearchItem // Bit 16 (0: scenery entry, 1: ride entry) union { - uint32_t rawValue; + uint32_t RawValue; struct { - RCT12ObjectEntryIndex entryIndex; - uint8_t baseRideType; - uint8_t type; // 0: scenery entry, 1: ride entry - uint8_t flags; + RCT12ObjectEntryIndex EntryIndex; + uint8_t BaseRideType; + uint8_t Type; // 0: scenery entry, 1: ride entry + uint8_t Flags; }; }; - uint8_t category; + uint8_t Category; bool IsInventedEndMarker() const; bool IsRandomEndMarker() const; @@ -848,8 +848,8 @@ assert_struct_size(RCT12ResearchItem, 5); struct RCT12VehicleColour { - uint8_t body_colour; - uint8_t trim_colour; + uint8_t BodyColour; + uint8_t TrimColour; }; assert_struct_size(RCT12VehicleColour, 2); @@ -877,7 +877,7 @@ template std::vector RCT12GetRideTypesBeenOn(T* srcPeep) std::vector ridesTypesBeenOn; for (uint16_t i = 0; i < RCT12::Limits::MaxRideObjects; i++) { - if (srcPeep->ride_types_been_on[i / 8] & (1 << (i % 8))) + if (srcPeep->RideTypesBeenOn[i / 8] & (1 << (i % 8))) { ridesTypesBeenOn.push_back(i); } @@ -889,7 +889,7 @@ template std::vector RCT12GetRidesBeenOn(T* srcPeep) std::vector ridesBeenOn; for (uint16_t i = 0; i < RCT12::Limits::MaxRidesInPark; i++) { - if (srcPeep->rides_been_on[i / 8] & (1 << (i % 8))) + if (srcPeep->RidesBeenOn[i / 8] & (1 << (i % 8))) { ridesBeenOn.push_back(RideId::FromUnderlying(i)); } diff --git a/src/openrct2/rct2/RCT2.cpp b/src/openrct2/rct2/RCT2.cpp index ea89111a2b..4c1d1aa03f 100644 --- a/src/openrct2/rct2/RCT2.cpp +++ b/src/openrct2/rct2/RCT2.cpp @@ -118,24 +118,24 @@ namespace RCT2 uint8_t Ride::GetMinCarsPerTrain() const { - return min_max_cars_per_train >> 4; + return MinMaxCarsPerTrain >> 4; } uint8_t Ride::GetMaxCarsPerTrain() const { - return min_max_cars_per_train & 0xF; + return MinMaxCarsPerTrain & 0xF; } void Ride::SetMinCarsPerTrain(uint8_t newValue) { - min_max_cars_per_train &= ~0xF0; - min_max_cars_per_train |= (newValue << 4); + MinMaxCarsPerTrain &= ~0xF0; + MinMaxCarsPerTrain |= (newValue << 4); } void Ride::SetMaxCarsPerTrain(uint8_t newValue) { - min_max_cars_per_train &= ~0x0F; - min_max_cars_per_train |= newValue & 0x0F; + MinMaxCarsPerTrain &= ~0x0F; + MinMaxCarsPerTrain |= newValue & 0x0F; } bool RCT2TrackTypeIsBooster(ride_type_t rideType, uint16_t trackType) diff --git a/src/openrct2/rct2/RCT2.h b/src/openrct2/rct2/RCT2.h index 718593dbdf..1b61775f55 100644 --- a/src/openrct2/rct2/RCT2.h +++ b/src/openrct2/rct2/RCT2.h @@ -43,7 +43,7 @@ namespace RCT2 static_assert(RCT2_OBJECT_ENTRY_COUNT == 721); // clang-format off - constexpr const int32_t rct2_object_entry_group_counts[] = { + constexpr const int32_t RCT2ObjectEntryGroupCounts[] = { Limits::MaxRideObjects, Limits::MaxSmallSceneryObjects, Limits::MaxLargeSceneryObjects, @@ -69,220 +69,220 @@ namespace RCT2 */ struct Ride { - uint8_t type; // 0x000 + uint8_t Type; // 0x000 // pointer to static info. for example, wild mouse type is 0x36, subtype is // 0x4c. - RCT12ObjectEntryIndex subtype; // 0x001 - uint16_t Pad002; // 0x002 - uint8_t mode; // 0x004 - uint8_t colour_scheme_type; // 0x005 - RCT12VehicleColour vehicle_colours[Limits::MaxTrainsPerRide]; // 0x006 + RCT12ObjectEntryIndex Subtype; // 0x001 + uint16_t Pad002; // 0x002 + uint8_t Mode; // 0x004 + uint8_t ColourSchemeType; // 0x005 + RCT12VehicleColour VehicleColours[Limits::MaxTrainsPerRide]; // 0x006 uint8_t Pad046[0x03]; // 0x046, Used to be track colours in RCT1 without expansions // 0 = closed, 1 = open, 2 = test - uint8_t status; // 0x049 - StringId name; // 0x04A + uint8_t Status; // 0x049 + StringId Name; // 0x04A union { - uint32_t name_arguments; // 0x04C + uint32_t NameArguments; // 0x04C struct { - StringId name_arguments_type_name; // 0x04C - uint16_t name_arguments_number; // 0x04E + StringId NameArgumentsTypeName; // 0x04C + uint16_t NameArgumentsNumber; // 0x04E }; }; - RCT12xy8 overall_view; // 0x050 - RCT12xy8 station_starts[Limits::MaxStationsPerRide]; // 0x052 - uint8_t station_heights[Limits::MaxStationsPerRide]; // 0x05A - uint8_t station_length[Limits::MaxStationsPerRide]; // 0x05E - uint8_t station_depart[Limits::MaxStationsPerRide]; // 0x062 + RCT12xy8 OverallView; // 0x050 + RCT12xy8 StationStarts[Limits::MaxStationsPerRide]; // 0x052 + uint8_t StationHeights[Limits::MaxStationsPerRide]; // 0x05A + uint8_t StationLength[Limits::MaxStationsPerRide]; // 0x05E + uint8_t StationDepart[Limits::MaxStationsPerRide]; // 0x062 // ride->vehicle index for current train waiting for passengers // at station - uint8_t train_at_station[Limits::MaxStationsPerRide]; // 0x066 - RCT12xy8 entrances[Limits::MaxStationsPerRide]; // 0x06A - RCT12xy8 exits[Limits::MaxStationsPerRide]; // 0x072 - uint16_t last_peep_in_queue[Limits::MaxStationsPerRide]; // 0x07A - uint8_t Pad082[Limits::MaxStationsPerRide]; // 0x082, Used to be number of peeps in queue in RCT1, but this - // has moved. - uint16_t vehicles[Limits::MaxTrainsPerRide]; // 0x086, Points to the first car in the train - uint8_t depart_flags; // 0x0C6 + uint8_t TrainAtStation[Limits::MaxStationsPerRide]; // 0x066 + RCT12xy8 Entrances[Limits::MaxStationsPerRide]; // 0x06A + RCT12xy8 Exits[Limits::MaxStationsPerRide]; // 0x072 + uint16_t LastPeepInQueue[Limits::MaxStationsPerRide]; // 0x07A + uint8_t Pad082[Limits::MaxStationsPerRide]; // 0x082, Used to be number of peeps in queue in RCT1, but this + // has moved. + uint16_t Vehicles[Limits::MaxTrainsPerRide]; // 0x086, Points to the first car in the train + uint8_t DepartFlags; // 0x0C6 // Not sure if these should be uint or sint. - uint8_t num_stations; // 0x0C7 - uint8_t NumTrains; // 0x0C8 - uint8_t num_cars_per_train; // 0x0C9 - uint8_t ProposedNumTrains; // 0x0CA - uint8_t proposed_num_cars_per_train; // 0x0CB - uint8_t max_trains; // 0x0CC - uint8_t min_max_cars_per_train; // 0x0CD - uint8_t min_waiting_time; // 0x0CE - uint8_t max_waiting_time; // 0x0CF + uint8_t NumStations; // 0x0C7 + uint8_t NumTrains; // 0x0C8 + uint8_t NumCarsPerTrain; // 0x0C9 + uint8_t ProposedNumTrains; // 0x0CA + uint8_t ProposedNumCarsPerTrain; // 0x0CB + uint8_t MaxTrains; // 0x0CC + uint8_t MinMaxCarsPerTrain; // 0x0CD + uint8_t MinWaitingTime; // 0x0CE + uint8_t MaxWaitingTime; // 0x0CF union { - uint8_t operation_option; // 0x0D0 - uint8_t time_limit; // 0x0D0 - uint8_t NumLaps; // 0x0D0 - uint8_t launch_speed; // 0x0D0 - uint8_t speed; // 0x0D0 - uint8_t rotations; // 0x0D0 + uint8_t OperationOption; // 0x0D0 + uint8_t TimeLimit; // 0x0D0 + uint8_t NumLaps; // 0x0D0 + uint8_t LaunchSpeed; // 0x0D0 + uint8_t Speed; // 0x0D0 + uint8_t Rotations; // 0x0D0 }; - uint8_t boat_hire_return_direction; // 0x0D1 - RCT12xy8 boat_hire_return_position; // 0x0D2 - uint8_t measurement_index; // 0x0D4 + uint8_t BoatHireReturnDirection; // 0x0D1 + RCT12xy8 BoatHireReturnPosition; // 0x0D2 + uint8_t MeasurementIndex; // 0x0D4 // bits 0 through 4 are the number of helix sections // bit 5: spinning tunnel, water splash, or rapids // bit 6: log reverser, waterfall // bit 7: whirlpool - uint8_t special_track_elements; // 0x0D5 - uint8_t Pad0D6[2]; // 0x0D6 + uint8_t SpecialTrackElements; // 0x0D5 + uint8_t Pad0D6[2]; // 0x0D6 // Divide this value by 29127 to get the human-readable max speed // (in RCT2, display_speed = (max_speed * 9) >> 18) - int32_t max_speed; // 0x0D8 - int32_t average_speed; // 0x0DC - uint8_t current_test_segment; // 0x0E0 - uint8_t average_speed_test_timeout; // 0x0E1 + int32_t MaxSpeed; // 0x0D8 + int32_t AverageSpeed; // 0x0DC + uint8_t CurrentTestSegment; // 0x0E0 + uint8_t AverageSpeedTestTimeout; // 0x0E1 uint8_t Pad0E2[0x2]; // 0x0E2 - int32_t length[Limits::MaxStationsPerRide]; // 0x0E4 - uint16_t time[Limits::MaxStationsPerRide]; // 0x0F4 - fixed16_2dp max_positive_vertical_g; // 0x0FC - fixed16_2dp max_negative_vertical_g; // 0x0FE - fixed16_2dp max_lateral_g; // 0x100 - fixed16_2dp previous_vertical_g; // 0x102 - fixed16_2dp previous_lateral_g; // 0x104 + int32_t Length[Limits::MaxStationsPerRide]; // 0x0E4 + uint16_t Time[Limits::MaxStationsPerRide]; // 0x0F4 + fixed16_2dp MaxPositiveVerticalG; // 0x0FC + fixed16_2dp MaxNegativeVerticalG; // 0x0FE + fixed16_2dp MaxLateralG; // 0x100 + fixed16_2dp PreviousVerticalG; // 0x102 + fixed16_2dp PreviousLateralG; // 0x104 uint8_t Pad106[0x2]; // 0x106 - uint32_t testing_flags; // 0x108 + uint32_t TestingFlags; // 0x108 // x y map location of the current track piece during a test // this is to prevent counting special tracks multiple times - RCT12xy8 cur_test_track_location; // 0x10C + RCT12xy8 CurTestTrackLocation; // 0x10C // Next 3 variables are related (XXXX XYYY ZZZa aaaa) - uint16_t turn_count_default; // 0x10E X = current turn count - uint16_t turn_count_banked; // 0x110 - uint16_t turn_count_sloped; // 0x112 X = number turns > 3 elements + uint16_t TurnCountDefault; // 0x10E X = current turn count + uint16_t TurnCountBanked; // 0x110 + uint16_t TurnCountSloped; // 0x112 X = number turns > 3 elements union { - uint8_t inversions; // 0x114 (???X XXXX) - uint8_t holes; // 0x114 (???X XXXX) + uint8_t Inversions; // 0x114 (???X XXXX) + uint8_t Holes; // 0x114 (???X XXXX) // This is a very rough approximation of how much of the ride is undercover. // It reaches the maximum value of 7 at about 50% undercover and doesn't increase beyond that. - uint8_t sheltered_eighths; // 0x114 (XXX?-????) + uint8_t ShelteredEighths; // 0x114 (XXX?-????) }; // Y is number of powered lifts, X is drops - uint8_t drops; // 0x115 (YYXX XXXX) - uint8_t start_drop_height; // 0x116 - uint8_t highest_drop_height; // 0x117 - int32_t sheltered_length; // 0x118 + uint8_t Drops; // 0x115 (YYXX XXXX) + uint8_t StartDropHeight; // 0x116 + uint8_t HighestDropHeight; // 0x117 + int32_t ShelteredLength; // 0x118 // Unused always 0? Should affect nausea - uint16_t var_11C; // 0x11C - uint8_t num_sheltered_sections; // 0x11E (?abY YYYY) - // see cur_test_track_location - uint8_t cur_test_track_z; // 0x11F + uint16_t Var11C; // 0x11C + uint8_t NumShelteredSections; // 0x11E (?abY YYYY) + // see CurTestTrackLocation + uint8_t CurTestTrackZ; // 0x11F // Customer counter in the current 960 game tick (about 30 seconds) interval - uint16_t cur_num_customers; // 0x120 + uint16_t CurNumCustomers; // 0x120 // Counts ticks to update customer intervals, resets each 960 game ticks. - uint16_t num_customers_timeout; // 0x122 + uint16_t NumCustomersTimeout; // 0x122 // Customer count in the last 10 * 960 game ticks (sliding window) - uint16_t num_customers[Limits::CustomerHistorySize]; // 0x124 - money16 price; // 0x138 - RCT12xy8 chairlift_bullwheel_location[2]; // 0x13A - uint8_t chairlift_bullwheel_z[2]; // 0x13E + uint16_t NumCustomers[Limits::CustomerHistorySize]; // 0x124 + money16 Price; // 0x138 + RCT12xy8 ChairliftBullwheelLocation[2]; // 0x13A + uint8_t ChairliftBullwheelZ[2]; // 0x13E union { - RatingTuple ratings; // 0x140 + RatingTuple Ratings; // 0x140 struct { - ride_rating excitement; // 0x140 - ride_rating intensity; // 0x142 - ride_rating nausea; // 0x144 + ride_rating Excitement; // 0x140 + ride_rating Intensity; // 0x142 + ride_rating Nausea; // 0x144 }; }; - uint16_t value; // 0x146 - uint16_t chairlift_bullwheel_rotation; // 0x148 - uint8_t satisfaction; // 0x14A - uint8_t satisfaction_time_out; // 0x14B - uint8_t satisfaction_next; // 0x14C + uint16_t Value; // 0x146 + uint16_t ChairliftBullwheelRotation; // 0x148 + uint8_t Satisfaction; // 0x14A + uint8_t SatisfactionTimeOut; // 0x14B + uint8_t SatisfactionNext; // 0x14C // Various flags stating whether a window needs to be refreshed - uint8_t window_invalidate_flags; // 0x14D - uint8_t Pad14E[0x02]; // 0x14E - uint32_t total_customers; // 0x150 - money32 total_profit; // 0x154 - uint8_t popularity; // 0x158 - uint8_t popularity_time_out; // 0x159 Updated every purchase and ?possibly by time? - uint8_t popularity_next; // 0x15A When timeout reached this will be the next popularity - uint8_t num_riders; // 0x15B - uint8_t music_tune_id; // 0x15C - uint8_t slide_in_use; // 0x15D + uint8_t WindowInvalidateFlags; // 0x14D + uint8_t Pad14E[0x02]; // 0x14E + uint32_t TotalCustomers; // 0x150 + money32 TotalProfit; // 0x154 + uint8_t Popularity; // 0x158 + uint8_t PopularityTimeOut; // 0x159 Updated every purchase and ?possibly by time? + uint8_t PopularityNext; // 0x15A When timeout reached this will be the next popularity + uint8_t NumRiders; // 0x15B + uint8_t MusicTuneId; // 0x15C + uint8_t SlideInUse; // 0x15D union { - uint16_t slide_peep; // 0x15E - uint16_t maze_tiles; // 0x15E + uint16_t SlidePeep; // 0x15E + uint16_t MazeTiles; // 0x15E }; - uint8_t Pad160[0xE]; // 0x160 - uint8_t slide_peep_t_shirt_colour; // 0x16E - uint8_t Pad16F[0x7]; // 0x16F - uint8_t spiral_slide_progress; // 0x176 - uint8_t Pad177[0x9]; // 0x177 - int16_t build_date; // 0x180 - money16 upkeep_cost; // 0x182 - uint16_t race_winner; // 0x184 - uint8_t Pad186[0x02]; // 0x186 - uint32_t music_position; // 0x188 - uint8_t breakdown_reason_pending; // 0x18C - uint8_t mechanic_status; // 0x18D - uint16_t mechanic; // 0x18E - uint8_t inspection_station; // 0x190 - uint8_t broken_vehicle; // 0x191 - uint8_t broken_car; // 0x192 - uint8_t breakdown_reason; // 0x193 - money16 price_secondary; // 0x194 + uint8_t Pad160[0xE]; // 0x160 + uint8_t SlidePeepTShirtColour; // 0x16E + uint8_t Pad16F[0x7]; // 0x16F + uint8_t SpiralSlideProgress; // 0x176 + uint8_t Pad177[0x9]; // 0x177 + int16_t BuildDate; // 0x180 + money16 UpkeepCost; // 0x182 + uint16_t RaceWinner; // 0x184 + uint8_t Pad186[0x02]; // 0x186 + uint32_t MusicPosition; // 0x188 + uint8_t BreakdownReasonPending; // 0x18C + uint8_t MechanicStatus; // 0x18D + uint16_t Mechanic; // 0x18E + uint8_t InspectionStation; // 0x190 + uint8_t BrokenVehicle; // 0x191 + uint8_t BrokenCar; // 0x192 + uint8_t BreakdownReason; // 0x193 + money16 PriceSecondary; // 0x194 union { struct { - uint8_t reliability_subvalue; // 0x196, 0 - 255, acts like the decimals for reliability_percentage - uint8_t reliability_percentage; // 0x197, Starts at 100 and decreases from there. + uint8_t ReliabilitySubvalue; // 0x196, 0 - 255, acts like the decimals for reliability_percentage + uint8_t ReliabilityPercentage; // 0x197, Starts at 100 and decreases from there. }; - uint16_t reliability; // 0x196 + uint16_t Reliability; // 0x196 }; // Small constant used to increase the unreliability as the game continues, // making breakdowns more and more likely. - uint8_t unreliability_factor; // 0x198 + uint8_t UnreliabilityFactor; // 0x198 // Range from [0, 100] - uint8_t downtime; // 0x199 - uint8_t inspection_interval; // 0x19A - uint8_t last_inspection; // 0x19B - uint8_t downtime_history[Limits::DowntimeHistorySize]; // 0x19C - uint32_t no_primary_items_sold; // 0x1A4 - uint32_t no_secondary_items_sold; // 0x1A8 - uint8_t breakdown_sound_modifier; // 0x1AC + uint8_t Downtime; // 0x199 + uint8_t InspectionInterval; // 0x19A + uint8_t LastInspection; // 0x19B + uint8_t DowntimeHistory[Limits::DowntimeHistorySize]; // 0x19C + uint32_t NoPrimaryItemsSold; // 0x1A4 + uint32_t NoSecondaryItemsSold; // 0x1A8 + uint8_t BreakdownSoundModifier; // 0x1AC // Used to oscillate the sound when ride breaks down. // 0 = no change, 255 = max change - uint8_t not_fixed_timeout; // 0x1AD - uint8_t last_crash_type; // 0x1AE - uint8_t connected_message_throttle; // 0x1AF - money32 income_per_hour; // 0x1B0 - money32 profit; // 0x1B4 - uint8_t queue_time[Limits::MaxStationsPerRide]; // 0x1B8 - uint8_t track_colour_main[Limits::NumColourSchemes]; // 0x1BC - uint8_t track_colour_additional[Limits::NumColourSchemes]; // 0x1C0 - uint8_t track_colour_supports[Limits::NumColourSchemes]; // 0x1C4 - uint8_t music; // 0x1C8 - uint8_t entrance_style; // 0x1C9 - uint16_t vehicle_change_timeout; // 0x1CA - uint8_t num_block_brakes; // 0x1CC - uint8_t lift_hill_speed; // 0x1CD - uint16_t guests_favourite; // 0x1CE - uint32_t lifecycle_flags; // 0x1D0 - uint8_t vehicle_colours_extended[Limits::MaxTrainsPerRide]; // 0x1D4 - uint16_t total_air_time; // 0x1F4 - uint8_t current_test_station; // 0x1F6 - uint8_t num_circuits; // 0x1F7 - int16_t cable_lift_x; // 0x1F8 - int16_t cable_lift_y; // 0x1FA - uint8_t cable_lift_z; // 0x1FC - uint8_t Pad1FD; // 0x1FD - uint16_t cable_lift; // 0x1FE - uint16_t queue_length[Limits::MaxStationsPerRide]; // 0x200 - uint8_t Pad208[0x58]; // 0x208 + uint8_t NotFixedTimeout; // 0x1AD + uint8_t LastCrashType; // 0x1AE + uint8_t ConnectedMessageThrottle; // 0x1AF + money32 IncomePerHour; // 0x1B0 + money32 Profit; // 0x1B4 + uint8_t QueueTime[Limits::MaxStationsPerRide]; // 0x1B8 + uint8_t TrackColourMain[Limits::NumColourSchemes]; // 0x1BC + uint8_t TrackColourAdditional[Limits::NumColourSchemes]; // 0x1C0 + uint8_t TrackColourSupports[Limits::NumColourSchemes]; // 0x1C4 + uint8_t Music; // 0x1C8 + uint8_t EntranceStyle; // 0x1C9 + uint16_t VehicleChangeTimeout; // 0x1CA + uint8_t NumBlockBrakes; // 0x1CC + uint8_t LiftHillSpeed; // 0x1CD + uint16_t GuestsFavourite; // 0x1CE + uint32_t LifecycleFlags; // 0x1D0 + uint8_t VehicleColoursExtended[Limits::MaxTrainsPerRide]; // 0x1D4 + uint16_t TotalAirTime; // 0x1F4 + uint8_t CurrentTestStation; // 0x1F6 + uint8_t NumCircuits; // 0x1F7 + int16_t CableLiftX; // 0x1F8 + int16_t CableLiftY; // 0x1FA + uint8_t CableLiftZ; // 0x1FC + uint8_t Pad1FD; // 0x1FD + uint16_t CableLift; // 0x1FE + uint16_t QueueLength[Limits::MaxStationsPerRide]; // 0x200 + uint8_t Pad208[0x58]; // 0x208 uint8_t GetMinCarsPerTrain() const; uint8_t GetMaxCarsPerTrain() const; @@ -304,13 +304,13 @@ namespace RCT2 /* Track Scenery entry size: 0x16 */ struct TD6SceneryElement { - RCTObjectEntry scenery_object; // 0x00 - int8_t x; // 0x10 - int8_t y; // 0x11 - int8_t z; // 0x12 - uint8_t flags; // 0x13 direction quadrant tertiary colour - uint8_t primary_colour; // 0x14 - uint8_t secondary_colour; // 0x15 + RCTObjectEntry SceneryObject; // 0x00 + int8_t x; // 0x10 + int8_t y; // 0x11 + int8_t z; // 0x12 + uint8_t Flags; // 0x13 direction quadrant tertiary colour + uint8_t PrimaryColour; // 0x14 + uint8_t SecondaryColour; // 0x15 }; assert_struct_size(TD6SceneryElement, 0x16); @@ -320,71 +320,71 @@ namespace RCT2 */ struct TD6Track { - uint8_t type; // 0x00 - RCT12ObjectEntryIndex vehicle_type; + uint8_t Type; // 0x00 + RCT12ObjectEntryIndex VehicleType; union { // After loading the track this is converted to // a cost but before its a flags register - money32 cost; // 0x02 - uint32_t flags; // 0x02 + money32 Cost; // 0x02 + uint32_t Flags; // 0x02 }; union { // After loading the track this is converted to // a flags register - uint8_t ride_mode; // 0x06 - uint8_t track_flags; // 0x06 + uint8_t RideMode; // 0x06 + uint8_t TrackFlags; // 0x06 }; - uint8_t version_and_colour_scheme; // 0x07 0b0000_VVCC - RCT12VehicleColour vehicle_colours[Limits::MaxTrainsPerRide]; // 0x08 + uint8_t VersionAndColourScheme; // 0x07 0b0000_VVCC + RCT12VehicleColour VehicleColours[Limits::MaxTrainsPerRide]; // 0x08 union { uint8_t Pad48; - uint8_t track_spine_colour_rct1; // 0x48 + uint8_t TrackSpineColourRCT1; // 0x48 }; union { - uint8_t entrance_style; // 0x49 - uint8_t track_rail_colour_rct1; // 0x49 + uint8_t EntranceStyle; // 0x49 + uint8_t TrackRailColourRCT1; // 0x49 }; union { - uint8_t total_air_time; // 0x4A - uint8_t track_support_colour_rct1; // 0x4A + uint8_t TotalAirTime; // 0x4A + uint8_t TrackSupportColourRCT1; // 0x4A }; - uint8_t depart_flags; // 0x4B - uint8_t number_of_trains; // 0x4C - uint8_t number_of_cars_per_train; // 0x4D - uint8_t min_waiting_time; // 0x4E - uint8_t max_waiting_time; // 0x4F - uint8_t operation_setting; - int8_t max_speed; // 0x51 - int8_t average_speed; // 0x52 - uint16_t ride_length; // 0x53 - uint8_t max_positive_vertical_g; // 0x55 - int8_t max_negative_vertical_g; // 0x56 - uint8_t max_lateral_g; // 0x57 + uint8_t DepartFlags; // 0x4B + uint8_t NumberOfTrains; // 0x4C + uint8_t NumberOfCarsPerTrain; // 0x4D + uint8_t MinWaitingTime; // 0x4E + uint8_t MaxWaitingTime; // 0x4F + uint8_t OperationSetting; + int8_t MaxSpeed; // 0x51 + int8_t AverageSpeed; // 0x52 + uint16_t RideLength; // 0x53 + uint8_t MaxPositiveVerticalG; // 0x55 + int8_t MaxNegativeVerticalG; // 0x56 + uint8_t MaxLateralG; // 0x57 union { - uint8_t inversions; // 0x58 - uint8_t holes; // 0x58 + uint8_t Inversions; // 0x58 + uint8_t Holes; // 0x58 }; - uint8_t drops; // 0x59 - uint8_t highest_drop_height; // 0x5A - uint8_t excitement; // 0x5B - uint8_t intensity; // 0x5C - uint8_t nausea; // 0x5D - money16 upkeep_cost; // 0x5E - uint8_t track_spine_colour[Limits::NumColourSchemes]; // 0x60 - uint8_t track_rail_colour[Limits::NumColourSchemes]; // 0x64 - uint8_t track_support_colour[Limits::NumColourSchemes]; // 0x68 - uint32_t flags2; // 0x6C - RCTObjectEntry vehicle_object; // 0x70 - uint8_t space_required_x; // 0x80 - uint8_t space_required_y; // 0x81 - uint8_t vehicle_additional_colour[Limits::MaxTrainsPerRide]; // 0x82 - uint8_t lift_hill_speed_num_circuits; // 0xA2 0bCCCL_LLLL + uint8_t Drops; // 0x59 + uint8_t HighestDropHeight; // 0x5A + uint8_t Excitement; // 0x5B + uint8_t Intensity; // 0x5C + uint8_t Nausea; // 0x5D + money16 UpkeepCost; // 0x5E + uint8_t TrackSpineColour[Limits::NumColourSchemes]; // 0x60 + uint8_t TrackRailColour[Limits::NumColourSchemes]; // 0x64 + uint8_t TrackSupportColour[Limits::NumColourSchemes]; // 0x68 + uint32_t Flags2; // 0x6C + RCTObjectEntry VehicleObject; // 0x70 + uint8_t SpaceRequiredX; // 0x80 + uint8_t SpaceRequiredY; // 0x81 + uint8_t VehicleAdditionalColour[Limits::MaxTrainsPerRide]; // 0x82 + uint8_t LiftHillSpeedNumCircuits; // 0xA2 0bCCCL_LLLL // 0xA3 (data starts here in file) }; assert_struct_size(TD6Track, 0xA3); @@ -395,9 +395,9 @@ namespace RCT2 */ struct ScoresHeader { - uint32_t var_0; - uint32_t var_4; - uint32_t var_8; + uint32_t Var0; + uint32_t Var4; + uint32_t Var8; uint32_t ScenarioCount; }; assert_struct_size(ScoresHeader, 0x10); @@ -425,105 +425,105 @@ namespace RCT2 struct Vehicle : RCT12EntityBase { - uint8_t Pitch; // 0x1F - uint8_t bank_rotation; // 0x20 + uint8_t Pitch; // 0x1F + uint8_t BankRotation; // 0x20 uint8_t Pad21[3]; - int32_t remaining_distance; // 0x24 - int32_t velocity; // 0x28 - int32_t acceleration; // 0x2C - uint8_t ride; // 0x30 - uint8_t vehicle_type; // 0x31 - RCT12VehicleColour colours; // 0x32 + int32_t RemainingDistance; // 0x24 + int32_t Velocity; // 0x28 + int32_t Acceleration; // 0x2C + uint8_t Ride; // 0x30 + uint8_t VehicleType; // 0x31 + RCT12VehicleColour Colours; // 0x32 union { - uint16_t track_progress; // 0x34 + uint16_t TrackProgress; // 0x34 struct { - int8_t var_34; - uint8_t var_35; + int8_t Var34; + uint8_t Var35; }; }; union { int16_t TrackTypeAndDirection; // 0x36 - RCT12xy8 boat_location; // 0x36 + RCT12xy8 BoatLocation; // 0x36 }; - uint16_t track_x; // 0x38 - uint16_t track_y; // 0x3A - uint16_t track_z; // 0x3C - uint16_t next_vehicle_on_train; // 0x3E - uint16_t prev_vehicle_on_ride; // 0x40 - uint16_t next_vehicle_on_ride; // 0x42 - uint16_t var_44; - uint16_t mass; // 0x46 - uint16_t update_flags; // 0x48 + uint16_t TrackX; // 0x38 + uint16_t TrackY; // 0x3A + uint16_t TrackZ; // 0x3C + uint16_t NextVehicleOnTrain; // 0x3E + uint16_t PrevVehicleOnRide; // 0x40 + uint16_t NextVehicleOnRide; // 0x42 + uint16_t Var44; + uint16_t Mass; // 0x46 + uint16_t UpdateFlags; // 0x48 uint8_t SwingSprite; - uint8_t current_station; // 0x4B + uint8_t CurrentStation; // 0x4B union { int16_t SwingPosition; // 0x4C - int16_t current_time; // 0x4C + int16_t CurrentTime; // 0x4C struct { - int8_t ferris_wheel_var_0; // 0x4C - int8_t ferris_wheel_var_1; // 0x4D + int8_t FerrisWheelVar0; // 0x4C + int8_t FerrisWheelVar1; // 0x4D }; }; union { int16_t SwingSpeed; - int16_t crash_z; // 0x4E + int16_t CrashZ; // 0x4E }; - uint8_t status; // 0x50 - uint8_t sub_state; // 0x51 - uint16_t peep[32]; // 0x52 - uint8_t peep_tshirt_colours[32]; // 0x92 - uint8_t num_seats; // 0xB2 - uint8_t num_peeps; // 0xB3 - uint8_t next_free_seat; // 0xB4 - uint8_t restraints_position; // 0xB5 + uint8_t Status; // 0x50 + uint8_t SubState; // 0x51 + uint16_t Peep[32]; // 0x52 + uint8_t PeepTshirtColours[32]; // 0x92 + uint8_t NumSeats; // 0xB2 + uint8_t NumPeeps; // 0xB3 + uint8_t NextFreeSeat; // 0xB4 + uint8_t RestraintsPosition; // 0xB5 union { - int16_t spin_speed; // 0xB6 - int16_t crash_x; // 0xB6 + int16_t SpinSpeed; // 0xB6 + int16_t CrashX; // 0xB6 }; - uint16_t sound2_flags; // 0xB8 - uint8_t spin_sprite; // 0xBA - uint8_t sound1_id; // 0xBB - uint8_t sound1_volume; // 0xBC - uint8_t sound2_id; // 0xBD - uint8_t sound2_volume; // 0xBE - int8_t sound_vector_factor; + uint16_t Sound2Flags; // 0xB8 + uint8_t SpinSprite; // 0xBA + uint8_t Sound1Id; // 0xBB + uint8_t Sound1Volume; // 0xBC + uint8_t Sound2Id; // 0xBD + uint8_t Sound2Volume; // 0xBE + int8_t SoundVectorFactor; union { - uint16_t var_C0; - int16_t crash_y; // 0xC0 - uint16_t time_waiting; // 0xC0 - uint16_t cable_lift_target; // 0xC0 + uint16_t VarC0; + int16_t CrashY; // 0xC0 + uint16_t TimeWaiting; // 0xC0 + uint16_t CableLiftTarget; // 0xC0 }; - uint8_t speed; // 0xC2 - uint8_t powered_acceleration; // 0xC3 + uint8_t Speed; // 0xC2 + uint8_t PoweredAcceleration; // 0xC3 union { uint8_t DodgemsCollisionDirection; // 0xC4 uint8_t CollisionDetectionTimer; // 0xC4 }; - uint8_t animation_frame; // 0xC5 + uint8_t AnimationFrame; // 0xC5 uint8_t PadC6[0x2]; - uint32_t animationState; - uint8_t scream_sound_id; // 0xCC + uint32_t AnimationState; + uint8_t ScreamSoundId; // 0xCC uint8_t TrackSubposition; - uint8_t NumLaps; // 0xCE - uint8_t brake_speed; // 0xCF - uint16_t lost_time_out; // 0xD0 - int8_t vertical_drop_countdown; // 0xD1 - uint8_t var_D3; - uint8_t mini_golf_current_animation; - uint8_t mini_golf_flags; // 0xD5 - uint8_t ride_subtype; // 0xD6 - uint8_t colours_extended; // 0xD7 - uint8_t seat_rotation; // 0xD8 - uint8_t target_seat_rotation; // 0xD9 + uint8_t NumLaps; // 0xCE + uint8_t BrakeSpeed; // 0xCF + uint16_t LostTimeOut; // 0xD0 + int8_t VerticalDropCountdown; // 0xD1 + uint8_t VarD3; + uint8_t MiniGolfCurrentAnimation; + uint8_t MiniGolfFlags; // 0xD5 + uint8_t RideSubtype; // 0xD6 + uint8_t ColoursExtended; // 0xD7 + uint8_t SeatRotation; // 0xD8 + uint8_t TargetSeatRotation; // 0xD9 uint16_t GetTrackType() const { @@ -551,160 +551,160 @@ namespace RCT2 struct Peep : RCT12EntityBase { uint8_t Pad1F[0x22 - 0x1F]; - StringId name_string_idx; // 0x22 - uint16_t next_x; // 0x24 - uint16_t next_y; // 0x26 - uint8_t next_z; // 0x28 - uint8_t next_flags; // 0x29 - uint8_t outside_of_park; // 0x2A - uint8_t state; // 0x2B - uint8_t sub_state; // 0x2C - uint8_t sprite_type; // 0x2D - uint8_t peep_type; // 0x2E + StringId NameStringIdx; // 0x22 + uint16_t NextX; // 0x24 + uint16_t NextY; // 0x26 + uint8_t NextZ; // 0x28 + uint8_t NextFlags; // 0x29 + uint8_t OutsideOfPark; // 0x2A + uint8_t State; // 0x2B + uint8_t SubState; // 0x2C + uint8_t SpriteType; // 0x2D + uint8_t PeepType; // 0x2E union { - uint8_t staff_type; // 0x2F - uint8_t no_of_rides; // 0x2F + uint8_t StaffType; // 0x2F + uint8_t NoOfRides; // 0x2F }; - uint8_t tshirt_colour; // 0x30 - uint8_t trousers_colour; // 0x31 - uint16_t destination_x; // 0x32 - uint16_t destination_y; // 0x34 - uint8_t destination_tolerance; // 0x36 - uint8_t var_37; - uint8_t energy; // 0x38 - uint8_t energy_target; // 0x39 - uint8_t happiness; // 0x3A - uint8_t happiness_target; // 0x3B - uint8_t nausea; // 0x3C - uint8_t nausea_target; // 0x3D - uint8_t hunger; // 0x3E - uint8_t thirst; // 0x3F - uint8_t toilet; // 0x40 - uint8_t mass; // 0x41 - uint8_t time_to_consume; // 0x42 - uint8_t intensity; // 0x43 - uint8_t nausea_tolerance; // 0x44 - uint8_t window_invalidate_flags; // 0x45 - money16 paid_on_drink; // 0x46 - uint8_t ride_types_been_on[16]; // 0x48 - uint32_t item_extra_flags; // 0x58 - RCT12RideId photo2_ride_ref; // 0x5C - RCT12RideId photo3_ride_ref; // 0x5D - RCT12RideId photo4_ride_ref; // 0x5E - uint8_t Pad5F[0x09]; // 0x5F - RCT12RideId current_ride; // 0x68 - uint8_t current_ride_station; // 0x69 - uint8_t current_train; // 0x6A + uint8_t TshirtColour; // 0x30 + uint8_t TrousersColour; // 0x31 + uint16_t DestinationX; // 0x32 + uint16_t DestinationY; // 0x34 + uint8_t DestinationTolerance; // 0x36 + uint8_t Var37; + uint8_t Energy; // 0x38 + uint8_t EnergyTarget; // 0x39 + uint8_t Happiness; // 0x3A + uint8_t HappinessTarget; // 0x3B + uint8_t Nausea; // 0x3C + uint8_t NauseaTarget; // 0x3D + uint8_t Hunger; // 0x3E + uint8_t Thirst; // 0x3F + uint8_t Toilet; // 0x40 + uint8_t Mass; // 0x41 + uint8_t TimeToConsume; // 0x42 + uint8_t Intensity; // 0x43 + uint8_t NauseaTolerance; // 0x44 + uint8_t WindowInvalidateFlags; // 0x45 + money16 PaidOnDrink; // 0x46 + uint8_t RideTypesBeenOn[16]; // 0x48 + uint32_t ItemExtraFlags; // 0x58 + RCT12RideId Photo2RideRef; // 0x5C + RCT12RideId Photo3RideRef; // 0x5D + RCT12RideId Photo4RideRef; // 0x5E + uint8_t Pad5F[0x09]; // 0x5F + RCT12RideId CurrentRide; // 0x68 + uint8_t CurrentRideStation; // 0x69 + uint8_t CurrentTrain; // 0x6A union { struct { - uint8_t current_car; // 0x6B - uint8_t current_seat; // 0x6C + uint8_t CurrentCar; // 0x6B + uint8_t CurrentSeat; // 0x6C }; - uint16_t time_to_sitdown; // 0x6B + uint16_t TimeToSitdown; // 0x6B struct { - uint8_t time_to_stand; // 0x6B - uint8_t standing_flags; // 0x6C + uint8_t TimeToStand; // 0x6B + uint8_t StandingFlags; // 0x6C }; }; - uint8_t special_sprite; // 0x6D - uint8_t action_sprite_type; // 0x6E - uint8_t next_action_sprite_type; // 0x6F - uint8_t action_sprite_image_offset; // 0x70 - uint8_t action; // 0x71 - uint8_t action_frame; // 0x72 - uint8_t step_progress; // 0x73 + uint8_t SpecialSprite; // 0x6D + uint8_t ActionSpriteType; // 0x6E + uint8_t NextActionSpriteType; // 0x6F + uint8_t ActionSpriteImageOffset; // 0x70 + uint8_t Action; // 0x71 + uint8_t ActionFrame; // 0x72 + uint8_t StepProgress; // 0x73 union { - uint16_t mechanic_time_since_call; - uint16_t next_in_queue; // 0x74 + uint16_t MechanicTimeSinceCall; + uint16_t NextInQueue; // 0x74 }; uint8_t Pad76; uint8_t Pad77; union { - uint8_t maze_last_edge; // 0x78 - uint8_t direction; + uint8_t MazeLastEdge; // 0x78 + uint8_t Direction; }; - RCT12RideId interaction_ride_index; - uint16_t time_in_queue; // 0x7A - uint8_t rides_been_on[32]; // 0x7C - uint32_t id; // 0x9C - money32 cash_in_pocket; // 0xA0 - money32 cash_spent; // 0xA4 - int32_t park_entry_time; // 0xA8 - int8_t rejoin_queue_timeout; // 0xAC - RCT12RideId previous_ride; // 0xAD - uint16_t previous_ride_time_out; // 0xAE - RCT12PeepThought thoughts[Limits::MaxPeepThoughts]; // 0xB0 - uint8_t path_check_optimisation; // 0xC4 + RCT12RideId InteractionRideIndex; + uint16_t TimeInQueue; // 0x7A + uint8_t RidesBeenOn[32]; // 0x7C + uint32_t Id; // 0x9C + money32 CashInPocket; // 0xA0 + money32 CashSpent; // 0xA4 + int32_t ParkEntryTime; // 0xA8 + int8_t RejoinQueueTimeout; // 0xAC + RCT12RideId PreviousRide; // 0xAD + uint16_t PreviousRideTimeOut; // 0xAE + RCT12PeepThought Thoughts[Limits::MaxPeepThoughts]; // 0xB0 + uint8_t PathCheckOptimisation; // 0xC4 union { - uint8_t staff_id; // 0xC5 - RCT12RideId guest_heading_to_ride_id; // 0xC5 + uint8_t StaffId; // 0xC5 + RCT12RideId GuestHeadingToRideId; // 0xC5 }; union { - uint8_t staff_orders; // 0xC6 - uint8_t peep_is_lost_countdown; // 0xC6 + uint8_t StaffOrders; // 0xC6 + uint8_t PeepIsLostCountdown; // 0xC6 }; - RCT12RideId photo1_ride_ref; // 0xC7 - uint32_t peep_flags; // 0xC8 - RCT12xyzd8 pathfind_goal; // 0xCC - RCT12xyzd8 pathfind_history[4]; // 0xD0 - uint8_t no_action_frame_num; // 0xE0 - uint8_t litter_count; // 0xE1 + RCT12RideId Photo1RideRef; // 0xC7 + uint32_t PeepFlags; // 0xC8 + RCT12xyzd8 PathfindGoal; // 0xCC + RCT12xyzd8 PathfindHistory[4]; // 0xD0 + uint8_t NoActionFrameNum; // 0xE0 + uint8_t LitterCount; // 0xE1 union { - uint8_t time_on_ride; // 0xE2 - uint8_t staff_mowing_timeout; // 0xE2 + uint8_t TimeOnRide; // 0xE2 + uint8_t StaffMowingTimeout; // 0xE2 }; - uint8_t disgusting_count; // 0xE3 + uint8_t DisgustingCount; // 0xE3 union { - money16 paid_to_enter; // 0xE4 - uint16_t staff_lawns_mown; // 0xE4 - uint16_t staff_rides_fixed; // 0xE4 + money16 PaidToEnter; // 0xE4 + uint16_t StaffLawnsMown; // 0xE4 + uint16_t StaffRidesFixed; // 0xE4 }; union { - money16 paid_on_rides; // 0xE6 - uint16_t staff_gardens_watered; // 0xE6 - uint16_t staff_rides_inspected; // 0xE6 + money16 PaidOnRides; // 0xE6 + uint16_t StaffGardensWatered; // 0xE6 + uint16_t StaffRidesInspected; // 0xE6 }; union { - money16 paid_on_food; // 0xE8 - uint16_t staff_litter_swept; // 0xE8 + money16 PaidOnFood; // 0xE8 + uint16_t StaffLitterSwept; // 0xE8 }; union { - money16 paid_on_souvenirs; // 0xEA - uint16_t staff_bins_emptied; // 0xEA + money16 PaidOnSouvenirs; // 0xEA + uint16_t StaffBinsEmptied; // 0xEA }; - uint8_t no_of_food; // 0xEC - uint8_t no_of_drinks; // 0xED - uint8_t no_of_souvenirs; // 0xEE - uint8_t vandalism_seen; // 0xEF 0xC0 vandalism thought timeout, 0x3F vandalism tiles seen - uint8_t voucher_type; // 0xF0 - RCT12RideId voucher_arguments; // 0xF1 ride_id or string_offset_id - uint8_t surroundings_thought_timeout; // 0xF2 - uint8_t angriness; // 0xF3 - uint8_t time_lost; // 0xF4 the time the peep has been lost when it reaches 254 generates the lost thought - uint8_t days_in_queue; // 0xF5 - uint8_t balloon_colour; // 0xF6 - uint8_t umbrella_colour; // 0xF7 - uint8_t hat_colour; // 0xF8 - RCT12RideId favourite_ride; // 0xF9 - uint8_t favourite_ride_rating; // 0xFA + uint8_t NoOfFood; // 0xEC + uint8_t NoOfDrinks; // 0xED + uint8_t NoOfSouvenirs; // 0xEE + uint8_t VandalismSeen; // 0xEF 0xC0 vandalism thought timeout, 0x3F vandalism tiles seen + uint8_t VoucherType; // 0xF0 + RCT12RideId VoucherArguments; // 0xF1 ride_id or string_offset_id + uint8_t SurroundingsThoughtTimeout; // 0xF2 + uint8_t Angriness; // 0xF3 + uint8_t TimeLost; // 0xF4 the time the peep has been lost when it reaches 254 generates the lost thought + uint8_t DaysInQueue; // 0xF5 + uint8_t BalloonColour; // 0xF6 + uint8_t UmbrellaColour; // 0xF7 + uint8_t HatColour; // 0xF8 + RCT12RideId FavouriteRide; // 0xF9 + uint8_t FavouriteRideRating; // 0xFA uint8_t PadFB; - uint32_t item_standard_flags; // 0xFC + uint32_t ItemStandardFlags; // 0xFC uint64_t GetItemFlags() const { - return item_standard_flags | (static_cast(item_extra_flags) << 32); + return ItemStandardFlags | (static_cast(ItemExtraFlags) << 32); } }; assert_struct_size(Peep, 0x100); @@ -722,38 +722,38 @@ namespace RCT2 uint8_t Pad00[0x100]; public: - RCT12EntityBase unknown; - Vehicle vehicle; - Peep peep; - RCT12EntityLitter litter; - RCT12EntityBalloon balloon; - RCT12EntityDuck duck; - RCT12EntityJumpingFountain jumping_fountain; - RCT12EntityMoneyEffect money_effect; - RCT12EntityCrashedVehicleParticle crashed_vehicle_particle; - RCT12EntityCrashSplash crash_splash; - RCT12EntitySteamParticle steam_particle; - RCT12EntityParticle misc_particle; + RCT12EntityBase Unknown; + RCT2::Vehicle Vehicle; + RCT2::Peep Peep; + RCT12EntityLitter Litter; + RCT12EntityBalloon Balloon; + RCT12EntityDuck Duck; + RCT12EntityJumpingFountain JumpingFountain; + RCT12EntityMoneyEffect MoneyEffect; + RCT12EntityCrashedVehicleParticle CrashedVehicleParticle; + RCT12EntityCrashSplash CrashSplash; + RCT12EntitySteamParticle SteamParticle; + RCT12EntityParticle MiscParticle; }; assert_struct_size(Entity, 0x100); struct RideRatingCalculationData { - uint16_t proximity_x; - uint16_t proximity_y; - uint16_t proximity_z; - uint16_t proximity_start_x; - uint16_t proximity_start_y; - uint16_t proximity_start_z; - uint8_t current_ride; - uint8_t state; - uint8_t proximity_track_type; - uint8_t proximity_BaseHeight; - uint16_t proximity_total; - uint16_t proximity_scores[26]; - uint16_t num_brakes; - uint16_t num_reversers; - uint16_t station_flags; + uint16_t ProximityX; + uint16_t ProximityY; + uint16_t ProximityZ; + uint16_t ProximityStartX; + uint16_t ProximityStartY; + uint16_t ProximityStartZ; + uint8_t CurrentRide; + uint8_t State; + uint8_t ProximityTrackType; + uint8_t ProximityBaseHeight; + uint16_t ProximityTotal; + uint16_t ProximityScores[26]; + uint16_t NumBrakes; + uint16_t NumReversers; + uint16_t StationFlags; }; assert_struct_size(RideRatingCalculationData, 76); @@ -763,11 +763,11 @@ namespace RCT2 */ struct S6Header { - uint8_t type; // 0x00 - uint8_t classic_flag; // 0x01 - uint16_t num_packed_objects; // 0x02 - uint32_t version; // 0x04 - uint32_t magic_number; // 0x08 + uint8_t Type; // 0x00 + uint8_t ClassicFlag; // 0x01 + uint16_t NumPackedObjects; // 0x02 + uint32_t Version; // 0x04 + uint32_t MagicNumber; // 0x08 uint8_t Pad0C[0x14]; }; assert_struct_size(S6Header, 0x20); @@ -778,26 +778,26 @@ namespace RCT2 */ struct S6Info { - EditorStep editor_step; - uint8_t category; // 0x01 - uint8_t objective_type; // 0x02 - uint8_t objective_arg_1; // 0x03 - int32_t objective_arg_2; // 0x04 - int16_t objective_arg_3; // 0x08 + ::EditorStep EditorStep; + uint8_t Category; // 0x01 + uint8_t ObjectiveType; // 0x02 + uint8_t ObjectiveArg1; // 0x03 + int32_t ObjectiveArg2; // 0x04 + int16_t ObjectiveArg3; // 0x08 uint8_t Pad00A[0x3E]; - char name[64]; // 0x48 - char details[256]; // 0x88 - RCTObjectEntry entry; // 0x188 + char Name[64]; // 0x48 + char Details[256]; // 0x88 + RCTObjectEntry Entry; // 0x188 }; assert_struct_size(S6Info, 0x198); struct S6Data { // SC6[0] - S6Header header; + S6Header Header; // SC6[1] - S6Info info; + S6Info Info; // SC6[2] // packed objects @@ -823,210 +823,210 @@ namespace RCT2 }; // SC6[4] - uint16_t elapsed_months; - uint16_t current_day; - uint32_t scenario_ticks; - uint32_t scenario_srand_0; - uint32_t scenario_srand_1; + uint16_t ElapsedMonths; + uint16_t CurrentDay; + uint32_t ScenarioTicks; + uint32_t ScenarioSrand0; + uint32_t ScenarioSrand1; // SC6[5] - RCT12TileElement tile_elements[Limits::MaxTileElements]; + RCT12TileElement TileElements[Limits::MaxTileElements]; // SC6[6] - uint32_t next_free_tile_element_pointer_index; - Entity sprites[Limits::MaxEntitiesRCTCExtended]; - uint16_t sprite_lists_head[static_cast(EntityListId::Count)]; - uint16_t sprite_lists_count[static_cast(EntityListId::Count)]; - StringId park_name; + uint32_t NextFreeTileElementPointerIndex; + Entity Entities[Limits::MaxEntitiesRCTCExtended]; + uint16_t EntityListsHead[static_cast(EntityListId::Count)]; + uint16_t EntityListsCount[static_cast(EntityListId::Count)]; + StringId ParkName; uint8_t Pad013573D6[2]; - uint32_t park_name_args; - money32 initial_cash; - money32 current_loan; - uint32_t park_flags; - money16 park_entrance_fee; - uint16_t rct1_park_entrance_x; - uint16_t rct1_park_entrance_y; + uint32_t ParkNameArgs; + money32 InitialCash; + money32 CurrentLoan; + uint32_t ParkFlags; + money16 ParkEntranceFee; + uint16_t RCT1ParkEntranceX; + uint16_t RCT1ParkEntranceY; uint8_t Pad013573EE[2]; - uint8_t rct1_park_entrance_z; + uint8_t RCT1ParkEntranceZ; uint8_t Pad013573F1; - RCT12PeepSpawn peep_spawns[Limits::MaxPeepSpawns]; - uint8_t guest_count_change_modifier; - uint8_t current_research_level; + RCT12PeepSpawn PeepSpawns[Limits::MaxPeepSpawns]; + uint8_t GuestCountChangeModifier; + uint8_t CurrentResearchLevel; uint8_t Pad01357400[4]; - uint32_t researched_ride_types[Limits::MaxResearchedRideTypeQuads]; - uint32_t researched_ride_entries[Limits::MaxResearchedRideEntryQuads]; - uint32_t researched_track_types_a[128]; - uint32_t researched_track_types_b[128]; + uint32_t ResearchedRideTypes[Limits::MaxResearchedRideTypeQuads]; + uint32_t ResearchedRideEntries[Limits::MaxResearchedRideEntryQuads]; + uint32_t ResearchedTrackTypesA[128]; + uint32_t ResearchedTrackTypesB[128]; // SC6[7] - uint16_t guests_in_park; - uint16_t guests_heading_for_park; + uint16_t GuestsInPark; + uint16_t GuestsHeadingForPark; // Ignored in scenario - money32 expenditure_table[Limits::ExpenditureTableMonthCount][Limits::ExpenditureTypeCount]; + money32 ExpenditureTable[Limits::ExpenditureTableMonthCount][Limits::ExpenditureTypeCount]; // SC6[8] - uint16_t last_guests_in_park; + uint16_t LastGuestsInPark; uint8_t Pad01357BCA[3]; - uint8_t handyman_colour; - uint8_t mechanic_colour; - uint8_t security_colour; + uint8_t HandymanColour; + uint8_t MechanicColour; + uint8_t SecurityColour; // Ignored in scenario - uint32_t researched_scenery_items[Limits::MaxResearchedSceneryItemQuads]; + uint32_t ResearchedSceneryItems[Limits::MaxResearchedSceneryItemQuads]; // SC6[9] - uint16_t park_rating; + uint16_t ParkRating; // Ignored in scenario - uint8_t park_rating_history[32]; - uint8_t guests_in_park_history[32]; + uint8_t ParkRatingHistory[32]; + uint8_t GuestsInParkHistory[32]; // SC6[10] - uint8_t active_research_types; - uint8_t research_progress_stage; - uint32_t last_researched_item_subject; + uint8_t ActiveResearchTypes; + uint8_t ResearchProgressStage; + uint32_t LastResearchedItemSubject; uint8_t Pad01357CF8[1000]; - uint32_t next_research_item; - uint16_t research_progress; - uint8_t next_research_category; - uint8_t next_research_expected_day; - uint8_t next_research_expected_month; - uint8_t guest_initial_happiness; - uint16_t park_size; - uint16_t guest_generation_probability; - uint16_t total_ride_value_for_money; - money32 maximum_loan; - money16 guest_initial_cash; - uint8_t guest_initial_hunger; - uint8_t guest_initial_thirst; - uint8_t objective_type; - uint8_t objective_year; + uint32_t NextResearchItem; + uint16_t ResearchProgress; + uint8_t NextResearchCategory; + uint8_t NextResearchExpectedDay; + uint8_t NextResearchExpectedMonth; + uint8_t GuestInitialHappiness; + uint16_t ParkSize; + uint16_t GuestGenerationProbability; + uint16_t TotalRideValueForMoney; + money32 MaximumLoan; + money16 GuestInitialCash; + uint8_t GuestInitialHunger; + uint8_t GuestInitialThirst; + uint8_t ObjectiveType; + uint8_t ObjectiveYear; uint8_t Pad013580FA[2]; - money32 objective_currency; - uint16_t objective_guests; - uint8_t campaign_weeks_left[20]; - uint8_t campaign_ride_index[22]; + money32 ObjectiveCurrency; + uint16_t ObjectiveGuests; + uint8_t CampaignWeeksLeft[20]; + uint8_t CampaignRideIndex[22]; // Ignored in scenario - money32 balance_history[Limits::FinanceGraphSize]; + money32 BalanceHistory[Limits::FinanceGraphSize]; // SC6[11] - money32 current_expenditure; - money32 current_profit; - money32 weekly_profit_average_dividend; - uint16_t weekly_profit_average_divisor; + money32 CurrentExpenditure; + money32 CurrentProfit; + money32 WeeklyProfitAverageDividend; + uint16_t WeeklyProfitAverageDivisor; uint8_t Pad0135833A[2]; // Ignored in scenario - money32 weekly_profit_history[Limits::FinanceGraphSize]; + money32 WeeklyProfitHistory[Limits::FinanceGraphSize]; // SC6[12] - money32 park_value; + money32 ParkValue; // Ignored in scenario - money32 park_value_history[Limits::FinanceGraphSize]; + money32 ParkValueHistory[Limits::FinanceGraphSize]; // SC6[13] - money32 completed_company_value; - uint32_t total_admissions; - money32 income_from_admissions; - money32 company_value; - uint8_t peep_warning_throttle[16]; - RCT12Award awards[Limits::MaxAwards]; - money16 land_price; - money16 construction_rights_price; - uint16_t word_01358774; + money32 CompletedCompanyValue; + uint32_t TotalAdmissions; + money32 IncomeFromAdmissions; + money32 CompanyValue; + uint8_t PeepWarningThrottle[16]; + RCT12Award Awards[Limits::MaxAwards]; + money16 LandPrice; + money16 ConstructionRightsPrice; + uint16_t Word01358774; uint8_t Pad01358776[2]; - uint32_t cd_key; + uint32_t CDKey; uint8_t Pad0135877C[64]; - uint32_t game_version_number; - money32 completed_company_value_record; - uint32_t loan_hash; - uint16_t ride_count; + uint32_t GameVersionNumber; + money32 CompletedCompanyValueRecord; + uint32_t LoanHash; + uint16_t RideCount; uint8_t Pad013587CA[6]; - money32 historical_profit; + money32 HistoricalProfit; uint8_t Pad013587D4[4]; - char scenario_completed_name[32]; - money32 cash; + char ScenarioCompletedName[32]; + money32 Cash; uint8_t Pad013587FC[50]; - uint16_t park_rating_casualty_penalty; - uint16_t map_size_units; - uint16_t map_size_minus_2; - uint16_t map_size; - uint16_t map_max_xy; - uint32_t same_price_throughout; - uint16_t suggested_max_guests; - uint16_t park_rating_warning_days; - uint8_t last_entrance_style; - uint8_t rct1_water_colour; + uint16_t ParkRatingCasualtyPenalty; + uint16_t MapSizeUnits; + uint16_t MapSizeMinus2; + uint16_t MapSize; + uint16_t MapMaxXy; + uint32_t SamePriceThroughout; + uint16_t SuggestedMaxGuests; + uint16_t ParkRatingWarningDays; + uint8_t LastEntranceStyle; + uint8_t RCT1WaterColour; uint8_t Pad01358842[2]; - RCT12ResearchItem research_items[Limits::MaxResearchItems]; - uint16_t map_base_z; - char scenario_name[64]; - char scenario_description[256]; - uint8_t current_interest_rate; + RCT12ResearchItem ResearchItems[Limits::MaxResearchItems]; + uint16_t MapBaseZ; + char ScenarioName[64]; + char ScenarioDescription[256]; + uint8_t CurrentInterestRate; uint8_t Pad0135934B; - uint32_t same_price_throughout_extended; - int16_t park_entrance_x[Limits::MaxParkEntrances]; - int16_t park_entrance_y[Limits::MaxParkEntrances]; - int16_t park_entrance_z[Limits::MaxParkEntrances]; - uint8_t park_entrance_direction[Limits::MaxParkEntrances]; - char scenario_filename[256]; - uint8_t saved_expansion_pack_names[3256]; - RCT12Banner banners[Limits::MaxBanners]; - char custom_strings[Limits::MaxUserStrings][Limits::MaxUserStringLength]; - uint32_t game_ticks_1; - Ride rides[Limits::MaxRidesInPark]; - uint16_t saved_age; - int16_t saved_view_x; - int16_t saved_view_y; - uint8_t saved_view_zoom; - uint8_t saved_view_rotation; - RCT12MapAnimation map_animations[Limits::MaxAnimatedObjects]; - uint16_t num_map_animations; + uint32_t SamePriceThroughoutExtended; + int16_t ParkEntranceX[Limits::MaxParkEntrances]; + int16_t ParkEntranceY[Limits::MaxParkEntrances]; + int16_t ParkEntranceZ[Limits::MaxParkEntrances]; + uint8_t ParkEntranceDirection[Limits::MaxParkEntrances]; + char ScenarioFilename[256]; + uint8_t SavedExpansionPackNames[3256]; + RCT12Banner Banners[Limits::MaxBanners]; + char CustomStrings[Limits::MaxUserStrings][Limits::MaxUserStringLength]; + uint32_t GameTicks1; + Ride Rides[Limits::MaxRidesInPark]; + uint16_t SavedAge; + int16_t SavedViewX; + int16_t SavedViewY; + uint8_t SavedViewZoom; + uint8_t SavedViewRotation; + RCT12MapAnimation MapAnimations[Limits::MaxAnimatedObjects]; + uint16_t NumMapAnimations; uint8_t Pad0138B582[2]; - RideRatingCalculationData ride_ratings_calc_data; + RideRatingCalculationData RideRatingsCalcData; uint8_t Pad0138B5D0[60]; - RCT12RideMeasurement ride_measurements[8]; - uint32_t next_guest_index; - uint16_t grass_and_scenery_tilepos; - uint32_t patrol_areas[(Limits::MaxStaff + Limits::StaffTypeCount) * Limits::PatrolAreaSize]; - StaffMode staff_modes[Limits::MaxStaff + Limits::StaffTypeCount]; + RCT12RideMeasurement RideMeasurements[8]; + uint32_t NextGuestIndex; + uint16_t GrassAndSceneryTilepos; + uint32_t PatrolAreas[(Limits::MaxStaff + Limits::StaffTypeCount) * Limits::PatrolAreaSize]; + StaffMode StaffModes[Limits::MaxStaff + Limits::StaffTypeCount]; uint8_t Pad13CA73E; uint8_t Pad13CA73F; uint8_t Byte13CA740; uint8_t Pad13CA741; uint8_t Byte13CA742[4]; // unused - uint8_t climate; + uint8_t Climate; uint8_t Pad013CA747; - uint16_t climate_update_timer; - uint8_t current_weather; - uint8_t next_weather; - uint8_t temperature; - uint8_t next_temperature; - uint8_t current_weather_effect; - uint8_t next_weather_effect; - uint8_t current_weather_gloom; - uint8_t next_weather_gloom; - uint8_t current_weather_level; - uint8_t next_weather_level; - RCT12NewsItem news_items[Limits::MaxNewsItems]; - char rct1_scenario_name[62]; // Unused in RCT2 - uint16_t rct1_scenario_slot_index; // Unused in RCT2 - uint32_t rct1_scenario_flags; // Unused in RCT2 - uint16_t wide_path_tile_loop_x; - uint16_t wide_path_tile_loop_y; + uint16_t ClimateUpdateTimer; + uint8_t CurrentWeather; + uint8_t NextWeather; + uint8_t Temperature; + uint8_t NextTemperature; + uint8_t CurrentWeatherEffect; + uint8_t NextWeatherEffect; + uint8_t CurrentWeatherGloom; + uint8_t NextWeatherGloom; + uint8_t CurrentWeatherLevel; + uint8_t NextWeatherLevel; + RCT12NewsItem NewsItems[Limits::MaxNewsItems]; + char RCT1ScenarioName[62]; // Unused in RCT2 + uint16_t RCT1ScenarioSlotIndex; // Unused in RCT2 + uint32_t RCT1ScenarioFlags; // Unused in RCT2 + uint16_t WidePathTileLoopX; + uint16_t WidePathTileLoopY; uint8_t Pad13CE778[434]; }; assert_struct_size(S6Data, 0x5a3c4a); struct StexEntry { - StringId scenario_name; // 0x00 - StringId park_name; // 0x02 - StringId details; // 0x04 - uint8_t var_06; + StringId ScenarioName; // 0x00 + StringId ParkName; // 0x02 + StringId Details; // 0x04 + uint8_t Var06; }; assert_struct_size(StexEntry, 7); #pragma pack(pop) diff --git a/src/openrct2/rct2/S6Importer.cpp b/src/openrct2/rct2/S6Importer.cpp index 9dd4a31c84..efeaebf391 100644 --- a/src/openrct2/rct2/S6Importer.cpp +++ b/src/openrct2/rct2/S6Importer.cpp @@ -141,20 +141,20 @@ namespace RCT2 const utf8* path = String::Empty) override { auto chunkReader = SawyerChunkReader(stream); - chunkReader.ReadChunk(&_s6.header, sizeof(_s6.header)); + chunkReader.ReadChunk(&_s6.Header, sizeof(_s6.Header)); - LOG_VERBOSE("saved game classic_flag = 0x%02x", _s6.header.classic_flag); + LOG_VERBOSE("saved game classic_flag = 0x%02x", _s6.Header.ClassicFlag); if (isScenario) { - if (_s6.header.type != S6_TYPE_SCENARIO) + if (_s6.Header.Type != S6_TYPE_SCENARIO) { throw std::runtime_error("Park is not a scenario."); } - chunkReader.ReadChunk(&_s6.info, sizeof(_s6.info)); + chunkReader.ReadChunk(&_s6.Info, sizeof(_s6.Info)); } else { - if (_s6.header.type != S6_TYPE_SAVEDGAME) + if (_s6.Header.Type != S6_TYPE_SAVEDGAME) { throw std::runtime_error("Park is not a saved game."); } @@ -162,7 +162,7 @@ namespace RCT2 // Read packed objects // TODO try to contain this more and not store objects until later - for (uint16_t i = 0; i < _s6.header.num_packed_objects; i++) + for (uint16_t i = 0; i < _s6.Header.NumPackedObjects; i++) { _objectRepository.ExportPackedObject(stream); } @@ -177,21 +177,21 @@ namespace RCT2 if (isScenario) { - chunkReader.ReadChunk(&_s6.elapsed_months, 16); - chunkReader.ReadChunk(&_s6.tile_elements, sizeof(_s6.tile_elements)); + chunkReader.ReadChunk(&_s6.ElapsedMonths, 16); + chunkReader.ReadChunk(&_s6.TileElements, sizeof(_s6.TileElements)); ReadChunk6(chunkReader, 76); - chunkReader.ReadChunk(&_s6.guests_in_park, 4); - chunkReader.ReadChunk(&_s6.last_guests_in_park, 8); - chunkReader.ReadChunk(&_s6.park_rating, 2); - chunkReader.ReadChunk(&_s6.active_research_types, 1082); - chunkReader.ReadChunk(&_s6.current_expenditure, 16); - chunkReader.ReadChunk(&_s6.park_value, 4); - chunkReader.ReadChunk(&_s6.completed_company_value, 483816); + chunkReader.ReadChunk(&_s6.GuestsInPark, 4); + chunkReader.ReadChunk(&_s6.LastGuestsInPark, 8); + chunkReader.ReadChunk(&_s6.ParkRating, 2); + chunkReader.ReadChunk(&_s6.ActiveResearchTypes, 1082); + chunkReader.ReadChunk(&_s6.CurrentExpenditure, 16); + chunkReader.ReadChunk(&_s6.ParkValue, 4); + chunkReader.ReadChunk(&_s6.CompletedCompanyValue, 483816); } else { - chunkReader.ReadChunk(&_s6.elapsed_months, 16); - chunkReader.ReadChunk(&_s6.tile_elements, sizeof(_s6.tile_elements)); + chunkReader.ReadChunk(&_s6.ElapsedMonths, 16); + chunkReader.ReadChunk(&_s6.TileElements, sizeof(_s6.TileElements)); ReadChunk6(chunkReader, 488816); } @@ -209,12 +209,12 @@ namespace RCT2 chunkReader.ReadChunk(buffer.data(), buffer.size()); auto stream = OpenRCT2::MemoryStream(buffer.data(), buffer.size()); - uint32_t preEntitiesSize = sizeof(_s6.next_free_tile_element_pointer_index); + uint32_t preEntitiesSize = sizeof(_s6.NextFreeTileElementPointerIndex); uint32_t postEntitiesSize = sizeWithoutEntities - preEntitiesSize; - stream.Read(&_s6.next_free_tile_element_pointer_index, preEntitiesSize); - stream.Read(&_s6.sprites, entitiesSize); - stream.Read(&_s6.sprite_lists_head, postEntitiesSize); + stream.Read(&_s6.NextFreeTileElementPointerIndex, preEntitiesSize); + stream.Read(&_s6.Entities, entitiesSize); + stream.Read(&_s6.EntityListsHead, postEntitiesSize); } bool GetDetails(scenario_index_entry* dst) override @@ -227,250 +227,248 @@ namespace RCT2 { Initialise(); - gEditorStep = _s6.info.editor_step; - gScenarioCategory = static_cast(_s6.info.category); + gEditorStep = _s6.Info.EditorStep; + gScenarioCategory = static_cast(_s6.Info.Category); // Some scenarios have their scenario details in UTF-8, due to earlier bugs in OpenRCT2. auto loadMaybeUTF8 = [](std::string_view str) -> std::string { return !IsLikelyUTF8(str) ? RCT2StringToUTF8(str, RCT2LanguageId::EnglishUK) : std::string(str); }; - if (_s6.header.type == S6_TYPE_SCENARIO) + if (_s6.Header.Type == S6_TYPE_SCENARIO) { - gScenarioName = loadMaybeUTF8(_s6.info.name); - gScenarioDetails = loadMaybeUTF8(_s6.info.details); + gScenarioName = loadMaybeUTF8(_s6.Info.Name); + gScenarioDetails = loadMaybeUTF8(_s6.Info.Details); } else { // Saved games do not have an info chunk - gScenarioName = loadMaybeUTF8(_s6.scenario_name); - gScenarioDetails = loadMaybeUTF8(_s6.scenario_description); + gScenarioName = loadMaybeUTF8(_s6.ScenarioName); + gScenarioDetails = loadMaybeUTF8(_s6.ScenarioDescription); } - gDateMonthsElapsed = static_cast(_s6.elapsed_months); - gDateMonthTicks = _s6.current_day; - gCurrentTicks = _s6.game_ticks_1; + gDateMonthsElapsed = static_cast(_s6.ElapsedMonths); + gDateMonthTicks = _s6.CurrentDay; + gCurrentTicks = _s6.GameTicks1; - ScenarioRandSeed(_s6.scenario_srand_0, _s6.scenario_srand_1); + ScenarioRandSeed(_s6.ScenarioSrand0, _s6.ScenarioSrand1); DetermineFlatRideStatus(); ImportTileElements(); ImportEntities(); - gInitialCash = ToMoney64(_s6.initial_cash); - gBankLoan = ToMoney64(_s6.current_loan); + gInitialCash = ToMoney64(_s6.InitialCash); + gBankLoan = ToMoney64(_s6.CurrentLoan); - gParkFlags = _s6.park_flags & ~PARK_FLAGS_NO_MONEY_SCENARIO; + gParkFlags = _s6.ParkFlags & ~PARK_FLAGS_NO_MONEY_SCENARIO; // RCT2 used a different flag for `no money` when the park is a scenario - if (_s6.header.type == S6_TYPE_SCENARIO) + if (_s6.Header.Type == S6_TYPE_SCENARIO) { - if (_s6.park_flags & PARK_FLAGS_NO_MONEY_SCENARIO) + if (_s6.ParkFlags & PARK_FLAGS_NO_MONEY_SCENARIO) gParkFlags |= PARK_FLAGS_NO_MONEY; else gParkFlags &= ~PARK_FLAGS_NO_MONEY; } - gParkEntranceFee = _s6.park_entrance_fee; - // rct1_park_entrance_x + gParkEntranceFee = _s6.ParkEntranceFee; + // rct1_park_entranceX // rct1_park_entrance_y // Pad013573EE // rct1_park_entrance_z ImportPeepSpawns(); - gGuestChangeModifier = _s6.guest_count_change_modifier; - gResearchFundingLevel = _s6.current_research_level; + gGuestChangeModifier = _s6.GuestCountChangeModifier; + gResearchFundingLevel = _s6.CurrentResearchLevel; // Pad01357400 - // _s6.researched_track_types_a - // _s6.researched_track_types_b + // _s6.ResearchedTrackTypesA + // _s6.ResearchedTrackTypesB - gNumGuestsInPark = _s6.guests_in_park; - gNumGuestsHeadingForPark = _s6.guests_heading_for_park; + gNumGuestsInPark = _s6.GuestsInPark; + gNumGuestsHeadingForPark = _s6.GuestsHeadingForPark; for (size_t i = 0; i < Limits::ExpenditureTableMonthCount; i++) { for (size_t j = 0; j < Limits::ExpenditureTypeCount; j++) { - gExpenditureTable[i][j] = ToMoney64(_s6.expenditure_table[i][j]); + gExpenditureTable[i][j] = ToMoney64(_s6.ExpenditureTable[i][j]); } } - gNumGuestsInParkLastWeek = _s6.last_guests_in_park; + gNumGuestsInParkLastWeek = _s6.LastGuestsInPark; // Pad01357BCA - gStaffHandymanColour = _s6.handyman_colour; - gStaffMechanicColour = _s6.mechanic_colour; - gStaffSecurityColour = _s6.security_colour; + gStaffHandymanColour = _s6.HandymanColour; + gStaffMechanicColour = _s6.MechanicColour; + gStaffSecurityColour = _s6.SecurityColour; - gParkRating = _s6.park_rating; + gParkRating = _s6.ParkRating; auto& park = OpenRCT2::GetContext()->GetGameState()->GetPark(); park.ResetHistories(); - std::copy(std::begin(_s6.park_rating_history), std::end(_s6.park_rating_history), gParkRatingHistory); - for (size_t i = 0; i < std::size(_s6.guests_in_park_history); i++) + std::copy(std::begin(_s6.ParkRatingHistory), std::end(_s6.ParkRatingHistory), gParkRatingHistory); + for (size_t i = 0; i < std::size(_s6.GuestsInParkHistory); i++) { - if (_s6.guests_in_park_history[i] != RCT12ParkHistoryUndefined) + if (_s6.GuestsInParkHistory[i] != RCT12ParkHistoryUndefined) { - gGuestsInParkHistory[i] = _s6.guests_in_park_history[i] * RCT12GuestsInParkHistoryFactor; + gGuestsInParkHistory[i] = _s6.GuestsInParkHistory[i] * RCT12GuestsInParkHistoryFactor; } } - gResearchPriorities = _s6.active_research_types; - gResearchProgressStage = _s6.research_progress_stage; - if (_s6.last_researched_item_subject != RCT12_RESEARCHED_ITEMS_SEPARATOR) - gResearchLastItem = RCT12ResearchItem{ _s6.last_researched_item_subject, - EnumValue(ResearchCategory::Transport) } + gResearchPriorities = _s6.ActiveResearchTypes; + gResearchProgressStage = _s6.ResearchProgressStage; + if (_s6.LastResearchedItemSubject != RCT12_RESEARCHED_ITEMS_SEPARATOR) + gResearchLastItem = RCT12ResearchItem{ _s6.LastResearchedItemSubject, EnumValue(ResearchCategory::Transport) } .ToResearchItem(); else gResearchLastItem = std::nullopt; // Pad01357CF8 - if (_s6.next_research_item != RCT12_RESEARCHED_ITEMS_SEPARATOR) - gResearchNextItem = RCT12ResearchItem{ _s6.next_research_item, _s6.next_research_category }.ToResearchItem(); + if (_s6.NextResearchItem != RCT12_RESEARCHED_ITEMS_SEPARATOR) + gResearchNextItem = RCT12ResearchItem{ _s6.NextResearchItem, _s6.NextResearchCategory }.ToResearchItem(); else gResearchNextItem = std::nullopt; - gResearchProgress = _s6.research_progress; - gResearchExpectedDay = _s6.next_research_expected_day; - gResearchExpectedMonth = _s6.next_research_expected_month; - gGuestInitialHappiness = _s6.guest_initial_happiness; - gParkSize = _s6.park_size; - _guestGenerationProbability = _s6.guest_generation_probability; - gTotalRideValueForMoney = _s6.total_ride_value_for_money; - gMaxBankLoan = ToMoney64(_s6.maximum_loan); - gGuestInitialCash = _s6.guest_initial_cash; - gGuestInitialHunger = _s6.guest_initial_hunger; - gGuestInitialThirst = _s6.guest_initial_thirst; - gScenarioObjective.Type = _s6.objective_type; - gScenarioObjective.Year = _s6.objective_year; + gResearchProgress = _s6.ResearchProgress; + gResearchExpectedDay = _s6.NextResearchExpectedDay; + gResearchExpectedMonth = _s6.NextResearchExpectedMonth; + gGuestInitialHappiness = _s6.GuestInitialHappiness; + gParkSize = _s6.ParkSize; + _guestGenerationProbability = _s6.GuestGenerationProbability; + gTotalRideValueForMoney = _s6.TotalRideValueForMoney; + gMaxBankLoan = ToMoney64(_s6.MaximumLoan); + gGuestInitialCash = _s6.GuestInitialCash; + gGuestInitialHunger = _s6.GuestInitialHunger; + gGuestInitialThirst = _s6.GuestInitialThirst; + gScenarioObjective.Type = _s6.ObjectiveType; + gScenarioObjective.Year = _s6.ObjectiveYear; // Pad013580FA - gScenarioObjective.Currency = _s6.objective_currency; + gScenarioObjective.Currency = _s6.ObjectiveCurrency; // In RCT2, the ride string IDs start at index STR_0002 and are directly mappable. // This is not always the case in OpenRCT2, so we use the actual ride ID. if (gScenarioObjective.Type == OBJECTIVE_BUILD_THE_BEST) - gScenarioObjective.RideId = _s6.objective_guests - RCT2_RIDE_STRING_START; + gScenarioObjective.RideId = _s6.ObjectiveGuests - RCT2_RIDE_STRING_START; else - gScenarioObjective.NumGuests = _s6.objective_guests; + gScenarioObjective.NumGuests = _s6.ObjectiveGuests; ImportMarketingCampaigns(); - gCurrentExpenditure = ToMoney64(_s6.current_expenditure); - gCurrentProfit = ToMoney64(_s6.current_profit); - gWeeklyProfitAverageDividend = ToMoney64(_s6.weekly_profit_average_dividend); - gWeeklyProfitAverageDivisor = _s6.weekly_profit_average_divisor; + gCurrentExpenditure = ToMoney64(_s6.CurrentExpenditure); + gCurrentProfit = ToMoney64(_s6.CurrentProfit); + gWeeklyProfitAverageDividend = ToMoney64(_s6.WeeklyProfitAverageDividend); + gWeeklyProfitAverageDivisor = _s6.WeeklyProfitAverageDivisor; // Pad0135833A - gParkValue = ToMoney64(_s6.park_value); + gParkValue = ToMoney64(_s6.ParkValue); for (size_t i = 0; i < Limits::FinanceGraphSize; i++) { - gCashHistory[i] = ToMoney64(_s6.balance_history[i]); - gWeeklyProfitHistory[i] = ToMoney64(_s6.weekly_profit_history[i]); - gParkValueHistory[i] = ToMoney64(_s6.park_value_history[i]); + gCashHistory[i] = ToMoney64(_s6.BalanceHistory[i]); + gWeeklyProfitHistory[i] = ToMoney64(_s6.WeeklyProfitHistory[i]); + gParkValueHistory[i] = ToMoney64(_s6.ParkValueHistory[i]); } - gScenarioCompletedCompanyValue = RCT12CompletedCompanyValueToOpenRCT2(_s6.completed_company_value); - gTotalAdmissions = _s6.total_admissions; - gTotalIncomeFromAdmissions = ToMoney64(_s6.income_from_admissions); - gCompanyValue = ToMoney64(_s6.company_value); - std::memcpy(gPeepWarningThrottle, _s6.peep_warning_throttle, sizeof(_s6.peep_warning_throttle)); + gScenarioCompletedCompanyValue = RCT12CompletedCompanyValueToOpenRCT2(_s6.CompletedCompanyValue); + gTotalAdmissions = _s6.TotalAdmissions; + gTotalIncomeFromAdmissions = ToMoney64(_s6.IncomeFromAdmissions); + gCompanyValue = ToMoney64(_s6.CompanyValue); + std::memcpy(gPeepWarningThrottle, _s6.PeepWarningThrottle, sizeof(_s6.PeepWarningThrottle)); // Awards auto& awards = GetAwards(); - for (auto& src : _s6.awards) + for (auto& src : _s6.Awards) { - if (src.time != 0) + if (src.Time != 0) { - awards.push_back(Award{ src.time, static_cast(src.type) }); + awards.push_back(Award{ src.Time, static_cast(src.Type) }); } } - gLandPrice = _s6.land_price; - gConstructionRightsPrice = _s6.construction_rights_price; + gLandPrice = _s6.LandPrice; + gConstructionRightsPrice = _s6.ConstructionRightsPrice; // unk_01358774 // Pad01358776 - // _s6.cd_key - _gameVersion = _s6.game_version_number; - gScenarioCompanyValueRecord = _s6.completed_company_value_record; - // _s6.loan_hash; + // _s6.CdKey + _gameVersion = _s6.GameVersionNumber; + gScenarioCompanyValueRecord = _s6.CompletedCompanyValueRecord; + // _s6.LoanHash; // Pad013587CA - gHistoricalProfit = ToMoney64(_s6.historical_profit); + gHistoricalProfit = ToMoney64(_s6.HistoricalProfit); // Pad013587D4 - gScenarioCompletedBy = std::string_view(_s6.scenario_completed_name, sizeof(_s6.scenario_completed_name)); - gCash = ToMoney64(DECRYPT_MONEY(_s6.cash)); + gScenarioCompletedBy = std::string_view(_s6.ScenarioCompletedName, sizeof(_s6.ScenarioCompletedName)); + gCash = ToMoney64(DECRYPT_MONEY(_s6.Cash)); // Pad013587FC - gParkRatingCasualtyPenalty = _s6.park_rating_casualty_penalty; - gMapSize = { _s6.map_size, _s6.map_size }; - gSamePriceThroughoutPark = _s6.same_price_throughout - | (static_cast(_s6.same_price_throughout_extended) << 32); - _suggestedGuestMaximum = _s6.suggested_max_guests; - gScenarioParkRatingWarningDays = _s6.park_rating_warning_days; - gLastEntranceStyle = _s6.last_entrance_style; + gParkRatingCasualtyPenalty = _s6.ParkRatingCasualtyPenalty; + gMapSize = { _s6.MapSize, _s6.MapSize }; + gSamePriceThroughoutPark = _s6.SamePriceThroughout | (static_cast(_s6.SamePriceThroughoutExtended) << 32); + _suggestedGuestMaximum = _s6.SuggestedMaxGuests; + gScenarioParkRatingWarningDays = _s6.ParkRatingWarningDays; + gLastEntranceStyle = _s6.LastEntranceStyle; // rct1_water_colour // Pad01358842 ImportResearchList(); - gMapBaseZ = _s6.map_base_z; - gBankLoanInterestRate = _s6.current_interest_rate; + gMapBaseZ = _s6.MapBaseZ; + gBankLoanInterestRate = _s6.CurrentInterestRate; // Pad0135934B // Preserve compatibility with vanilla RCT2's save format. gParkEntrances.clear(); for (uint8_t i = 0; i < Limits::MaxParkEntrances; i++) { - if (_s6.park_entrance_x[i] != LOCATION_NULL) + if (_s6.ParkEntranceX[i] != LOCATION_NULL) { CoordsXYZD entrance; - entrance.x = _s6.park_entrance_x[i]; - entrance.y = _s6.park_entrance_y[i]; - entrance.z = _s6.park_entrance_z[i]; - entrance.direction = _s6.park_entrance_direction[i]; + entrance.x = _s6.ParkEntranceX[i]; + entrance.y = _s6.ParkEntranceY[i]; + entrance.z = _s6.ParkEntranceZ[i]; + entrance.direction = _s6.ParkEntranceDirection[i]; gParkEntrances.push_back(entrance); } } - if (_s6.header.type == S6_TYPE_SCENARIO) + if (_s6.Header.Type == S6_TYPE_SCENARIO) { - // _s6.scenario_filename is wrong for some RCT2 expansion scenarios, so we use the real filename + // _s6.ScenarioFilename is wrong for some RCT2 expansion scenarios, so we use the real filename gScenarioFileName = Path::GetFileName(_s6Path); } else { // For savegames the filename can be arbitrary, so we have no choice but to rely on the name provided - gScenarioFileName = std::string(String::ToStringView(_s6.scenario_filename, std::size(_s6.scenario_filename))); + gScenarioFileName = std::string(String::ToStringView(_s6.ScenarioFilename, std::size(_s6.ScenarioFilename))); } gCurrentRealTimeTicks = 0; ImportRides(); - gSavedAge = _s6.saved_age; - gSavedView = ScreenCoordsXY{ _s6.saved_view_x, _s6.saved_view_y }; - gSavedViewZoom = ZoomLevel{ static_cast(_s6.saved_view_zoom) }; - gSavedViewRotation = _s6.saved_view_rotation; + gSavedAge = _s6.SavedAge; + gSavedView = ScreenCoordsXY{ _s6.SavedViewX, _s6.SavedViewY }; + gSavedViewZoom = ZoomLevel{ static_cast(_s6.SavedViewZoom) }; + gSavedViewRotation = _s6.SavedViewRotation; ImportRideRatingsCalcData(); ImportRideMeasurements(); - gNextGuestNumber = _s6.next_guest_index; - gGrassSceneryTileLoopPosition = _s6.grass_and_scenery_tilepos; + gNextGuestNumber = _s6.NextGuestIndex; + gGrassSceneryTileLoopPosition = _s6.GrassAndSceneryTilepos; // unk_13CA73E // Pad13CA73F // unk_13CA740 - gClimate = ClimateType{ _s6.climate }; + gClimate = ClimateType{ _s6.Climate }; // Pad13CA741; // Byte13CA742 // Pad013CA747 - gClimateUpdateTimer = _s6.climate_update_timer; - gClimateCurrent.Weather = WeatherType{ _s6.current_weather }; - gClimateNext.Weather = WeatherType{ _s6.next_weather }; - gClimateCurrent.Temperature = _s6.temperature; - gClimateNext.Temperature = _s6.next_temperature; - gClimateCurrent.WeatherEffect = WeatherEffectType{ _s6.current_weather_effect }; - gClimateNext.WeatherEffect = WeatherEffectType{ _s6.next_weather_effect }; - gClimateCurrent.WeatherGloom = _s6.current_weather_gloom; - gClimateNext.WeatherGloom = _s6.next_weather_gloom; - gClimateCurrent.Level = static_cast(_s6.current_weather_level); - gClimateNext.Level = static_cast(_s6.next_weather_level); + gClimateUpdateTimer = _s6.ClimateUpdateTimer; + gClimateCurrent.Weather = WeatherType{ _s6.CurrentWeather }; + gClimateNext.Weather = WeatherType{ _s6.NextWeather }; + gClimateCurrent.Temperature = _s6.Temperature; + gClimateNext.Temperature = _s6.NextTemperature; + gClimateCurrent.WeatherEffect = WeatherEffectType{ _s6.CurrentWeatherEffect }; + gClimateNext.WeatherEffect = WeatherEffectType{ _s6.NextWeatherEffect }; + gClimateCurrent.WeatherGloom = _s6.CurrentWeatherGloom; + gClimateNext.WeatherGloom = _s6.NextWeatherGloom; + gClimateCurrent.Level = static_cast(_s6.CurrentWeatherLevel); + gClimateNext.Level = static_cast(_s6.NextWeatherLevel); // News items News::InitQueue(); for (size_t i = 0; i < Limits::MaxNewsItems; i++) { - const RCT12NewsItem* src = &_s6.news_items[i]; + const RCT12NewsItem* src = &_s6.NewsItems[i]; News::Item* dst = &gNewsItems[i]; if (src->Type < News::ItemTypeCount) { @@ -494,8 +492,8 @@ namespace RCT2 // Pad13CE730 // rct1_scenario_flags - gWidePathTileLoopPosition.x = _s6.wide_path_tile_loop_x; - gWidePathTileLoopPosition.y = _s6.wide_path_tile_loop_y; + gWidePathTileLoopPosition.x = _s6.WidePathTileLoopX; + gWidePathTileLoopPosition.y = _s6.WidePathTileLoopY; // Pad13CE778 // Fix and set dynamic variables @@ -503,7 +501,7 @@ namespace RCT2 ConvertScenarioStringsToUTF8(); DetermineRideEntranceAndExitLocations(); - park.Name = GetUserString(_s6.park_name); + park.Name = GetUserString(_s6.ParkName); FixLandOwnership(); FixAyersRockScenario(); @@ -534,10 +532,10 @@ namespace RCT2 void FixLandOwnership() const { - // Checking _s6.scenario_filename is generally more reliable as it survives renaming. + // Checking _s6.ScenarioFilename is generally more reliable as it survives renaming. // However, some WW/TT scenarios have this incorrectly set to "Six Flags Magic Mountain.SC6", // so for those cases (as well as for SFMM proper, we’ll have to check the filename. - if (String::Equals(_s6.scenario_filename, "Europe - European Cultural Festival.SC6")) + if (String::Equals(_s6.ScenarioFilename, "Europe - European Cultural Festival.SC6")) { // This scenario breaks pathfinding. Create passages between the worlds. (List is grouped by neighbouring // tiles.) @@ -552,7 +550,7 @@ namespace RCT2 OWNERSHIP_OWNED); // clang-format on } - else if (String::Equals(_s6.scenario_filename, "Six Flags Holland.SC6")) + else if (String::Equals(_s6.ScenarioFilename, "Six Flags Holland.SC6")) { // clang-format off FixLandOwnershipTilesWithOwnership( @@ -563,7 +561,7 @@ namespace RCT2 OWNERSHIP_AVAILABLE, true); // clang-format on } - else if (String::Equals(_s6.scenario_filename, "North America - Grand Canyon.SC6")) + else if (String::Equals(_s6.ScenarioFilename, "North America - Grand Canyon.SC6")) { // clang-format off FixLandOwnershipTilesWithOwnership( @@ -602,7 +600,7 @@ namespace RCT2 OWNERSHIP_AVAILABLE, true); // clang-format on } - else if (String::Equals(_s6.scenario_filename, "Great Wall of China Tourism Enhancement.SC6")) + else if (String::Equals(_s6.ScenarioFilename, "Great Wall of China Tourism Enhancement.SC6")) { FixLandOwnershipTilesWithOwnership( { @@ -643,7 +641,7 @@ namespace RCT2 void FixAyersRockScenario() const { - if (!_isScenario || !String::Equals(_s6.scenario_filename, "Australasia - Ayers Rock.SC6")) + if (!_isScenario || !String::Equals(_s6.ScenarioFilename, "Australasia - Ayers Rock.SC6")) return; TileCoordsXY tilesToUncovered[] = { @@ -699,8 +697,8 @@ namespace RCT2 { for (uint8_t index = 0; index < Limits::MaxRidesInPark; index++) { - auto src = &_s6.rides[index]; - if (src->type != RIDE_TYPE_NULL) + auto src = &_s6.Rides[index]; + if (src->Type != RIDE_TYPE_NULL) { const auto rideId = RideId::FromUnderlying(index); auto dst = GetOrAllocateRide(rideId); @@ -725,14 +723,14 @@ namespace RCT2 { for (uint8_t index = 0; index < Limits::MaxRidesInPark; index++) { - auto src = &_s6.rides[index]; - if (src->type == RIDE_TYPE_NULL) + auto src = &_s6.Rides[index]; + if (src->Type == RIDE_TYPE_NULL) continue; - auto subtype = RCTEntryIndexToOpenRCT2EntryIndex(src->subtype); + auto subtype = RCTEntryIndexToOpenRCT2EntryIndex(src->Subtype); auto* rideEntry = GetRideEntryByIndex(subtype); // If the ride is tracked, we don’t need to check the vehicle any more. - if (!GetRideTypeDescriptor(src->type).HasFlag(RIDE_TYPE_FLAG_FLAT_RIDE)) + if (!GetRideTypeDescriptor(src->Type).HasFlag(RIDE_TYPE_FLAG_FLAT_RIDE)) { _isFlatRide[index] = false; continue; @@ -740,7 +738,7 @@ namespace RCT2 // We have established the ride type is a flat ride, which means the vehicle now determines whether it is a // true flat ride (scenario 4) or a tracked ride with an invisibility hack (scenario 2). - ObjectEntryIndex originalRideType = src->type; + ObjectEntryIndex originalRideType = src->Type; if (rideEntry != nullptr) { originalRideType = rideEntry->GetFirstNonNullRideType(); @@ -762,14 +760,14 @@ namespace RCT2 *dst = {}; dst->id = rideIndex; - ObjectEntryIndex rideType = src->type; - auto subtype = RCTEntryIndexToOpenRCT2EntryIndex(src->subtype); - if (RCT2RideTypeNeedsConversion(src->type)) + ObjectEntryIndex rideType = src->Type; + auto subtype = RCTEntryIndexToOpenRCT2EntryIndex(src->Subtype); + if (RCT2RideTypeNeedsConversion(src->Type)) { auto* rideEntry = GetRideEntryByIndex(subtype); if (rideEntry != nullptr) { - rideType = RCT2RideTypeToOpenRCT2RideType(src->type, *rideEntry); + rideType = RCT2RideTypeToOpenRCT2RideType(src->Type, *rideEntry); } } @@ -781,35 +779,35 @@ namespace RCT2 dst->type = rideType; dst->subtype = subtype; // Pad002; - dst->mode = static_cast(src->mode); - dst->colour_scheme_type = src->colour_scheme_type; + dst->mode = static_cast(src->Mode); + dst->colour_scheme_type = src->ColourSchemeType; for (uint8_t i = 0; i < Limits::MaxTrainsPerRide; i++) { - dst->vehicle_colours[i].Body = src->vehicle_colours[i].body_colour; - dst->vehicle_colours[i].Trim = src->vehicle_colours[i].trim_colour; + dst->vehicle_colours[i].Body = src->VehicleColours[i].BodyColour; + dst->vehicle_colours[i].Trim = src->VehicleColours[i].TrimColour; } // Pad046; - dst->status = static_cast(src->status); + dst->status = static_cast(src->Status); - dst->default_name_number = src->name_arguments_number; - if (IsUserStringID(src->name)) + dst->default_name_number = src->NameArgumentsNumber; + if (IsUserStringID(src->Name)) { - dst->custom_name = GetUserString(src->name); + dst->custom_name = GetUserString(src->Name); } else { - dst->default_name_number = src->name_arguments_number; + dst->default_name_number = src->NameArgumentsNumber; } - if (src->overall_view.IsNull()) + if (src->OverallView.IsNull()) { dst->overall_view.SetNull(); } else { - auto tileLoc = TileCoordsXY(src->overall_view.x, src->overall_view.y); + auto tileLoc = TileCoordsXY(src->OverallView.x, src->OverallView.y); dst->overall_view = tileLoc.ToCoordsXY(); } @@ -818,39 +816,39 @@ namespace RCT2 StationIndex stationIndex = StationIndex::FromUnderlying(i); auto& destStation = dst->GetStation(stationIndex); - if (src->station_starts[i].IsNull()) + if (src->StationStarts[i].IsNull()) { destStation.Start.SetNull(); } else { - auto tileStartLoc = TileCoordsXY(src->station_starts[i].x, src->station_starts[i].y); + auto tileStartLoc = TileCoordsXY(src->StationStarts[i].x, src->StationStarts[i].y); destStation.Start = tileStartLoc.ToCoordsXY(); } - destStation.Height = src->station_heights[i]; - destStation.Length = src->station_length[i]; - destStation.Depart = src->station_depart[i]; - destStation.TrainAtStation = src->train_at_station[i]; + destStation.Height = src->StationHeights[i]; + destStation.Length = src->StationLength[i]; + destStation.Depart = src->StationDepart[i]; + destStation.TrainAtStation = src->TrainAtStation[i]; // Direction is fixed later. - if (src->entrances[i].IsNull()) + if (src->Entrances[i].IsNull()) destStation.Entrance.SetNull(); else - destStation.Entrance = { src->entrances[i].x, src->entrances[i].y, src->station_heights[i], 0 }; + destStation.Entrance = { src->Entrances[i].x, src->Entrances[i].y, src->StationHeights[i], 0 }; - if (src->exits[i].IsNull()) + if (src->Exits[i].IsNull()) destStation.Exit.SetNull(); else - destStation.Exit = { src->exits[i].x, src->exits[i].y, src->station_heights[i], 0 }; + destStation.Exit = { src->Exits[i].x, src->Exits[i].y, src->StationHeights[i], 0 }; - destStation.LastPeepInQueue = EntityId::FromUnderlying(src->last_peep_in_queue[i]); + destStation.LastPeepInQueue = EntityId::FromUnderlying(src->LastPeepInQueue[i]); - destStation.SegmentLength = src->length[i]; - destStation.SegmentTime = src->time[i]; + destStation.SegmentLength = src->Length[i]; + destStation.SegmentTime = src->Time[i]; - destStation.QueueTime = src->queue_time[i]; + destStation.QueueTime = src->QueueTime[i]; - destStation.QueueLength = src->queue_length[i]; + destStation.QueueLength = src->QueueLength[i]; } // All other values take 0 as their default. Since they're already memset to that, no need to do it again. for (int32_t i = Limits::MaxStationsPerRide; i < OpenRCT2::Limits::MaxStationsPerRide; i++) @@ -867,162 +865,161 @@ namespace RCT2 for (int32_t i = 0; i < Limits::MaxTrainsPerRide; i++) { - dst->vehicles[i] = EntityId::FromUnderlying(src->vehicles[i]); + dst->vehicles[i] = EntityId::FromUnderlying(src->Vehicles[i]); } for (int32_t i = Limits::MaxTrainsPerRide - 1; i <= OpenRCT2::Limits::MaxTrainsPerRide; i++) { dst->vehicles[i] = EntityId::GetNull(); } - dst->depart_flags = src->depart_flags; + dst->depart_flags = src->DepartFlags; - dst->num_stations = src->num_stations; + dst->num_stations = src->NumStations; dst->NumTrains = src->NumTrains; - dst->num_cars_per_train = src->num_cars_per_train; + dst->num_cars_per_train = src->NumCarsPerTrain; dst->ProposedNumTrains = src->ProposedNumTrains; - dst->proposed_num_cars_per_train = src->proposed_num_cars_per_train; - dst->max_trains = src->max_trains; + dst->proposed_num_cars_per_train = src->ProposedNumCarsPerTrain; + dst->max_trains = src->MaxTrains; dst->MinCarsPerTrain = src->GetMinCarsPerTrain(); dst->MaxCarsPerTrain = src->GetMaxCarsPerTrain(); - dst->min_waiting_time = src->min_waiting_time; - dst->max_waiting_time = src->max_waiting_time; + dst->min_waiting_time = src->MinWaitingTime; + dst->max_waiting_time = src->MaxWaitingTime; // Includes time_limit, NumLaps, launch_speed, speed, rotations - dst->operation_option = src->operation_option; + dst->operation_option = src->OperationOption; - dst->boat_hire_return_direction = src->boat_hire_return_direction; - dst->boat_hire_return_position = { src->boat_hire_return_position.x, src->boat_hire_return_position.y }; + dst->boat_hire_return_direction = src->BoatHireReturnDirection; + dst->boat_hire_return_position = { src->BoatHireReturnPosition.x, src->BoatHireReturnPosition.y }; - dst->special_track_elements = src->special_track_elements; + dst->special_track_elements = src->SpecialTrackElements; // Pad0D6[2]; - dst->max_speed = src->max_speed; - dst->average_speed = src->average_speed; - dst->current_test_segment = src->current_test_segment; - dst->average_speed_test_timeout = src->average_speed_test_timeout; + dst->max_speed = src->MaxSpeed; + dst->average_speed = src->AverageSpeed; + dst->current_test_segment = src->CurrentTestSegment; + dst->average_speed_test_timeout = src->AverageSpeedTestTimeout; // Pad0E2[0x2]; - dst->max_positive_vertical_g = src->max_positive_vertical_g; - dst->max_negative_vertical_g = src->max_negative_vertical_g; - dst->max_lateral_g = src->max_lateral_g; - dst->previous_vertical_g = src->previous_vertical_g; - dst->previous_lateral_g = src->previous_lateral_g; + dst->max_positive_vertical_g = src->MaxPositiveVerticalG; + dst->max_negative_vertical_g = src->MaxNegativeVerticalG; + dst->max_lateral_g = src->MaxLateralG; + dst->previous_vertical_g = src->PreviousVerticalG; + dst->previous_lateral_g = src->PreviousLateralG; // Pad106[0x2]; - dst->testing_flags = src->testing_flags; + dst->testing_flags = src->TestingFlags; - if (src->cur_test_track_location.IsNull()) + if (src->CurTestTrackLocation.IsNull()) { dst->CurTestTrackLocation.SetNull(); } else { - dst->CurTestTrackLocation = { src->cur_test_track_location.x, src->cur_test_track_location.y, - src->cur_test_track_z }; + dst->CurTestTrackLocation = { src->CurTestTrackLocation.x, src->CurTestTrackLocation.y, src->CurTestTrackZ }; } - dst->turn_count_default = src->turn_count_default; - dst->turn_count_banked = src->turn_count_banked; - dst->turn_count_sloped = src->turn_count_sloped; + dst->turn_count_default = src->TurnCountDefault; + dst->turn_count_banked = src->TurnCountBanked; + dst->turn_count_sloped = src->TurnCountSloped; if (dst->type == RIDE_TYPE_MINI_GOLF) - dst->holes = src->inversions & 0x1F; + dst->holes = src->Inversions & 0x1F; else - dst->inversions = src->inversions & 0x1F; - dst->sheltered_eighths = src->inversions >> 5; - dst->drops = src->drops; - dst->start_drop_height = src->start_drop_height; - dst->highest_drop_height = src->highest_drop_height; - dst->sheltered_length = src->sheltered_length; - dst->var_11C = src->var_11C; - dst->num_sheltered_sections = src->num_sheltered_sections; + dst->inversions = src->Inversions & 0x1F; + dst->sheltered_eighths = src->Inversions >> 5; + dst->drops = src->Drops; + dst->start_drop_height = src->StartDropHeight; + dst->highest_drop_height = src->HighestDropHeight; + dst->sheltered_length = src->ShelteredLength; + dst->var_11C = src->Var11C; + dst->num_sheltered_sections = src->NumShelteredSections; - dst->cur_num_customers = src->cur_num_customers; - dst->num_customers_timeout = src->num_customers_timeout; + dst->cur_num_customers = src->CurNumCustomers; + dst->num_customers_timeout = src->NumCustomersTimeout; for (uint8_t i = 0; i < Limits::CustomerHistorySize; i++) { - dst->num_customers[i] = src->num_customers[i]; + dst->num_customers[i] = src->NumCustomers[i]; } - dst->price[0] = src->price; + dst->price[0] = src->Price; for (uint8_t i = 0; i < 2; i++) { - dst->ChairliftBullwheelLocation[i] = { src->chairlift_bullwheel_location[i].x, - src->chairlift_bullwheel_location[i].y, src->chairlift_bullwheel_z[i] }; + dst->ChairliftBullwheelLocation[i] = { src->ChairliftBullwheelLocation[i].x, + src->ChairliftBullwheelLocation[i].y, src->ChairliftBullwheelZ[i] }; } - dst->ratings = src->ratings; - dst->value = src->value; + dst->ratings = src->Ratings; + dst->value = src->Value; - dst->chairlift_bullwheel_rotation = src->chairlift_bullwheel_rotation; + dst->chairlift_bullwheel_rotation = src->ChairliftBullwheelRotation; - dst->satisfaction = src->satisfaction; - dst->satisfaction_time_out = src->satisfaction_time_out; - dst->satisfaction_next = src->satisfaction_next; + dst->satisfaction = src->Satisfaction; + dst->satisfaction_time_out = src->SatisfactionTimeOut; + dst->satisfaction_next = src->SatisfactionNext; - dst->window_invalidate_flags = src->window_invalidate_flags; + dst->window_invalidate_flags = src->WindowInvalidateFlags; // Pad14E[0x02]; - dst->total_customers = src->total_customers; - dst->total_profit = ToMoney64(src->total_profit); - dst->popularity = src->popularity; - dst->popularity_time_out = src->popularity_time_out; - dst->popularity_next = src->popularity_next; + dst->total_customers = src->TotalCustomers; + dst->total_profit = ToMoney64(src->TotalProfit); + dst->popularity = src->Popularity; + dst->popularity_time_out = src->PopularityTimeOut; + dst->popularity_next = src->PopularityNext; ImportNumRiders(dst, rideIndex); - dst->music_tune_id = src->music_tune_id; - dst->slide_in_use = src->slide_in_use; + dst->music_tune_id = src->MusicTuneId; + dst->slide_in_use = src->SlideInUse; // Includes maze_tiles - dst->slide_peep = EntityId::FromUnderlying(src->slide_peep); + dst->slide_peep = EntityId::FromUnderlying(src->SlidePeep); // Pad160[0xE]; - dst->slide_peep_t_shirt_colour = src->slide_peep_t_shirt_colour; + dst->slide_peep_t_shirt_colour = src->SlidePeepTShirtColour; // Pad16F[0x7]; - dst->spiral_slide_progress = src->spiral_slide_progress; + dst->spiral_slide_progress = src->SpiralSlideProgress; // Pad177[0x9]; - dst->build_date = static_cast(src->build_date); - dst->upkeep_cost = src->upkeep_cost; - dst->race_winner = EntityId::FromUnderlying(src->race_winner); + dst->build_date = static_cast(src->BuildDate); + dst->upkeep_cost = src->UpkeepCost; + dst->race_winner = EntityId::FromUnderlying(src->RaceWinner); // Pad186[0x02]; - dst->music_position = src->music_position; + dst->music_position = src->MusicPosition; - dst->breakdown_reason_pending = src->breakdown_reason_pending; - dst->mechanic_status = src->mechanic_status; - dst->mechanic = EntityId::FromUnderlying(src->mechanic); - dst->inspection_station = StationIndex::FromUnderlying(src->inspection_station); - dst->broken_vehicle = src->broken_vehicle; - dst->broken_car = src->broken_car; - dst->breakdown_reason = src->breakdown_reason; + dst->breakdown_reason_pending = src->BreakdownReasonPending; + dst->mechanic_status = src->MechanicStatus; + dst->mechanic = EntityId::FromUnderlying(src->Mechanic); + dst->inspection_station = StationIndex::FromUnderlying(src->InspectionStation); + dst->broken_vehicle = src->BrokenVehicle; + dst->broken_car = src->BrokenCar; + dst->breakdown_reason = src->BreakdownReason; - dst->price[1] = src->price_secondary; + dst->price[1] = src->PriceSecondary; - dst->reliability = src->reliability; - dst->unreliability_factor = src->unreliability_factor; - dst->downtime = src->downtime; - dst->inspection_interval = src->inspection_interval; - dst->last_inspection = src->last_inspection; + dst->reliability = src->Reliability; + dst->unreliability_factor = src->UnreliabilityFactor; + dst->downtime = src->Downtime; + dst->inspection_interval = src->InspectionInterval; + dst->last_inspection = src->LastInspection; for (uint8_t i = 0; i < Limits::DowntimeHistorySize; i++) { - dst->downtime_history[i] = src->downtime_history[i]; + dst->downtime_history[i] = src->DowntimeHistory[i]; } - dst->no_primary_items_sold = src->no_primary_items_sold; - dst->no_secondary_items_sold = src->no_secondary_items_sold; + dst->no_primary_items_sold = src->NoPrimaryItemsSold; + dst->no_secondary_items_sold = src->NoSecondaryItemsSold; - dst->breakdown_sound_modifier = src->breakdown_sound_modifier; - dst->not_fixed_timeout = src->not_fixed_timeout; - dst->last_crash_type = src->last_crash_type; - dst->connected_message_throttle = src->connected_message_throttle; + dst->breakdown_sound_modifier = src->BreakdownSoundModifier; + dst->not_fixed_timeout = src->NotFixedTimeout; + dst->last_crash_type = src->LastCrashType; + dst->connected_message_throttle = src->ConnectedMessageThrottle; - dst->income_per_hour = ToMoney64(src->income_per_hour); - dst->profit = ToMoney64(src->profit); + dst->income_per_hour = ToMoney64(src->IncomePerHour); + dst->profit = ToMoney64(src->Profit); for (uint8_t i = 0; i < Limits::NumColourSchemes; i++) { - dst->track_colour[i].main = src->track_colour_main[i]; - dst->track_colour[i].additional = src->track_colour_additional[i]; - dst->track_colour[i].supports = src->track_colour_supports[i]; + dst->track_colour[i].main = src->TrackColourMain[i]; + dst->track_colour[i].additional = src->TrackColourAdditional[i]; + dst->track_colour[i].supports = src->TrackColourSupports[i]; } // This stall was not colourable in RCT2. if (dst->type == RIDE_TYPE_FOOD_STALL) @@ -1037,7 +1034,7 @@ namespace RCT2 auto musicStyle = OBJECT_ENTRY_INDEX_NULL; if (GetRideTypeDescriptor(dst->type).HasFlag(RIDE_TYPE_FLAG_ALLOW_MUSIC)) { - musicStyle = src->music; + musicStyle = src->Music; } dst->music = musicStyle; @@ -1045,63 +1042,63 @@ namespace RCT2 auto entranceStyle = OBJECT_ENTRY_INDEX_NULL; if (!_isSV7 && GetRideTypeDescriptor(dst->type).HasFlag(RIDE_TYPE_FLAG_HAS_ENTRANCE_EXIT)) { - entranceStyle = src->entrance_style; + entranceStyle = src->EntranceStyle; } dst->entrance_style = entranceStyle; - dst->vehicle_change_timeout = src->vehicle_change_timeout; - dst->num_block_brakes = src->num_block_brakes; - dst->lift_hill_speed = src->lift_hill_speed; - dst->guests_favourite = src->guests_favourite; - dst->lifecycle_flags = src->lifecycle_flags; + dst->vehicle_change_timeout = src->VehicleChangeTimeout; + dst->num_block_brakes = src->NumBlockBrakes; + dst->lift_hill_speed = src->LiftHillSpeed; + dst->guests_favourite = src->GuestsFavourite; + dst->lifecycle_flags = src->LifecycleFlags; for (uint8_t i = 0; i < Limits::MaxTrainsPerRide; i++) { - dst->vehicle_colours[i].Tertiary = src->vehicle_colours_extended[i]; + dst->vehicle_colours[i].Tertiary = src->VehicleColoursExtended[i]; } - dst->total_air_time = src->total_air_time; - dst->current_test_station = StationIndex::FromUnderlying(src->current_test_station); - dst->num_circuits = src->num_circuits; - dst->CableLiftLoc = { src->cable_lift_x, src->cable_lift_y, src->cable_lift_z * COORDS_Z_STEP }; + dst->total_air_time = src->TotalAirTime; + dst->current_test_station = StationIndex::FromUnderlying(src->CurrentTestStation); + dst->num_circuits = src->NumCircuits; + dst->CableLiftLoc = { src->CableLiftX, src->CableLiftY, src->CableLiftZ * COORDS_Z_STEP }; // Pad1FD; - dst->cable_lift = EntityId::FromUnderlying(src->cable_lift); + dst->cable_lift = EntityId::FromUnderlying(src->CableLift); // Pad208[0x58]; } void ImportRideRatingsCalcData() { - const auto& src = _s6.ride_ratings_calc_data; + const auto& src = _s6.RideRatingsCalcData; auto& dst = gRideRatingUpdateState; dst = {}; - dst.Proximity = { src.proximity_x, src.proximity_y, src.proximity_z }; - dst.ProximityStart = { src.proximity_start_x, src.proximity_start_y, src.proximity_start_z }; - dst.CurrentRide = RCT12RideIdToOpenRCT2RideId(src.current_ride); - dst.State = src.state; - if (src.current_ride < Limits::MaxRidesInPark && _s6.rides[src.current_ride].type < std::size(RideTypeDescriptors)) + dst.Proximity = { src.ProximityX, src.ProximityY, src.ProximityZ }; + dst.ProximityStart = { src.ProximityStartX, src.ProximityStartY, src.ProximityStartZ }; + dst.CurrentRide = RCT12RideIdToOpenRCT2RideId(src.CurrentRide); + dst.State = src.State; + if (src.CurrentRide < Limits::MaxRidesInPark && _s6.Rides[src.CurrentRide].Type < std::size(RideTypeDescriptors)) dst.ProximityTrackType = RCT2TrackTypeToOpenRCT2( - src.proximity_track_type, _s6.rides[src.current_ride].type, IsFlatRide(src.current_ride)); + src.ProximityTrackType, _s6.Rides[src.CurrentRide].Type, IsFlatRide(src.CurrentRide)); else dst.ProximityTrackType = 0xFF; - dst.ProximityBaseHeight = src.proximity_BaseHeight; - dst.ProximityTotal = src.proximity_total; - for (size_t i = 0; i < std::size(src.proximity_scores); i++) + dst.ProximityBaseHeight = src.ProximityBaseHeight; + dst.ProximityTotal = src.ProximityTotal; + for (size_t i = 0; i < std::size(src.ProximityScores); i++) { - dst.ProximityScores[i] = src.proximity_scores[i]; + dst.ProximityScores[i] = src.ProximityScores[i]; } - dst.AmountOfBrakes = src.num_brakes; - dst.AmountOfReversers = src.num_reversers; - dst.StationFlags = src.station_flags; + dst.AmountOfBrakes = src.NumBrakes; + dst.AmountOfReversers = src.NumReversers; + dst.StationFlags = src.StationFlags; } void ImportRideMeasurements() { - for (const auto& src : _s6.ride_measurements) + for (const auto& src : _s6.RideMeasurements) { - if (src.ride_index != RCT12_RIDE_ID_NULL) + if (src.RideIndex != RCT12_RIDE_ID_NULL) { - const auto rideId = RideId::FromUnderlying(src.ride_index); + const auto rideId = RideId::FromUnderlying(src.RideIndex); auto ride = GetRide(rideId); if (ride != nullptr) { @@ -1114,25 +1111,25 @@ namespace RCT2 void ImportRideMeasurement(RideMeasurement& dst, const RCT12RideMeasurement& src) { - dst.flags = src.flags; - dst.last_use_tick = src.last_use_tick; - dst.num_items = src.num_items; - dst.current_item = src.current_item; - dst.vehicle_index = src.vehicle_index; - dst.current_station = StationIndex::FromUnderlying(src.current_station); - for (size_t i = 0; i < std::size(src.velocity); i++) + dst.flags = src.Flags; + dst.last_use_tick = src.LastUseTick; + dst.num_items = src.NumItems; + dst.current_item = src.CurrentItem; + dst.vehicle_index = src.VehicleIndex; + dst.current_station = StationIndex::FromUnderlying(src.CurrentStation); + for (size_t i = 0; i < std::size(src.Velocity); i++) { - dst.velocity[i] = src.velocity[i]; - dst.altitude[i] = src.altitude[i]; - dst.vertical[i] = src.vertical[i]; - dst.lateral[i] = src.lateral[i]; + dst.velocity[i] = src.Velocity[i]; + dst.altitude[i] = src.Altitude[i]; + dst.vertical[i] = src.Vertical[i]; + dst.lateral[i] = src.Lateral[i]; } } void ImportResearchList() { bool invented = true; - for (const auto& researchItem : _s6.research_items) + for (const auto& researchItem : _s6.ResearchItems) { if (researchItem.IsInventedEndMarker()) { @@ -1157,31 +1154,31 @@ namespace RCT2 *dst = {}; dst->id = id; - dst->type = RCTEntryIndexToOpenRCT2EntryIndex(src->type); - dst->flags = src->flags; + dst->type = RCTEntryIndexToOpenRCT2EntryIndex(src->Type); + dst->flags = src->Flags; - if (!(src->flags & BANNER_FLAG_LINKED_TO_RIDE) && IsUserStringID(src->string_idx)) + if (!(src->Flags & BANNER_FLAG_LINKED_TO_RIDE) && IsUserStringID(src->StringID)) { - dst->text = GetUserString(src->string_idx); + dst->text = GetUserString(src->StringID); } - if (src->flags & BANNER_FLAG_LINKED_TO_RIDE) + if (src->Flags & BANNER_FLAG_LINKED_TO_RIDE) { - dst->ride_index = RCT12RideIdToOpenRCT2RideId(src->ride_index); + dst->ride_index = RCT12RideIdToOpenRCT2RideId(src->RideIndex); } else { - dst->colour = src->colour; + dst->colour = src->Colour; } - dst->text_colour = src->text_colour; + dst->text_colour = src->TextColour; dst->position.x = src->x; dst->position.y = src->y; } void Initialise() { - OpenRCT2::GetContext()->GetGameState()->InitAll({ _s6.map_size, _s6.map_size }); + OpenRCT2::GetContext()->GetGameState()->InitAll({ _s6.MapSize, _s6.MapSize }); } /** @@ -1194,38 +1191,38 @@ namespace RCT2 // and the corrected filename. // In this park, peep_spawns[0] is incorrect, and peep_spawns[1] is correct. - if (String::Equals(_s6.scenario_filename, "WW South America - Rio Carnival.SC6") - || String::Equals(_s6.scenario_filename, "South America - Rio Carnival.SC6")) + if (String::Equals(_s6.ScenarioFilename, "WW South America - Rio Carnival.SC6") + || String::Equals(_s6.ScenarioFilename, "South America - Rio Carnival.SC6")) { - _s6.peep_spawns[0] = { 2160, 3167, 6, 1 }; - _s6.peep_spawns[1].x = RCT12_PEEP_SPAWN_UNDEFINED; + _s6.PeepSpawns[0] = { 2160, 3167, 6, 1 }; + _s6.PeepSpawns[1].x = RCT12_PEEP_SPAWN_UNDEFINED; } // In this park, peep_spawns[0] is correct. Just clear the other. else if ( - String::Equals(_s6.scenario_filename, "Great Wall of China Tourism Enhancement.SC6") - || String::Equals(_s6.scenario_filename, "Asia - Great Wall of China Tourism Enhancement.SC6")) + String::Equals(_s6.ScenarioFilename, "Great Wall of China Tourism Enhancement.SC6") + || String::Equals(_s6.ScenarioFilename, "Asia - Great Wall of China Tourism Enhancement.SC6")) { - _s6.peep_spawns[1].x = RCT12_PEEP_SPAWN_UNDEFINED; + _s6.PeepSpawns[1].x = RCT12_PEEP_SPAWN_UNDEFINED; } // Amity Airfield has peeps entering from the corner of the tile, instead of the middle. - else if (String::Equals(_s6.scenario_filename, "Amity Airfield.SC6")) + else if (String::Equals(_s6.ScenarioFilename, "Amity Airfield.SC6")) { - _s6.peep_spawns[0].y = 1296; + _s6.PeepSpawns[0].y = 1296; } // #9926: Africa - Oasis has peeps spawning on the edge underground near the entrance - else if (String::Equals(_s6.scenario_filename, "Africa - Oasis.SC6")) + else if (String::Equals(_s6.ScenarioFilename, "Africa - Oasis.SC6")) { - _s6.peep_spawns[0].y = 2128; - _s6.peep_spawns[0].z = 7; + _s6.PeepSpawns[0].y = 2128; + _s6.PeepSpawns[0].z = 7; } gPeepSpawns.clear(); for (size_t i = 0; i < Limits::MaxPeepSpawns; i++) { - if (_s6.peep_spawns[i].x != RCT12_PEEP_SPAWN_UNDEFINED) + if (_s6.PeepSpawns[i].x != RCT12_PEEP_SPAWN_UNDEFINED) { - PeepSpawn spawn = { _s6.peep_spawns[i].x, _s6.peep_spawns[i].y, _s6.peep_spawns[i].z * 16, - _s6.peep_spawns[i].direction }; + PeepSpawn spawn = { _s6.PeepSpawns[i].x, _s6.PeepSpawns[i].y, _s6.PeepSpawns[i].z * 16, + _s6.PeepSpawns[i].direction }; gPeepSpawns.push_back(spawn); } } @@ -1237,12 +1234,12 @@ namespace RCT2 uint16_t numRiders = 0; for (int32_t i = 0; i < GetMaxEntities(); i++) { - const auto& sprite = _s6.sprites[i]; - if (sprite.unknown.EntityIdentifier == RCT12EntityIdentifier::Peep) + const auto& entity = _s6.Entities[i]; + if (entity.Unknown.EntityIdentifier == RCT12EntityIdentifier::Peep) { - if (sprite.peep.current_ride == static_cast(rideIndex.ToUnderlying()) - && (static_cast(sprite.peep.state) == PeepState::OnRide - || static_cast(sprite.peep.state) == PeepState::EnteringRide)) + if (entity.Peep.CurrentRide == static_cast(rideIndex.ToUnderlying()) + && (static_cast(entity.Peep.State) == PeepState::OnRide + || static_cast(entity.Peep.State) == PeepState::EnteringRide)) { numRiders++; } @@ -1255,12 +1252,12 @@ namespace RCT2 { // Build tile pointer cache (needed to get the first element at a certain location) auto tilePointerIndex = TilePointerIndex( - Limits::MaxMapSize, _s6.tile_elements, std::size(_s6.tile_elements)); + Limits::MaxMapSize, _s6.TileElements, std::size(_s6.TileElements)); std::vector tileElements; bool nextElementInvisible = false; bool restOfTileInvisible = false; - const auto maxSize = std::min(Limits::MaxMapSize, _s6.map_size); + const auto maxSize = std::min(Limits::MaxMapSize, _s6.MapSize); for (TileCoordsXY coords = { 0, 0 }; coords.y < MAXIMUM_MAP_SIZE_TECHNICAL; coords.y++) { for (coords.x = 0; coords.x < MAXIMUM_MAP_SIZE_TECHNICAL; coords.x++) @@ -1401,7 +1398,7 @@ namespace RCT2 auto dst2 = dst->AsTrack(); auto src2 = src->AsTrack(); - auto rideType = _s6.rides[src2->GetRideIndex()].type; + auto rideType = _s6.Rides[src2->GetRideIndex()].Type; track_type_t trackType = static_cast(src2->GetTrackType()); dst2->SetTrackType(RCT2TrackTypeToOpenRCT2(trackType, rideType, IsFlatRide(src2->GetRideIndex()))); @@ -1516,9 +1513,9 @@ namespace RCT2 if (entry != nullptr && entry->scrolling_mode != SCROLLING_MODE_NONE) { auto bannerIndex = src2->GetBannerIndex(); - if (bannerIndex < std::size(_s6.banners)) + if (bannerIndex < std::size(_s6.Banners)) { - auto srcBanner = &_s6.banners[bannerIndex]; + auto srcBanner = &_s6.Banners[bannerIndex]; auto dstBanner = GetOrCreateBanner(BannerIndex::FromUnderlying(bannerIndex)); if (dstBanner == nullptr) { @@ -1549,9 +1546,9 @@ namespace RCT2 if (entry != nullptr && entry->scrolling_mode != SCROLLING_MODE_NONE) { auto bannerIndex = src2->GetBannerIndex(); - if (bannerIndex < std::size(_s6.banners)) + if (bannerIndex < std::size(_s6.Banners)) { - auto srcBanner = &_s6.banners[bannerIndex]; + auto srcBanner = &_s6.Banners[bannerIndex]; auto dstBanner = GetOrCreateBanner(BannerIndex::FromUnderlying(bannerIndex)); if (dstBanner == nullptr) { @@ -1575,9 +1572,9 @@ namespace RCT2 dst2->SetAllowedEdges(src2->GetAllowedEdges()); auto bannerIndex = src2->GetIndex(); - if (bannerIndex < std::size(_s6.banners)) + if (bannerIndex < std::size(_s6.Banners)) { - auto srcBanner = &_s6.banners[bannerIndex]; + auto srcBanner = &_s6.Banners[bannerIndex]; auto dstBanner = GetOrCreateBanner(BannerIndex::FromUnderlying(bannerIndex)); if (dstBanner == nullptr) { @@ -1604,22 +1601,22 @@ namespace RCT2 { for (size_t i = 0; i < ADVERTISING_CAMPAIGN_COUNT; i++) { - if (_s6.campaign_weeks_left[i] & CAMPAIGN_ACTIVE_FLAG) + if (_s6.CampaignWeeksLeft[i] & CAMPAIGN_ACTIVE_FLAG) { MarketingCampaign campaign{}; campaign.Type = static_cast(i); - campaign.WeeksLeft = _s6.campaign_weeks_left[i] & ~(CAMPAIGN_ACTIVE_FLAG | CAMPAIGN_FIRST_WEEK_FLAG); - if ((_s6.campaign_weeks_left[i] & CAMPAIGN_FIRST_WEEK_FLAG) != 0) + campaign.WeeksLeft = _s6.CampaignWeeksLeft[i] & ~(CAMPAIGN_ACTIVE_FLAG | CAMPAIGN_FIRST_WEEK_FLAG); + if ((_s6.CampaignWeeksLeft[i] & CAMPAIGN_FIRST_WEEK_FLAG) != 0) { campaign.Flags |= MarketingCampaignFlags::FIRST_WEEK; } if (campaign.Type == ADVERTISING_CAMPAIGN_RIDE_FREE || campaign.Type == ADVERTISING_CAMPAIGN_RIDE) { - campaign.RideId = RCT12RideIdToOpenRCT2RideId(_s6.campaign_ride_index[i]); + campaign.RideId = RCT12RideIdToOpenRCT2RideId(_s6.CampaignRideIndex[i]); } else if (campaign.Type == ADVERTISING_CAMPAIGN_FOOD_OR_DRINK_FREE) { - campaign.ShopItemType = ShopItem(_s6.campaign_ride_index[i]); + campaign.ShopItemType = ShopItem(_s6.CampaignRideIndex[i]); } gMarketingCampaigns.push_back(campaign); } @@ -1630,14 +1627,14 @@ namespace RCT2 { // First check staff mode as vanilla did not clean up patrol areas when switching from patrol to walk // without doing this we could accidentally add a patrol when it didn't exist. - if (_s6.staff_modes[staffId] != StaffMode::Patrol) + if (_s6.StaffModes[staffId] != StaffMode::Patrol) { return; } int32_t peepOffset = staffId * Limits::PatrolAreaSize; for (int32_t i = 0; i < Limits::PatrolAreaSize; i++) { - if (_s6.patrol_areas[peepOffset + i] == 0) + if (_s6.PatrolAreas[peepOffset + i] == 0) { // No patrol for this area continue; @@ -1646,7 +1643,7 @@ namespace RCT2 // Loop over the bits of the uint32_t for (int32_t j = 0; j < 32; j++) { - int8_t bit = (_s6.patrol_areas[peepOffset + i] >> j) & 1; + int8_t bit = (_s6.PatrolAreas[peepOffset + i] >> j) & 1; if (bit == 0) { // No patrol for this area @@ -1668,13 +1665,13 @@ namespace RCT2 { for (int32_t i = 0; i < GetMaxEntities(); i++) { - ImportEntity(_s6.sprites[i].unknown); + ImportEntity(_s6.Entities[i].Unknown); } } uint16_t GetMaxEntities() { - return (_s6.header.classic_flag == 0xf) ? Limits::MaxEntitiesRCTCExtended : Limits::MaxEntities; + return (_s6.Header.ClassicFlag == 0xf) ? Limits::MaxEntitiesRCTCExtended : Limits::MaxEntities; } template void ImportEntity(const RCT12EntityBase& src); @@ -1686,65 +1683,65 @@ namespace RCT2 }; ImportEntityCommonProperties(static_cast(dst), src); - if (IsUserStringID(src->name_string_idx)) + if (IsUserStringID(src->NameStringIdx)) { - dst->SetName(GetUserString(src->name_string_idx)); + dst->SetName(GetUserString(src->NameStringIdx)); } - dst->NextLoc = { src->next_x, src->next_y, src->next_z * COORDS_Z_STEP }; - dst->NextFlags = src->next_flags; - dst->State = static_cast(src->state); - dst->SubState = src->sub_state; - dst->SpriteType = static_cast(src->sprite_type); - dst->TshirtColour = src->tshirt_colour; - dst->TrousersColour = src->trousers_colour; - dst->DestinationX = src->destination_x; - dst->DestinationY = src->destination_y; - dst->DestinationTolerance = src->destination_tolerance; - dst->Var37 = src->var_37; - dst->Energy = src->energy; - dst->EnergyTarget = src->energy_target; - dst->Mass = src->mass; - dst->WindowInvalidateFlags = src->window_invalidate_flags; - dst->CurrentRide = RCT12RideIdToOpenRCT2RideId(src->current_ride); - dst->CurrentRideStation = StationIndex::FromUnderlying(src->current_ride_station); - dst->CurrentTrain = src->current_train; - dst->TimeToSitdown = src->time_to_sitdown; - dst->SpecialSprite = src->special_sprite; - dst->ActionSpriteType = static_cast(src->action_sprite_type); - dst->NextActionSpriteType = static_cast(src->next_action_sprite_type); - dst->ActionSpriteImageOffset = src->action_sprite_image_offset; - dst->Action = static_cast(src->action); - dst->ActionFrame = src->action_frame; - dst->StepProgress = src->step_progress; - dst->PeepDirection = src->direction; - dst->InteractionRideIndex = RCT12RideIdToOpenRCT2RideId(src->interaction_ride_index); - dst->Id = src->id; - dst->PathCheckOptimisation = src->path_check_optimisation; - dst->PeepFlags = src->peep_flags; - if (isNullLocation(src->pathfind_goal)) + dst->NextLoc = { src->NextX, src->NextY, src->NextZ * COORDS_Z_STEP }; + dst->NextFlags = src->NextFlags; + dst->State = static_cast(src->State); + dst->SubState = src->SubState; + dst->SpriteType = static_cast(src->SpriteType); + dst->TshirtColour = src->TshirtColour; + dst->TrousersColour = src->TrousersColour; + dst->DestinationX = src->DestinationX; + dst->DestinationY = src->DestinationY; + dst->DestinationTolerance = src->DestinationTolerance; + dst->Var37 = src->Var37; + dst->Energy = src->Energy; + dst->EnergyTarget = src->EnergyTarget; + dst->Mass = src->Mass; + dst->WindowInvalidateFlags = src->WindowInvalidateFlags; + dst->CurrentRide = RCT12RideIdToOpenRCT2RideId(src->CurrentRide); + dst->CurrentRideStation = StationIndex::FromUnderlying(src->CurrentRideStation); + dst->CurrentTrain = src->CurrentTrain; + dst->TimeToSitdown = src->TimeToSitdown; + dst->SpecialSprite = src->SpecialSprite; + dst->ActionSpriteType = static_cast(src->ActionSpriteType); + dst->NextActionSpriteType = static_cast(src->NextActionSpriteType); + dst->ActionSpriteImageOffset = src->ActionSpriteImageOffset; + dst->Action = static_cast(src->Action); + dst->ActionFrame = src->ActionFrame; + dst->StepProgress = src->StepProgress; + dst->PeepDirection = src->Direction; + dst->InteractionRideIndex = RCT12RideIdToOpenRCT2RideId(src->InteractionRideIndex); + dst->Id = src->Id; + dst->PathCheckOptimisation = src->PathCheckOptimisation; + dst->PeepFlags = src->PeepFlags; + if (isNullLocation(src->PathfindGoal)) { dst->PathfindGoal.SetNull(); dst->PathfindGoal.direction = INVALID_DIRECTION; } else { - dst->PathfindGoal = { src->pathfind_goal.x, src->pathfind_goal.y, src->pathfind_goal.z, - src->pathfind_goal.direction }; + dst->PathfindGoal = { src->PathfindGoal.x, src->PathfindGoal.y, src->PathfindGoal.z, + src->PathfindGoal.direction }; } - for (size_t i = 0; i < std::size(src->pathfind_history); i++) + for (size_t i = 0; i < std::size(src->PathfindHistory); i++) { - if (isNullLocation(src->pathfind_history[i])) + if (isNullLocation(src->PathfindHistory[i])) { dst->PathfindHistory[i].SetNull(); dst->PathfindHistory[i].direction = INVALID_DIRECTION; } else { - dst->PathfindHistory[i] = { src->pathfind_history[i].x, src->pathfind_history[i].y, - src->pathfind_history[i].z, src->pathfind_history[i].direction }; + dst->PathfindHistory[i] = { src->PathfindHistory[i].x, src->PathfindHistory[i].y, src->PathfindHistory[i].z, + src->PathfindHistory[i].direction }; } } - dst->WalkingFrameNum = src->no_action_frame_num; + dst->WalkingFrameNum = src->NoActionFrameNum; } constexpr EntityType GetEntityTypeFromRCT2Sprite(const RCT12EntityBase* src) @@ -1756,7 +1753,9 @@ namespace RCT2 output = EntityType::Vehicle; break; case RCT12EntityIdentifier::Peep: - if (RCT12PeepType(static_cast(src)->peep_type) == RCT12PeepType::Guest) + { + const auto& peep = static_cast(*src); + if (RCT12PeepType(peep.PeepType) == RCT12PeepType::Guest) { output = EntityType::Guest; } @@ -1765,9 +1764,10 @@ namespace RCT2 output = EntityType::Staff; } break; + } case RCT12EntityIdentifier::Misc: - switch (RCT12MiscEntityType(src->type)) + switch (RCT12MiscEntityType(src->Type)) { case RCT12MiscEntityType::SteamParticle: output = EntityType::SteamParticle; @@ -1828,7 +1828,7 @@ namespace RCT2 std::string GetUserString(StringId stringId) { - const auto originalString = _s6.custom_strings[(stringId - USER_STRING_START) % 1024]; + const auto originalString = _s6.CustomStrings[(stringId - USER_STRING_START) % 1024]; auto originalStringView = std::string_view( originalString, GetRCT2StringBufferLen(originalString, USER_STRING_MAX_LENGTH)); auto asUtf8 = RCT2StringToUTF8(originalStringView, RCT2LanguageId::EnglishUK); @@ -1848,7 +1848,7 @@ namespace RCT2 ObjectEntryIndex railingCount = 0; for (int16_t objectType = EnumValue(ObjectType::Ride); objectType <= EnumValue(ObjectType::Water); objectType++) { - for (int16_t i = 0; i < rct2_object_entry_group_counts[objectType]; i++, objectIt++) + for (int16_t i = 0; i < RCT2ObjectEntryGroupCounts[objectType]; i++, objectIt++) { auto entry = ObjectEntryDescriptor(_s6.Objects[objectIt]); if (entry.HasValue()) @@ -1905,7 +1905,7 @@ namespace RCT2 // Find if any rct1 terrain surfaces or edges have been used const bool hasRCT1Terrain = std::any_of( - std::begin(_s6.tile_elements), std::end(_s6.tile_elements), [](RCT12TileElement& tile) { + std::begin(_s6.TileElements), std::end(_s6.TileElements), [](RCT12TileElement& tile) { auto* surface = tile.AsSurface(); if (surface == nullptr) { @@ -1940,31 +1940,31 @@ namespace RCT2 { auto dst = CreateEntityAt<::Vehicle>(EntityId::FromUnderlying(baseSrc.EntityIndex)); auto src = static_cast(&baseSrc); - const auto& ride = _s6.rides[src->ride]; + const auto& ride = _s6.Rides[src->Ride]; ImportEntityCommonProperties(dst, src); - dst->SubType = ::Vehicle::Type(src->type); + dst->SubType = ::Vehicle::Type(src->Type); dst->Pitch = src->Pitch; - dst->bank_rotation = src->bank_rotation; - dst->remaining_distance = src->remaining_distance; - dst->velocity = src->velocity; - dst->acceleration = src->acceleration; - dst->ride = RideId::FromUnderlying(src->ride); - dst->vehicle_type = src->vehicle_type; - dst->colours.Body = src->colours.body_colour; - dst->colours.Trim = src->colours.trim_colour; - dst->colours.Tertiary = src->colours_extended; - dst->track_progress = src->track_progress; - dst->TrackLocation = { src->track_x, src->track_y, src->track_z }; - if (src->boat_location.IsNull() || static_cast(ride.mode) != RideMode::BoatHire - || src->status != static_cast(::Vehicle::Status::TravellingBoat)) + dst->bank_rotation = src->BankRotation; + dst->remaining_distance = src->RemainingDistance; + dst->velocity = src->Velocity; + dst->acceleration = src->Acceleration; + dst->ride = RideId::FromUnderlying(src->Ride); + dst->vehicle_type = src->VehicleType; + dst->colours.Body = src->Colours.BodyColour; + dst->colours.Trim = src->Colours.TrimColour; + dst->colours.Tertiary = src->ColoursExtended; + dst->track_progress = src->TrackProgress; + dst->TrackLocation = { src->TrackX, src->TrackY, src->TrackZ }; + if (src->BoatLocation.IsNull() || static_cast(ride.Mode) != RideMode::BoatHire + || src->Status != static_cast(::Vehicle::Status::TravellingBoat)) { dst->BoatLocation.SetNull(); dst->SetTrackDirection(src->GetTrackDirection()); dst->SetTrackType(src->GetTrackType()); // RotationControlToggle and Booster are saved as the same track piece ID // Which one the vehicle is using must be determined - if (IsFlatRide(src->ride)) + if (IsFlatRide(src->Ride)) { dst->SetTrackType(RCT12FlatTrackTypeToOpenRCT2(src->GetTrackType())); } @@ -1983,66 +1983,66 @@ namespace RCT2 } else { - dst->BoatLocation = TileCoordsXY{ src->boat_location.x, src->boat_location.y }.ToCoordsXY(); + dst->BoatLocation = TileCoordsXY{ src->BoatLocation.x, src->BoatLocation.y }.ToCoordsXY(); dst->SetTrackDirection(0); dst->SetTrackType(0); } - dst->next_vehicle_on_train = EntityId::FromUnderlying(src->next_vehicle_on_train); - dst->prev_vehicle_on_ride = EntityId::FromUnderlying(src->prev_vehicle_on_ride); - dst->next_vehicle_on_ride = EntityId::FromUnderlying(src->next_vehicle_on_ride); - dst->var_44 = src->var_44; - dst->mass = src->mass; - dst->update_flags = src->update_flags; + dst->next_vehicle_on_train = EntityId::FromUnderlying(src->NextVehicleOnTrain); + dst->prev_vehicle_on_ride = EntityId::FromUnderlying(src->PrevVehicleOnRide); + dst->next_vehicle_on_ride = EntityId::FromUnderlying(src->NextVehicleOnRide); + dst->var_44 = src->Var44; + dst->mass = src->Mass; + dst->update_flags = src->UpdateFlags; dst->SwingSprite = src->SwingSprite; - dst->current_station = StationIndex::FromUnderlying(src->current_station); - dst->current_time = src->current_time; - dst->crash_z = src->crash_z; + dst->current_station = StationIndex::FromUnderlying(src->CurrentStation); + dst->current_time = src->CurrentTime; + dst->crash_z = src->CrashZ; ::Vehicle::Status statusSrc = ::Vehicle::Status::MovingToEndOfStation; - if (src->status <= static_cast(::Vehicle::Status::StoppedByBlockBrakes)) + if (src->Status <= static_cast(::Vehicle::Status::StoppedByBlockBrakes)) { - statusSrc = static_cast<::Vehicle::Status>(src->status); + statusSrc = static_cast<::Vehicle::Status>(src->Status); } dst->status = statusSrc; - dst->sub_state = src->sub_state; - for (size_t i = 0; i < std::size(src->peep); i++) + dst->sub_state = src->SubState; + for (size_t i = 0; i < std::size(src->Peep); i++) { - dst->peep[i] = EntityId::FromUnderlying(src->peep[i]); - dst->peep_tshirt_colours[i] = src->peep_tshirt_colours[i]; + dst->peep[i] = EntityId::FromUnderlying(src->Peep[i]); + dst->peep_tshirt_colours[i] = src->PeepTshirtColours[i]; } - dst->num_seats = src->num_seats; - dst->num_peeps = src->num_peeps; - dst->next_free_seat = src->next_free_seat; - dst->restraints_position = src->restraints_position; - dst->crash_x = src->crash_x; - dst->sound2_flags = src->sound2_flags; - dst->spin_sprite = src->spin_sprite; - dst->sound1_id = static_cast(src->sound1_id); - dst->sound1_volume = src->sound1_volume; - dst->sound2_id = static_cast(src->sound2_id); - dst->sound2_volume = src->sound2_volume; - dst->sound_vector_factor = src->sound_vector_factor; - dst->time_waiting = src->time_waiting; - dst->speed = src->speed; - dst->powered_acceleration = src->powered_acceleration; + dst->num_seats = src->NumSeats; + dst->num_peeps = src->NumPeeps; + dst->next_free_seat = src->NextFreeSeat; + dst->restraints_position = src->RestraintsPosition; + dst->crash_x = src->CrashX; + dst->sound2_flags = src->Sound2Flags; + dst->spin_sprite = src->SpinSprite; + dst->sound1_id = static_cast(src->Sound1Id); + dst->sound1_volume = src->Sound1Volume; + dst->sound2_id = static_cast(src->Sound2Id); + dst->sound2_volume = src->Sound2Volume; + dst->sound_vector_factor = src->SoundVectorFactor; + dst->time_waiting = src->TimeWaiting; + dst->speed = src->Speed; + dst->powered_acceleration = src->PoweredAcceleration; dst->CollisionDetectionTimer = src->CollisionDetectionTimer; - dst->animation_frame = src->animation_frame; - dst->animationState = src->animationState; - dst->scream_sound_id = static_cast(src->scream_sound_id); + dst->animation_frame = src->AnimationFrame; + dst->animationState = src->AnimationState; + dst->scream_sound_id = static_cast(src->ScreamSoundId); dst->TrackSubposition = VehicleTrackSubposition{ src->TrackSubposition }; dst->NumLaps = src->NumLaps; - dst->brake_speed = src->brake_speed; - dst->lost_time_out = src->lost_time_out; - dst->vertical_drop_countdown = src->vertical_drop_countdown; - dst->var_D3 = src->var_D3; - dst->mini_golf_current_animation = MiniGolfAnimation(src->mini_golf_current_animation); - dst->mini_golf_flags = src->mini_golf_flags; - dst->ride_subtype = RCTEntryIndexToOpenRCT2EntryIndex(src->ride_subtype); - dst->seat_rotation = src->seat_rotation; - dst->target_seat_rotation = src->target_seat_rotation; - dst->IsCrashedVehicle = src->flags & RCT12_ENTITY_FLAGS_IS_CRASHED_VEHICLE_ENTITY; + dst->brake_speed = src->BrakeSpeed; + dst->lost_time_out = src->LostTimeOut; + dst->vertical_drop_countdown = src->VerticalDropCountdown; + dst->var_D3 = src->VarD3; + dst->mini_golf_current_animation = MiniGolfAnimation(src->MiniGolfCurrentAnimation); + dst->mini_golf_flags = src->MiniGolfFlags; + dst->ride_subtype = RCTEntryIndexToOpenRCT2EntryIndex(src->RideSubtype); + dst->seat_rotation = src->SeatRotation; + dst->target_seat_rotation = src->TargetSeatRotation; + dst->IsCrashedVehicle = src->Flags & RCT12_ENTITY_FLAGS_IS_CRASHED_VEHICLE_ENTITY; } static uint32_t AdjustScenarioToCurrentTicks(const S6Data& s6, uint32_t tick) @@ -2050,8 +2050,8 @@ namespace RCT2 // Previously gScenarioTicks was used as a time point, now it's gCurrentTicks. // gCurrentTicks and gScenarioTicks are now exported as the same, older saves that have a different // scenario tick must account for the difference between the two. - uint32_t ticksElapsed = s6.scenario_ticks - tick; - return s6.game_ticks_1 - ticksElapsed; + uint32_t ticksElapsed = s6.ScenarioTicks - tick; + return s6.GameTicks1 - ticksElapsed; } template<> void S6Importer::ImportEntity<::Guest>(const RCT12EntityBase& baseSrc) @@ -2060,72 +2060,72 @@ namespace RCT2 auto src = static_cast(&baseSrc); ImportEntityPeep(dst, src); - dst->OutsideOfPark = static_cast(src->outside_of_park); - dst->GuestNumRides = src->no_of_rides; - dst->Happiness = src->happiness; - dst->HappinessTarget = src->happiness_target; - dst->Nausea = src->nausea; - dst->NauseaTarget = src->nausea_target; - dst->Hunger = src->hunger; - dst->Thirst = src->thirst; - dst->Toilet = src->toilet; - dst->TimeToConsume = src->time_to_consume; - dst->Intensity = static_cast(src->intensity); - dst->NauseaTolerance = static_cast(src->nausea_tolerance); - dst->PaidOnDrink = src->paid_on_drink; + dst->OutsideOfPark = static_cast(src->OutsideOfPark); + dst->GuestNumRides = src->NoOfRides; + dst->Happiness = src->Happiness; + dst->HappinessTarget = src->HappinessTarget; + dst->Nausea = src->Nausea; + dst->NauseaTarget = src->NauseaTarget; + dst->Hunger = src->Hunger; + dst->Thirst = src->Thirst; + dst->Toilet = src->Toilet; + dst->TimeToConsume = src->TimeToConsume; + dst->Intensity = static_cast(src->Intensity); + dst->NauseaTolerance = static_cast(src->NauseaTolerance); + dst->PaidOnDrink = src->PaidOnDrink; OpenRCT2::RideUse::GetHistory().Set(dst->sprite_index, RCT12GetRidesBeenOn(src)); OpenRCT2::RideUse::GetTypeHistory().Set(dst->sprite_index, RCT12GetRideTypesBeenOn(src)); dst->SetItemFlags(src->GetItemFlags()); - dst->Photo1RideRef = RCT12RideIdToOpenRCT2RideId(src->photo1_ride_ref); - dst->Photo2RideRef = RCT12RideIdToOpenRCT2RideId(src->photo2_ride_ref); - dst->Photo3RideRef = RCT12RideIdToOpenRCT2RideId(src->photo3_ride_ref); - dst->Photo4RideRef = RCT12RideIdToOpenRCT2RideId(src->photo4_ride_ref); - dst->GuestNextInQueue = EntityId::FromUnderlying(src->next_in_queue); - dst->TimeInQueue = src->time_in_queue; - dst->CashInPocket = src->cash_in_pocket; - dst->CashSpent = src->cash_spent; - dst->ParkEntryTime = AdjustScenarioToCurrentTicks(_s6, src->park_entry_time); - dst->RejoinQueueTimeout = src->rejoin_queue_timeout; - dst->PreviousRide = RCT12RideIdToOpenRCT2RideId(src->previous_ride); - dst->PreviousRideTimeOut = src->previous_ride_time_out; - for (size_t i = 0; i < std::size(src->thoughts); i++) + dst->Photo1RideRef = RCT12RideIdToOpenRCT2RideId(src->Photo1RideRef); + dst->Photo2RideRef = RCT12RideIdToOpenRCT2RideId(src->Photo2RideRef); + dst->Photo3RideRef = RCT12RideIdToOpenRCT2RideId(src->Photo3RideRef); + dst->Photo4RideRef = RCT12RideIdToOpenRCT2RideId(src->Photo4RideRef); + dst->GuestNextInQueue = EntityId::FromUnderlying(src->NextInQueue); + dst->TimeInQueue = src->TimeInQueue; + dst->CashInPocket = src->CashInPocket; + dst->CashSpent = src->CashSpent; + dst->ParkEntryTime = AdjustScenarioToCurrentTicks(_s6, src->ParkEntryTime); + dst->RejoinQueueTimeout = src->RejoinQueueTimeout; + dst->PreviousRide = RCT12RideIdToOpenRCT2RideId(src->PreviousRide); + dst->PreviousRideTimeOut = src->PreviousRideTimeOut; + for (size_t i = 0; i < std::size(src->Thoughts); i++) { - auto srcThought = &src->thoughts[i]; + auto srcThought = &src->Thoughts[i]; auto dstThought = &dst->Thoughts[i]; - dstThought->type = static_cast(srcThought->type); - if (srcThought->item == RCT12PeepThoughtItemNone) + dstThought->type = static_cast(srcThought->Type); + if (srcThought->Item == RCT12PeepThoughtItemNone) dstThought->item = PeepThoughtItemNone; else - dstThought->item = srcThought->item; - dstThought->freshness = srcThought->freshness; - dstThought->fresh_timeout = srcThought->fresh_timeout; + dstThought->item = srcThought->Item; + dstThought->freshness = srcThought->Freshness; + dstThought->fresh_timeout = srcThought->FreshTimeout; } - dst->GuestHeadingToRideId = RCT12RideIdToOpenRCT2RideId(src->guest_heading_to_ride_id); - dst->GuestIsLostCountdown = src->peep_is_lost_countdown; - dst->LitterCount = src->litter_count; - dst->GuestTimeOnRide = src->time_on_ride; - dst->DisgustingCount = src->disgusting_count; - dst->PaidToEnter = src->paid_to_enter; - dst->PaidOnRides = src->paid_on_rides; - dst->PaidOnFood = src->paid_on_food; - dst->PaidOnSouvenirs = src->paid_on_souvenirs; - dst->AmountOfFood = src->no_of_food; - dst->AmountOfDrinks = src->no_of_drinks; - dst->AmountOfSouvenirs = src->no_of_souvenirs; - dst->VandalismSeen = src->vandalism_seen; - dst->VoucherType = src->voucher_type; - dst->VoucherRideId = RCT12RideIdToOpenRCT2RideId(src->voucher_arguments); - dst->SurroundingsThoughtTimeout = src->surroundings_thought_timeout; - dst->Angriness = src->angriness; - dst->TimeLost = src->time_lost; - dst->DaysInQueue = src->days_in_queue; - dst->BalloonColour = src->balloon_colour; - dst->UmbrellaColour = src->umbrella_colour; - dst->HatColour = src->hat_colour; - dst->FavouriteRide = RCT12RideIdToOpenRCT2RideId(src->favourite_ride); - dst->FavouriteRideRating = src->favourite_ride_rating; + dst->GuestHeadingToRideId = RCT12RideIdToOpenRCT2RideId(src->GuestHeadingToRideId); + dst->GuestIsLostCountdown = src->PeepIsLostCountdown; + dst->LitterCount = src->LitterCount; + dst->GuestTimeOnRide = src->TimeOnRide; + dst->DisgustingCount = src->DisgustingCount; + dst->PaidToEnter = src->PaidToEnter; + dst->PaidOnRides = src->PaidOnRides; + dst->PaidOnFood = src->PaidOnFood; + dst->PaidOnSouvenirs = src->PaidOnSouvenirs; + dst->AmountOfFood = src->NoOfFood; + dst->AmountOfDrinks = src->NoOfDrinks; + dst->AmountOfSouvenirs = src->NoOfSouvenirs; + dst->VandalismSeen = src->VandalismSeen; + dst->VoucherType = src->VoucherType; + dst->VoucherRideId = RCT12RideIdToOpenRCT2RideId(src->VoucherArguments); + dst->SurroundingsThoughtTimeout = src->SurroundingsThoughtTimeout; + dst->Angriness = src->Angriness; + dst->TimeLost = src->TimeLost; + dst->DaysInQueue = src->DaysInQueue; + dst->BalloonColour = src->BalloonColour; + dst->UmbrellaColour = src->UmbrellaColour; + dst->HatColour = src->HatColour; + dst->FavouriteRide = RCT12RideIdToOpenRCT2RideId(src->FavouriteRide); + dst->FavouriteRideRating = src->FavouriteRideRating; } template<> void S6Importer::ImportEntity<::Staff>(const RCT12EntityBase& baseSrc) @@ -2134,18 +2134,18 @@ namespace RCT2 auto src = static_cast(&baseSrc); ImportEntityPeep(dst, src); - dst->AssignedStaffType = StaffType(src->staff_type); - dst->MechanicTimeSinceCall = src->mechanic_time_since_call; + dst->AssignedStaffType = StaffType(src->StaffType); + dst->MechanicTimeSinceCall = src->MechanicTimeSinceCall; - dst->HireDate = src->park_entry_time; - dst->StaffOrders = src->staff_orders; - dst->StaffMowingTimeout = src->staff_mowing_timeout; - dst->StaffLawnsMown = src->paid_to_enter; - dst->StaffGardensWatered = src->paid_on_rides; - dst->StaffLitterSwept = src->paid_on_food; - dst->StaffBinsEmptied = src->paid_on_souvenirs; + dst->HireDate = src->ParkEntryTime; + dst->StaffOrders = src->StaffOrders; + dst->StaffMowingTimeout = src->StaffMowingTimeout; + dst->StaffLawnsMown = src->PaidToEnter; + dst->StaffGardensWatered = src->PaidOnRides; + dst->StaffLitterSwept = src->PaidOnFood; + dst->StaffBinsEmptied = src->PaidOnSouvenirs; - ImportStaffPatrolArea(dst, src->staff_id); + ImportStaffPatrolArea(dst, src->StaffId); } template<> void S6Importer::ImportEntity<::SteamParticle>(const RCT12EntityBase& baseSrc) @@ -2153,8 +2153,8 @@ namespace RCT2 auto dst = CreateEntityAt<::SteamParticle>(EntityId::FromUnderlying(baseSrc.EntityIndex)); auto src = static_cast(&baseSrc); ImportEntityCommonProperties(dst, src); - dst->time_to_move = src->time_to_move; - dst->frame = src->frame; + dst->time_to_move = src->TimeToMove; + dst->frame = src->Frame; } template<> void S6Importer::ImportEntity<::MoneyEffect>(const RCT12EntityBase& baseSrc) @@ -2162,12 +2162,12 @@ namespace RCT2 auto dst = CreateEntityAt<::MoneyEffect>(EntityId::FromUnderlying(baseSrc.EntityIndex)); auto src = static_cast(&baseSrc); ImportEntityCommonProperties(dst, src); - dst->MoveDelay = src->move_delay; - dst->NumMovements = src->num_movements; - dst->Vertical = src->vertical; - dst->Value = src->value; - dst->OffsetX = src->offset_x; - dst->Wiggle = src->wiggle; + dst->MoveDelay = src->MoveDelay; + dst->NumMovements = src->NumMovements; + dst->Vertical = src->Vertical; + dst->Value = src->Value; + dst->OffsetX = src->OffsetX; + dst->Wiggle = src->Wiggle; } template<> void S6Importer::ImportEntity<::VehicleCrashParticle>(const RCT12EntityBase& baseSrc) @@ -2175,18 +2175,18 @@ namespace RCT2 auto dst = CreateEntityAt<::VehicleCrashParticle>(EntityId::FromUnderlying(baseSrc.EntityIndex)); auto src = static_cast(&baseSrc); ImportEntityCommonProperties(dst, src); - dst->frame = src->frame; - dst->time_to_live = src->time_to_live; - dst->frame = src->frame; - dst->colour[0] = src->colour[0]; - dst->colour[1] = src->colour[1]; + dst->frame = src->Frame; + dst->time_to_live = src->TimeToLive; + dst->frame = src->Frame; + dst->colour[0] = src->Colour[0]; + dst->colour[1] = src->Colour[1]; dst->crashed_sprite_base = src->CrashedEntityBase; - dst->velocity_x = src->velocity_x; - dst->velocity_y = src->velocity_y; - dst->velocity_z = src->velocity_z; - dst->acceleration_x = src->acceleration_x; - dst->acceleration_y = src->acceleration_y; - dst->acceleration_z = src->acceleration_z; + dst->velocity_x = src->VelocityX; + dst->velocity_y = src->VelocityY; + dst->velocity_z = src->VelocityZ; + dst->acceleration_x = src->AccelerationX; + dst->acceleration_y = src->AccelerationY; + dst->acceleration_z = src->AccelerationZ; } template<> void S6Importer::ImportEntity<::ExplosionCloud>(const RCT12EntityBase& baseSrc) @@ -2194,7 +2194,7 @@ namespace RCT2 auto dst = CreateEntityAt<::ExplosionCloud>(EntityId::FromUnderlying(baseSrc.EntityIndex)); auto src = static_cast(&baseSrc); ImportEntityCommonProperties(dst, src); - dst->frame = src->frame; + dst->frame = src->Frame; } template<> void S6Importer::ImportEntity<::ExplosionFlare>(const RCT12EntityBase& baseSrc) @@ -2202,7 +2202,7 @@ namespace RCT2 auto dst = CreateEntityAt<::ExplosionFlare>(EntityId::FromUnderlying(baseSrc.EntityIndex)); auto src = static_cast(&baseSrc); ImportEntityCommonProperties(dst, src); - dst->frame = src->frame; + dst->frame = src->Frame; } template<> void S6Importer::ImportEntity<::CrashSplashParticle>(const RCT12EntityBase& baseSrc) @@ -2210,7 +2210,7 @@ namespace RCT2 auto dst = CreateEntityAt<::CrashSplashParticle>(EntityId::FromUnderlying(baseSrc.EntityIndex)); auto src = static_cast(&baseSrc); ImportEntityCommonProperties(dst, src); - dst->frame = src->frame; + dst->frame = src->Frame; } template<> void S6Importer::ImportEntity<::JumpingFountain>(const RCT12EntityBase& baseSrc) @@ -2218,13 +2218,13 @@ namespace RCT2 auto dst = CreateEntityAt<::JumpingFountain>(EntityId::FromUnderlying(baseSrc.EntityIndex)); auto src = static_cast(&baseSrc); ImportEntityCommonProperties(dst, src); - dst->NumTicksAlive = src->num_ticks_alive; - dst->frame = src->frame; - dst->FountainFlags = src->fountain_flags; - dst->TargetX = src->target_x; - dst->TargetY = src->target_y; - dst->Iteration = src->iteration; - dst->FountainType = RCT12MiscEntityType(src->type) == RCT12MiscEntityType::JumpingFountainSnow + dst->NumTicksAlive = src->NumTicksAlive; + dst->frame = src->Frame; + dst->FountainFlags = src->FountainFlags; + dst->TargetX = src->TargetX; + dst->TargetY = src->TargetY; + dst->Iteration = src->Iteration; + dst->FountainType = RCT12MiscEntityType(src->Type) == RCT12MiscEntityType::JumpingFountainSnow ? ::JumpingFountainType::Snow : ::JumpingFountainType::Water; } @@ -2234,10 +2234,10 @@ namespace RCT2 auto dst = CreateEntityAt<::Balloon>(EntityId::FromUnderlying(baseSrc.EntityIndex)); auto src = static_cast(&baseSrc); ImportEntityCommonProperties(dst, src); - dst->popped = src->popped; - dst->time_to_move = src->time_to_move; - dst->frame = src->frame; - dst->colour = src->colour; + dst->popped = src->Popped; + dst->time_to_move = src->TimeToMove; + dst->frame = src->Frame; + dst->colour = src->Colour; } template<> void S6Importer::ImportEntity<::Duck>(const RCT12EntityBase& baseSrc) @@ -2245,10 +2245,10 @@ namespace RCT2 auto dst = CreateEntityAt<::Duck>(EntityId::FromUnderlying(baseSrc.EntityIndex)); auto src = static_cast(&baseSrc); ImportEntityCommonProperties(dst, src); - dst->frame = src->frame; - dst->target_x = src->target_x; - dst->target_y = src->target_y; - dst->state = static_cast<::Duck::DuckState>(src->state); + dst->frame = src->Frame; + dst->target_x = src->TargetX; + dst->target_y = src->TargetY; + dst->state = static_cast<::Duck::DuckState>(src->State); } template<> void S6Importer::ImportEntity<::Litter>(const RCT12EntityBase& baseSrc) @@ -2256,8 +2256,8 @@ namespace RCT2 auto dst = CreateEntityAt<::Litter>(EntityId::FromUnderlying(baseSrc.EntityIndex)); auto src = static_cast(&baseSrc); ImportEntityCommonProperties(dst, src); - dst->SubType = ::Litter::Type(src->type); - dst->creationTick = AdjustScenarioToCurrentTicks(_s6, src->creationTick); + dst->SubType = ::Litter::Type(src->Type); + dst->creationTick = AdjustScenarioToCurrentTicks(_s6, src->CreationTick); } void S6Importer::ImportEntity(const RCT12EntityBase& src) diff --git a/src/openrct2/rct2/T6Importer.cpp b/src/openrct2/rct2/T6Importer.cpp index fa1221a0ca..1f44c2e493 100644 --- a/src/openrct2/rct2/T6Importer.cpp +++ b/src/openrct2/rct2/T6Importer.cpp @@ -71,64 +71,64 @@ namespace RCT2 // Rework td6 so that it is just the fields _stream.Read(&td6, 0xA3); - td->type = td6.type; // 0x00 - td->vehicle_type = td6.vehicle_type; + td->type = td6.Type; // 0x00 + td->vehicle_type = td6.VehicleType; td->cost = 0; - td->flags = td6.flags; - td->ride_mode = static_cast(td6.ride_mode); + td->flags = td6.Flags; + td->ride_mode = static_cast(td6.RideMode); td->track_flags = 0; - td->colour_scheme = td6.version_and_colour_scheme & 0x3; + td->colour_scheme = td6.VersionAndColourScheme & 0x3; for (auto i = 0; i < Limits::MaxTrainsPerRide; ++i) { - td->vehicle_colours[i].Body = td6.vehicle_colours[i].body_colour; - td->vehicle_colours[i].Trim = td6.vehicle_colours[i].trim_colour; - td->vehicle_colours[i].Tertiary = td6.vehicle_additional_colour[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->entrance_style = td6.entrance_style; - td->total_air_time = td6.total_air_time; - td->depart_flags = td6.depart_flags; - td->number_of_trains = td6.number_of_trains; - td->number_of_cars_per_train = td6.number_of_cars_per_train; - td->min_waiting_time = td6.min_waiting_time; - td->max_waiting_time = td6.max_waiting_time; - td->operation_setting = td6.operation_setting; - td->max_speed = td6.max_speed; - td->average_speed = td6.average_speed; - td->ride_length = td6.ride_length; - td->max_positive_vertical_g = td6.max_positive_vertical_g; - td->max_negative_vertical_g = td6.max_negative_vertical_g; - td->max_lateral_g = td6.max_lateral_g; + td->entrance_style = 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; if (td->type == RIDE_TYPE_MINI_GOLF) { - td->holes = td6.holes; + td->holes = td6.Holes; } else { - td->inversions = td6.inversions; + td->inversions = td6.Inversions; } - td->drops = td6.drops; - td->highest_drop_height = td6.highest_drop_height; - td->excitement = td6.excitement; - td->intensity = td6.intensity; - td->nausea = td6.nausea; - td->upkeep_cost = td6.upkeep_cost; + td->drops = td6.Drops; + td->highest_drop_height = td6.HighestDropHeight; + td->excitement = td6.Excitement; + td->intensity = td6.Intensity; + td->nausea = td6.Nausea; + td->upkeep_cost = td6.UpkeepCost; for (auto i = 0; i < Limits::NumColourSchemes; ++i) { - td->track_spine_colour[i] = td6.track_spine_colour[i]; - td->track_rail_colour[i] = td6.track_rail_colour[i]; - td->track_support_colour[i] = td6.track_support_colour[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->flags2 = td6.flags2; - td->vehicle_object = ObjectEntryDescriptor(td6.vehicle_object); - td->space_required_x = td6.space_required_x; - td->space_required_y = td6.space_required_y; - td->lift_hill_speed = td6.lift_hill_speed_num_circuits & 0b00011111; - td->num_circuits = td6.lift_hill_speed_num_circuits >> 5; + 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; - auto version = static_cast((td6.version_and_colour_scheme >> 2) & 3); + auto version = static_cast((td6.VersionAndColourScheme >> 2) & 3); if (version != RCT12TrackDesignVersion::TD6) { LOG_ERROR("Unsupported track design."); @@ -141,17 +141,17 @@ namespace RCT2 if (rtd.HasFlag(RIDE_TYPE_FLAG_IS_MAZE)) { TD46MazeElement t6MazeElement{}; - t6MazeElement.all = !0; - while (t6MazeElement.all != 0) + t6MazeElement.All = !0; + while (t6MazeElement.All != 0) { _stream.Read(&t6MazeElement, sizeof(TD46MazeElement)); - if (t6MazeElement.all != 0) + if (t6MazeElement.All != 0) { TrackDesignMazeElement mazeElement{}; mazeElement.x = t6MazeElement.x; mazeElement.y = t6MazeElement.y; - mazeElement.direction = t6MazeElement.direction; - mazeElement.type = t6MazeElement.type; + mazeElement.direction = t6MazeElement.Direction; + mazeElement.type = t6MazeElement.Type; td->maze_elements.push_back(mazeElement); } } @@ -165,14 +165,14 @@ namespace RCT2 _stream.Read(&t6TrackElement, sizeof(TD46TrackElement)); TrackDesignTrackElement trackElement{}; - track_type_t trackType = RCT2TrackTypeToOpenRCT2(t6TrackElement.type, td->type, true); + track_type_t trackType = RCT2TrackTypeToOpenRCT2(t6TrackElement.Type, td->type, true); if (trackType == TrackElemType::InvertedUp90ToFlatQuarterLoopAlias) { trackType = TrackElemType::MultiDimInvertedUp90ToFlatQuarterLoop; } trackElement.type = trackType; - trackElement.flags = t6TrackElement.flags; + trackElement.flags = t6TrackElement.Flags; td->track_elements.push_back(trackElement); } @@ -197,13 +197,13 @@ namespace RCT2 TD6SceneryElement t6SceneryElement{}; _stream.Read(&t6SceneryElement, sizeof(TD6SceneryElement)); TrackDesignSceneryElement sceneryElement{}; - sceneryElement.scenery_object = ObjectEntryDescriptor(t6SceneryElement.scenery_object); + sceneryElement.scenery_object = ObjectEntryDescriptor(t6SceneryElement.SceneryObject); sceneryElement.loc.x = t6SceneryElement.x * COORDS_XY_STEP; sceneryElement.loc.y = t6SceneryElement.y * COORDS_XY_STEP; sceneryElement.loc.z = t6SceneryElement.z * COORDS_Z_STEP; - sceneryElement.flags = t6SceneryElement.flags; - sceneryElement.primary_colour = t6SceneryElement.primary_colour; - sceneryElement.secondary_colour = t6SceneryElement.secondary_colour; + sceneryElement.flags = t6SceneryElement.Flags; + sceneryElement.primary_colour = t6SceneryElement.PrimaryColour; + sceneryElement.secondary_colour = t6SceneryElement.SecondaryColour; td->scenery_elements.push_back(std::move(sceneryElement)); } diff --git a/src/openrct2/scenario/ScenarioRepository.cpp b/src/openrct2/scenario/ScenarioRepository.cpp index 9476c38092..2b97665144 100644 --- a/src/openrct2/scenario/ScenarioRepository.cpp +++ b/src/openrct2/scenario/ScenarioRepository.cpp @@ -246,15 +246,15 @@ private: auto chunkReader = SawyerChunkReader(stream.get()); const auto header = chunkReader.ReadChunkAs(); - if (header.type == S6_TYPE_SCENARIO) + if (header.Type == S6_TYPE_SCENARIO) { auto info = chunkReader.ReadChunkAs(); // If the name or the details contain a colour code, they might be in UTF-8 already. // This is caused by a bug that was in OpenRCT2 for 3 years. - if (!IsLikelyUTF8(info.name) && !IsLikelyUTF8(info.details)) + if (!IsLikelyUTF8(info.Name) && !IsLikelyUTF8(info.Details)) { - RCT2StringToUTF8Self(info.name, sizeof(info.name)); - RCT2StringToUTF8Self(info.details, sizeof(info.details)); + RCT2StringToUTF8Self(info.Name, sizeof(info.Name)); + RCT2StringToUTF8Self(info.Details, sizeof(info.Details)); } *entry = CreateNewScenarioEntry(path, timestamp, &info); @@ -277,20 +277,20 @@ private: // Set new entry String::Set(entry.path, sizeof(entry.path), path.c_str()); entry.timestamp = timestamp; - entry.category = s6Info->category; - entry.objective_type = s6Info->objective_type; - entry.objective_arg_1 = s6Info->objective_arg_1; - entry.objective_arg_2 = s6Info->objective_arg_2; - entry.objective_arg_3 = s6Info->objective_arg_3; + entry.category = s6Info->Category; + entry.objective_type = s6Info->ObjectiveType; + entry.objective_arg_1 = s6Info->ObjectiveArg1; + entry.objective_arg_2 = s6Info->ObjectiveArg2; + entry.objective_arg_3 = s6Info->ObjectiveArg3; entry.highscore = nullptr; - if (String::IsNullOrEmpty(s6Info->name)) + if (String::IsNullOrEmpty(s6Info->Name)) { // If the scenario doesn't have a name, set it to the filename String::Set(entry.name, sizeof(entry.name), Path::GetFileNameWithoutExtension(entry.path).c_str()); } else { - String::Set(entry.name, sizeof(entry.name), s6Info->name); + String::Set(entry.name, sizeof(entry.name), s6Info->Name); // Normalise the name to make the scenario as recognisable as possible. ScenarioSources::NormaliseName(entry.name, sizeof(entry.name), entry.name); } @@ -298,7 +298,7 @@ private: // entry.name will be translated later so keep the untranslated name here String::Set(entry.internal_name, sizeof(entry.internal_name), entry.name); - String::Set(entry.details, sizeof(entry.details), s6Info->details); + String::Set(entry.details, sizeof(entry.details), s6Info->Details); // Look up and store information regarding the origins of this scenario. SourceDescriptor desc;