From 48619afbb8dd416b6184bad2891176a87e7e6469 Mon Sep 17 00:00:00 2001 From: Michael Steenbeek Date: Thu, 19 Jan 2023 22:48:07 +0100 Subject: [PATCH] Replace snake_case in rct1 folder --- src/openrct2/rct1/RCT1.h | 1048 +++++++++++++++--------------- src/openrct2/rct1/S4Importer.cpp | 868 +++++++++++++------------ src/openrct2/rct1/T4Importer.cpp | 90 +-- 3 files changed, 1004 insertions(+), 1002 deletions(-) diff --git a/src/openrct2/rct1/RCT1.h b/src/openrct2/rct1/RCT1.h index 797479c91f..5382315c30 100644 --- a/src/openrct2/rct1/RCT1.h +++ b/src/openrct2/rct1/RCT1.h @@ -15,7 +15,7 @@ namespace RCT1 { - constexpr const uint8_t RCT1_RESEARCH_FLAGS_SEPARATOR = 0xFF; + constexpr const uint8_t RCT1ResearchFlagsSeparator = 0xFF; enum class RideType : uint8_t { @@ -125,272 +125,272 @@ namespace RCT1 */ struct Ride { - RideType type; // 0x000 - uint8_t vehicle_type; // 0x001 - uint16_t lifecycle_flags; // 0x002 - uint8_t operating_mode; // 0x004 - uint8_t colour_scheme; // 0x005 + RideType Type; // 0x000 + uint8_t VehicleType; // 0x001 + uint16_t LifecycleFlags; // 0x002 + uint8_t OperatingMode; // 0x004 + uint8_t ColourScheme; // 0x005 struct { - colour_t body; - colour_t trim; - } vehicle_colours[Limits::MaxTrainsPerRide]; // 0x006 - colour_t track_primary_colour; // 0x01E - colour_t track_secondary_colour; // 0x01F - colour_t track_support_colour; // 0x020 - uint8_t status; // 0x021 - uint16_t name; // 0x022 - uint16_t name_argument_ride; // 0x024 - uint16_t name_argument_number; // 0x026 - RCT12xy8 overall_view; // 0x028 - RCT12xy8 station_starts[Limits::MaxStationsPerRide]; // 0x02A - uint8_t station_height[Limits::MaxStationsPerRide]; // 0x032 - uint8_t station_length[Limits::MaxStationsPerRide]; // 0x036 - uint8_t station_light[Limits::MaxStationsPerRide]; // 0x03A - uint8_t station_depart[Limits::MaxStationsPerRide]; // 0x03E - RCT12xy8 entrance[Limits::MaxStationsPerRide]; // 0x042 - RCT12xy8 exit[Limits::MaxStationsPerRide]; // 0x04A - uint16_t last_peep_in_queue[Limits::MaxStationsPerRide]; // 0x052 - uint8_t num_peeps_in_queue[Limits::MaxStationsPerRide]; // 0x05A - uint16_t vehicles[Limits::MaxTrainsPerRide]; // 0x05E - uint8_t depart_flags; // 0x076 - uint8_t num_stations; // 0x077 - uint8_t NumTrains; // 0x078 - uint8_t num_cars_per_train; // 0x079 - uint8_t ProposedNumTrains; // 0x07A - uint8_t proposed_num_cars_per_train; // 0x07B - uint8_t max_trains; // 0x07C - uint8_t min_max_cars_per_train; // 0x07D - uint8_t min_waiting_time; // 0x07E - uint8_t max_waiting_time; // 0x07F - uint8_t operation_option; // 0x080 - uint8_t boat_hire_return_direction; // 0x081 - RCT12xy8 boat_hire_return_position; // 0x082 - uint8_t data_logging_index; // 0x084 - uint8_t special_track_elements; // 0x085 - uint16_t unk_86; // 0x086 - int32_t max_speed; // 0x088 - int32_t average_speed; // 0x08C - uint8_t current_test_segment; // 0x090 - uint8_t average_speed_test_timeout; // 0x091 - uint8_t pad_0E2[0x2]; // 0x092 - int32_t length[Limits::MaxStationsPerRide]; // 0x094 - uint16_t time[Limits::MaxStationsPerRide]; // 0x0A4 - fixed16_2dp max_positive_vertical_g; // 0x0AC - fixed16_2dp max_negative_vertical_g; // 0x0AE - fixed16_2dp max_lateral_g; // 0x0B0 - fixed16_2dp previous_vertical_g; // 0x0B2 - fixed16_2dp previous_lateral_g; // 0x0B4 - uint8_t pad_B6[0x2]; // 0x0B6 - uint32_t testing_flags; // 0x0B8 + colour_t Body; + colour_t Trim; + } VehicleColours[Limits::MaxTrainsPerRide]; // 0x006 + colour_t TrackPrimaryColour; // 0x01E + colour_t TrackSecondaryColour; // 0x01F + colour_t TrackSupportColour; // 0x020 + uint8_t Status; // 0x021 + uint16_t Name; // 0x022 + uint16_t NameArgumentRide; // 0x024 + uint16_t NameArgumentNumber; // 0x026 + RCT12xy8 OverallView; // 0x028 + RCT12xy8 StationStarts[Limits::MaxStationsPerRide]; // 0x02A + uint8_t StationHeights[Limits::MaxStationsPerRide]; // 0x032 + uint8_t StationLengths[Limits::MaxStationsPerRide]; // 0x036 + uint8_t StationLights[Limits::MaxStationsPerRide]; // 0x03A + uint8_t StationDeparts[Limits::MaxStationsPerRide]; // 0x03E + RCT12xy8 Entrances[Limits::MaxStationsPerRide]; // 0x042 + RCT12xy8 Exits[Limits::MaxStationsPerRide]; // 0x04A + uint16_t LastPeepInQueue[Limits::MaxStationsPerRide]; // 0x052 + uint8_t NumPeepsInQueue[Limits::MaxStationsPerRide]; // 0x05A + uint16_t Vehicles[Limits::MaxTrainsPerRide]; // 0x05E + uint8_t DepartFlags; // 0x076 + uint8_t NumStations; // 0x077 + uint8_t NumTrains; // 0x078 + uint8_t NumCarsPerTrain; // 0x079 + uint8_t ProposedNumTrains; // 0x07A + uint8_t ProposedNumCarsPerTrain; // 0x07B + uint8_t MaxTrains; // 0x07C + uint8_t MinMaxCarsPerTrain; // 0x07D + uint8_t MinWaitingTime; // 0x07E + uint8_t MaxWaitingTime; // 0x07F + uint8_t OperationOption; // 0x080 + uint8_t BoatHireReturnDirection; // 0x081 + RCT12xy8 BoatHireReturnPosition; // 0x082 + uint8_t DataLoggingIndex; // 0x084 + uint8_t SpecialTrackElements; // 0x085 + uint16_t Unk6; // 0x086 + int32_t MaxSpeed; // 0x088 + int32_t AverageSpeed; // 0x08C + uint8_t CurrentTestSegment; // 0x090 + uint8_t AverageSpeedTestTimeout; // 0x091 + uint8_t Pad0E2[0x2]; // 0x092 + int32_t Length[Limits::MaxStationsPerRide]; // 0x094 + uint16_t Time[Limits::MaxStationsPerRide]; // 0x0A4 + fixed16_2dp MaxPositiveVerticalG; // 0x0AC + fixed16_2dp MaxNegativeVerticalG; // 0x0AE + fixed16_2dp MaxLateralG; // 0x0B0 + fixed16_2dp PreviousVerticalG; // 0x0B2 + fixed16_2dp PreviousLateralG; // 0x0B4 + uint8_t PadB6[0x2]; // 0x0B6 + uint32_t TestingFlags; // 0x0B8 // 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; // 0x0BC + RCT12xy8 CurTestTrackLocation; // 0x0BC // Next 3 variables are related (XXXX XYYY ZZZa aaaa) - uint16_t turn_count_default; // 0x0BE X = current turn count - uint16_t turn_count_banked; // 0x0C0 - uint16_t turn_count_sloped; // 0x0C2 X = number turns > 3 elements + uint16_t TurnCountDefault; // 0x0BE X = current turn count + uint16_t TurnCountBanked; // 0x0C0 + uint16_t TurnCountSloped; // 0x0C2 X = number turns > 3 elements union { - uint8_t num_inversions; // 0x0C4 - uint8_t num_holes; + uint8_t NumInversions; // 0x0C4 + uint8_t NumHoles; }; - uint8_t num_drops; // 0x0C5 - uint8_t start_drop_height; // 0x0C6 - uint8_t highest_drop_height; // 0x0C7 - int32_t sheltered_length; // 0x0C8 - uint8_t unk_CC[2]; // 0x0CC - uint8_t num_sheltered_sections; // 0x0CE - // see cur_test_track_location - uint8_t cur_test_track_z; // 0x0CF - int16_t unk_D0; // 0x0D0 - int16_t unk_D2; // 0x0D2 + uint8_t NumDrops; // 0x0C5 + uint8_t StartDropHeight; // 0x0C6 + uint8_t HighestDropHeight; // 0x0C7 + int32_t ShelteredLength; // 0x0C8 + uint8_t UnkCC[2]; // 0x0CC + uint8_t NumShelteredSections; // 0x0CE + // see CurTestTrackLocation + uint8_t CurTestTrackZ; // 0x0CF + int16_t UnkD0; // 0x0D0 + int16_t UnkD2; // 0x0D2 // Customer count in the last 10 * 960 game ticks (sliding window) - uint16_t num_customers[Limits::CustomerHistorySize]; // 0xD4 - money16 price; // 0x0E8 - RCT12xy8 chairlift_bullwheel_location[2]; // 0x0EA - uint8_t chairlift_bullwheel_z[2]; // 0x0EE + uint16_t NumCustomers[Limits::CustomerHistorySize]; // 0xD4 + money16 Price; // 0x0E8 + RCT12xy8 ChairliftBullwheelLocation[2]; // 0x0EA + uint8_t ChairliftBullwheelZ[2]; // 0x0EE union { - RatingTuple ratings; + RatingTuple Ratings; struct { - ride_rating excitement; // 0x0F0 - ride_rating intensity; // 0x0F2 - ride_rating nausea; // 0x0F4 + ride_rating Excitement; // 0x0F0 + ride_rating Intensity; // 0x0F2 + ride_rating Nausea; // 0x0F4 }; }; - uint16_t value; // 0x0F6 - uint16_t chairlift_bullwheel_rotation; // 0x0F8 - uint8_t satisfaction; // 0x0FA - uint8_t satisfaction_time_out; // 0x0FB - uint8_t satisfaction_next; // 0x0FC - uint8_t window_invalidate_flags; // 0x0FD - uint8_t unk_FE[2]; // 0x0FE - uint32_t total_customers; // 0x100 - money32 total_profit; // 0x104 - uint8_t popularity; // 0x108 - uint8_t popularity_time_out; // 0x109 - uint8_t popularity_next; // 0x10A - uint8_t num_riders; // 0x10B - uint8_t music_tune_id; // 0x10C - uint8_t slide_in_use; // 0x10D + uint16_t Value; // 0x0F6 + uint16_t ChairliftBullwheelRotation; // 0x0F8 + uint8_t Satisfaction; // 0x0FA + uint8_t SatisfactionTimeOut; // 0x0FB + uint8_t SatisfactionNext; // 0x0FC + uint8_t WindowInvalidateFlags; // 0x0FD + uint8_t UnkFE[2]; // 0x0FE + uint32_t TotalCustomers; // 0x100 + money32 TotalProfit; // 0x104 + uint8_t Popularity; // 0x108 + uint8_t PopularityTimeOut; // 0x109 + uint8_t PopularityNext; // 0x10A + uint8_t NumRiders; // 0x10B + uint8_t MusicTuneID; // 0x10C + uint8_t SlideInUse; // 0x10D union { - uint16_t slide_peep; // 0x10E - uint16_t maze_tiles; // 0x10E + uint16_t SlidePeep; // 0x10E + uint16_t MazeTiles; // 0x10E }; - uint8_t pad_110[0xE]; // 0x110 - uint8_t slide_peep_t_shirt_colour; // 0x11E - uint8_t pad_11F[0x7]; // 0x11F - uint8_t spiral_slide_progress; // 0x126 - uint8_t pad_127[0x9]; // 0x127 - int16_t build_date; // 0x130 - money16 upkeep_cost; // 0x131 - uint16_t race_winner; // 0x132 - uint8_t unk_134[2]; // 0x134 - uint32_t music_position; // 0x138 - uint8_t breakdown_reason_pending; // 0x13C - uint8_t mechanic_status; // 0x13D - uint16_t mechanic; // 0x13E - uint8_t inspection_station; // 0x140 - uint8_t broken_vehicle; // 0x141 - uint8_t broken_car; // 0x142 - uint8_t breakdown_reason; // 0x143 - money16 price_secondary; // 0x144 + uint8_t Pad110[0xE]; // 0x110 + uint8_t SlidePeepTshirtColour; // 0x11E + uint8_t Pad11F[0x7]; // 0x11F + uint8_t SpiralSlideProgress; // 0x126 + uint8_t Pad127[0x9]; // 0x127 + int16_t BuildDate; // 0x130 + money16 UpkeepCost; // 0x131 + uint16_t RaceWinner; // 0x132 + uint8_t Unk134[2]; // 0x134 + uint32_t MusicPosition; // 0x138 + uint8_t BreakdownReasonPending; // 0x13C + uint8_t MechanicStatus; // 0x13D + uint16_t Mechanic; // 0x13E + uint8_t InspectionStation; // 0x140 + uint8_t BrokenVehicle; // 0x141 + uint8_t BrokenCar; // 0x142 + uint8_t BreakdownReason; // 0x143 + money16 PriceSecondary; // 0x144 union { struct { - uint8_t reliability_subvalue; // 0x146, 0 - 255, acts like the decimals for reliability_percentage - uint8_t reliability_percentage; // 0x147, Starts at 100 and decreases from there. + uint8_t ReliabilitySubvalue; // 0x146, 0 - 255, acts like the decimals for ReliabilityPercentage + uint8_t ReliabilityPercentage; // 0x147, Starts at 100 and decreases from there. }; - uint16_t reliability; // 0x146 + uint16_t Reliability; // 0x146 }; - uint8_t unreliability_factor; // 0x148 - uint8_t downtime; // 0x149 - uint8_t inspection_interval; // 0x14A - uint8_t last_inspection; // 0x14B - uint8_t unk_14C[20]; // 0x14C - money32 income_per_hour; // 0x160 - money32 profit; // 0x164 - uint8_t queue_time[Limits::MaxStationsPerRide]; // 0x168 - colour_t track_colour_main[4]; // 0x16C - colour_t track_colour_additional[4]; // 0x170 - colour_t track_colour_supports[4]; // 0x174 - uint8_t music; // 0x178 - uint8_t entrance_style; // 0x179 - uint8_t unk_17A[230]; // 0x17A + uint8_t UnreliabilityFactor; // 0x148 + uint8_t Downtime; // 0x149 + uint8_t InspectionInterval; // 0x14A + uint8_t LastInspection; // 0x14B + uint8_t Unk14C[20]; // 0x14C + money32 IncomePerHour; // 0x160 + money32 Profit; // 0x164 + uint8_t QueueTime[Limits::MaxStationsPerRide]; // 0x168 + colour_t TrackColourMain[4]; // 0x16C + colour_t TrackColourAdditional[4]; // 0x170 + colour_t TrackColourSupports[4]; // 0x174 + uint8_t Music; // 0x178 + uint8_t EntranceStyle; // 0x179 + uint8_t Unk17A[230]; // 0x17A }; assert_struct_size(Ride, 0x260); struct UnkEntity : RCT12SpriteBase { - uint8_t pad_1F[3]; // 0x1f - StringId name_string_idx; // 0x22 - uint16_t var_24; - uint16_t frame; // 0x26 - uint8_t var_28[3]; - uint8_t var_2B; - uint8_t pad_2C[0x45]; - uint8_t var_71; + uint8_t Pad1F[3]; // 0x1f + StringId NameStringID; // 0x22 + uint16_t Var24; + uint16_t Frame; // 0x26 + uint8_t Var28[3]; + uint8_t Var2B; + uint8_t Pad2C[0x45]; + uint8_t Var71; }; struct Vehicle : RCT12SpriteBase { - uint8_t Pitch; // 0x1F - uint8_t bank_rotation; // 0x20 - uint8_t pad_21[3]; - int32_t remaining_distance; // 0x24 - int32_t velocity; // 0x28 - int32_t acceleration; // 0x2C - uint8_t ride; // 0x30 + uint8_t Pitch; // 0x1F + uint8_t BankRotation; // 0x20 + uint8_t Pad21[3]; + int32_t RemainingDistance; // 0x24 + int32_t Velocity; // 0x28 + int32_t Acceleration; // 0x2C + uint8_t Ride; // 0x30 uint8_t CarType; // 0x31 - RCT12VehicleColour colours; // 0x32 + 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 TrackX; // 0x38 + uint16_t TrackY; // 0x3A + uint16_t TrackZ; // 0x3C + uint16_t NextVehicleOnTrain; // 0x3E // The previous vehicle on the same train or the last vehicle on the previous or only train. - uint16_t prev_vehicle_on_ride; // 0x40 + uint16_t PrevVehicleOnRide; // 0x40 // The next vehicle on the same train or the first vehicle on the next or only train - uint16_t next_vehicle_on_ride; // 0x42 + uint16_t NextVehicleOnRide; // 0x42 - uint16_t var_44; - uint16_t mass; // 0x46 - uint16_t update_flags; // 0x48 + 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 }; }; int16_t SwingSpeed; - 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 0 == Close, 255 == Open - int16_t spin_speed; - uint16_t sound2_flags; - uint8_t spin_sprite; - 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; + 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 0 == Close, 255 == Open + int16_t SpinSpeed; + uint16_t Sound2Flags; + uint8_t SpinSprite; + uint8_t Sound1ID; // 0xBB + uint8_t Sound1Volume; // 0xBC + uint8_t Sound2ID; // 0xBD + uint8_t Sound2Volume; // 0xBE + int8_t SoundVectorFactor; union { - uint16_t var_C0; - uint16_t time_waiting; // 0xC0 - uint16_t cable_lift_target; // 0xC0 + uint16_t VarC0; + 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 DodgemsCollisionDetection; // 0xC4 uint8_t CollisionDetectionTimer; // 0xC4 }; - uint8_t animation_frame; - uint8_t pad_C6[0x2]; - uint32_t animationState; - uint8_t scream_sound_id; // 0xCC + uint8_t AnimationFrame; + uint8_t PadC6[0x2]; + 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 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 uint16_t GetTrackType() const { @@ -437,174 +437,174 @@ namespace RCT1 struct Peep : RCT12SpriteBase { - uint8_t pad_1F[3]; - 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 - PeepSpriteType sprite_type; // 0x2D - uint8_t type; // 0x2E + uint8_t Pad1F[3]; + StringId NameStringID; // 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 + PeepSpriteType SpriteType; // 0x2D + RCT12PeepType PeepType; // 0x2E union { - uint8_t staff_type; // 0x2F - uint8_t no_of_rides; // 0x2F + uint8_t StaffType; // 0x2F + uint8_t NumRides; // 0x2F }; - uint8_t tshirt_colour; // 0x30 - uint8_t trousers_colour; // 0x31 - uint16_t destination_x; // 0x32 Location that the peep is trying to get to - uint16_t destination_y; // 0x34 - uint8_t destination_tolerance; // 0x36 How close to destination before next action/state 0 = exact - 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; - 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 nausea_tolerance; // 0x44 - uint8_t window_invalidate_flags; // 0x45 - money16 paid_on_drink; // 0x46 - uint8_t ride_types_been_on[16]; // 0x48 - uint8_t pad_5F[0x10]; // 0x58 - 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 Location that the peep is trying to get to + uint16_t DestinationY; // 0x34 + uint8_t DestinationTolerance; // 0x36 How close to destination before next action/state 0 = exact + 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; + 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 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 }; }; // Normally 0, 1 for carrying sliding board on spiral slide ride, 2 for carrying lawn mower - uint8_t special_sprite; // 0x6D - uint8_t action_sprite_type; // 0x6E + uint8_t SpecialSprite; // 0x6D + uint8_t ActionSpriteType; // 0x6E // Seems to be used like a local variable, as it's always set before calling SwitchNextActionSpriteType, which reads // this again - 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; + uint8_t NextActionSpriteType; // 0x6F + uint8_t ActionSpriteImageOffset; // 0x70 + uint8_t Action; // 0x71 + uint8_t ActionFrame; // 0x72 + uint8_t StepProgress; union { - uint16_t mechanic_time_since_call; // time getting to ride to fix - uint16_t next_in_queue; // 0x74 + uint16_t MechanicTimeSinceCall; // time getting to ride to fix + uint16_t NextInQueue; // 0x74 }; - uint8_t pad_76; - uint8_t pad_77; + uint8_t Pad76; + uint8_t Pad77; union { - uint8_t maze_last_edge; // 0x78 - uint8_t direction; // Direction ? + uint8_t MazeLastEdge; // 0x78 + uint8_t Direction; // Direction ? }; - RCT12RideId interaction_ride_index; - uint16_t time_in_queue; // 0x7A + RCT12RideId InteractionRideIndex; + uint16_t TimeInQueue; // 0x7A uint8_t rides_been_on[32]; // 0x7C // 255 bit bitmap of every ride the peep has been on see - // window_peep_rides_update for how to use. - 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 pad_C4; + // WindowPeepRidesUpdate for how to use. + 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 PadC4; 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 - rct12_xyzd8 pathfind_goal; // 0xCC - rct12_xyzd8 pathfind_history[4]; // 0xD0 - uint8_t no_action_frame_num; // 0xE0 + RCT12RideId Photo1RideRef; // 0xC7 + uint32_t PeepFlags; // 0xC8 + rct12_xyzd8 PathfindGoal; // 0xCC + rct12_xyzd8 PathfindHistory[4]; // 0xD0 + uint8_t NoActionFrameNum; // 0xE0 // 0x3F Litter Count split into lots of 3 with time, 0xC0 Time since last recalc - uint8_t litter_count; // 0xE1 + 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 }; // 0x3F Sick Count split into lots of 3 with time, 0xC0 Time since last recalc - uint8_t disgusting_count; // 0xE3 - money16 paid_to_enter; // 0xE4 - money16 paid_on_rides; // 0xE6 - money16 paid_on_food; // 0xE8 - money16 paid_on_souvenirs; // 0xEA - uint8_t no_of_food; // 0xEC - uint8_t no_of_drinks; // 0xED - uint8_t no_of_souvenirs; // 0xEE - uint8_t vandalism_seen; // 0xEF - 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; - 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 pad_FB; - uint32_t item_standard_flags; // 0xFC + uint8_t DisgustingCount; // 0xE3 + money16 PaidToEnter; // 0xE4 + money16 PaidOnRides; // 0xE6 + money16 PaidOnFood; // 0xE8 + money16 PaidOnSouvenirs; // 0xEA + uint8_t NumFood; // 0xEC + uint8_t NumDrinks; // 0xED + uint8_t NumSouvenirs; // 0xEE + uint8_t VandalismSeen; // 0xEF + uint8_t VoucherType; // 0xF0 + RCT12RideId VoucherArguments; // 0xF1 RideID or StringOffsetID + uint8_t SurroundingsThoughtTimeout; // 0xF2 + uint8_t Angriness; // 0xF3 + uint8_t TimeLost; + 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 ItemStandardFlags; // 0xFC uint64_t GetItemFlags() const { - return item_standard_flags; + return ItemStandardFlags; } }; assert_struct_size(Peep, 0x100); union Entity { - uint8_t pad_00[0x100]; - UnkEntity unknown; - Vehicle vehicle; - Peep peep; - RCT12SpriteLitter litter; - RCT12SpriteBalloon balloon; - RCT12SpriteDuck duck; - RCT12SpriteJumpingFountain jumping_fountain; - RCT12SpriteMoneyEffect money_effect; - RCT12SpriteCrashedVehicleParticle crashed_vehicle_particle; - RCT12SpriteCrashSplash crash_splash; - RCT12SpriteSteamParticle steam_particle; + uint8_t Pad00[0x100]; + UnkEntity Unknown; + RCT1::Vehicle Vehicle; + RCT1::Peep Peep; + RCT12SpriteLitter Litter; + RCT12SpriteBalloon Balloon; + RCT12SpriteDuck Duck; + RCT12SpriteJumpingFountain JumpingFountain; + RCT12SpriteMoneyEffect MoneyEffect; + RCT12SpriteCrashedVehicleParticle CrashedVehicleParticle; + RCT12SpriteCrashSplash CrashSplash; + RCT12SpriteSteamParticle SteamParticle; }; assert_struct_size(Entity, 0x100); struct ResearchItem { - uint8_t item; - uint8_t related_ride; - uint8_t type; - uint8_t flags; - uint8_t category; + uint8_t Item; + uint8_t RelatedRide; + uint8_t Type; + uint8_t Flags; + uint8_t Category; }; assert_struct_size(ResearchItem, 5); @@ -614,174 +614,174 @@ namespace RCT1 */ struct S4 { - uint16_t month; - uint16_t day; - uint32_t ticks; - uint32_t random_a; - uint32_t random_b; - RCT12TileElement tile_elements[Limits::MaxTileElements]; - uint32_t unk_counter; - Entity sprites[Limits::MaxEntities]; - uint16_t next_sprite_index; - uint16_t first_vehicle_sprite_index; - uint16_t first_peep_sprite_index; - uint16_t first_duck_sprite_index; - uint16_t first_litter_sprite_index; - uint16_t first_oversized_ride_car_sprite_index; - uint16_t sprites_available; - uint16_t num_vehicle_sprites; - uint16_t num_peep_sprites; - uint16_t num_duck_sprites; - uint16_t num_litter_sprites; - uint16_t num_oversized_ride_car_sprites; - uint32_t park_name_string_index; - uint32_t unk_198830; - money32 cash; - money32 loan; - uint32_t park_flags; - money16 park_entrance_fee; - Entrance park_entrance; - uint8_t unk_198849; - rct12_peep_spawn peep_spawn[Limits::MaxPeepSpawns]; - uint8_t unk_198856; - uint8_t research_level; - uint32_t unk_198858; - uint32_t available_rides[8]; - uint32_t available_vehicles[8]; - uint32_t ride_feature_1[128]; - uint32_t ride_feature_2[128]; - uint16_t guests_in_park; - uint16_t unk_198C9E; - money32 expenditure[Limits::ExpenditureTableMonthCount][Limits::ExpenditureTypeCount]; - uint32_t guests_in_park_2; - uint8_t unk_199024; - colour_t handman_colour; - colour_t mechanic_colour; - colour_t security_guard_colour; - uint8_t available_scenery[128]; - uint16_t available_banners; - uint8_t unk_1990AA[94]; - uint16_t park_rating; - uint8_t park_rating_history[32]; - uint8_t guests_in_park_history[32]; - uint8_t research_priority; - uint8_t research_progress_stage; - uint8_t last_research_item; - uint8_t last_research_ride; - uint8_t last_research_type; - uint8_t last_research_flags; - ResearchItem research_items[200]; - uint8_t next_research_item; - uint8_t next_research_ride; - uint8_t next_research_type; - uint8_t next_research_flags; - 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; - money16 total_ride_value_for_money; - money32 max_loan; - money16 guest_initial_cash; - uint8_t guest_initial_hunger; - uint8_t guest_initial_thirst; - uint8_t scenario_objective_type; - uint8_t scenario_objective_years; - uint16_t unk_199552; - money32 scenario_objective_currency; - uint16_t scenario_objective_num_guests; - uint8_t marketing_status[20]; - uint8_t marketing_assoc[20]; - uint8_t unk_199582[2]; - money32 cash_history[Limits::FinanceGraphSize]; - money32 total_expenditure; - money32 profit; - uint8_t unk_199788[8]; - money32 weekly_profit_history[Limits::FinanceGraphSize]; - money32 park_value; - money32 park_value_history[Limits::FinanceGraphSize]; - money32 completed_company_value; - uint32_t num_admissions; - money32 admission_total_income; - money32 company_value; - uint8_t thought_timer[16]; - rct12_award awards[Limits::MaxAwards]; - money16 land_price; - money16 construction_rights_price; - uint16_t unk_199BCC; - uint16_t unk_199BCE; - uint32_t unk_199BD0; + uint16_t Month; + uint16_t Day; + uint32_t Ticks; + uint32_t RandomA; + uint32_t RandomB; + RCT12TileElement TileElements[Limits::MaxTileElements]; + uint32_t UnkCounter; + Entity Entities[Limits::MaxEntities]; + uint16_t NextEntityIndex; + uint16_t FirstVehicleEntityIndex; + uint16_t FirstPeepEntityIndex; + uint16_t FirstDuckEntityIndex; + uint16_t FirstLitterEntityIndex; + uint16_t FirstOversizedRideCarEntityIndex; + uint16_t EntitiesAvailable; + uint16_t NumVehicleEntities; + uint16_t NumPeepEntities; + uint16_t NumDuckEntities; + uint16_t NumLitterEntities; + uint16_t NumOversizedRideCarEntities; + uint32_t ParkNameStringIndex; + uint32_t Unk198830; + money32 Cash; + money32 Loan; + uint32_t ParkFlags; + money16 ParkEntranceFee; + Entrance ParkEntrance; + uint8_t Unk198849; + rct12_peep_spawn PeepSpawn[Limits::MaxPeepSpawns]; + uint8_t Unk198856; + uint8_t ResearchLevel; + uint32_t Unk198858; + uint32_t AvailableRides[8]; + uint32_t AvailableVehicles[8]; + uint32_t RideFeature1[128]; + uint32_t RideFeature2[128]; + uint16_t GuestsInPark; + uint16_t Unk198C9E; + money32 Expenditure[Limits::ExpenditureTableMonthCount][Limits::ExpenditureTypeCount]; + uint32_t GuestsInPark2; + uint8_t Unk199024; + colour_t HandymanColour; + colour_t MechanicColour; + colour_t SecurityGuardColour; + uint8_t AvailableScenery[128]; + uint16_t AvailableBanners; + uint8_t Unk1990AA[94]; + uint16_t ParkRating; + uint8_t ParkRatingHistory[32]; + uint8_t GuestsInParkHistory[32]; + uint8_t ResearchPriority; + uint8_t ResearchProgressStage; + uint8_t LastResearchItem; + uint8_t LastResearchRide; + uint8_t LastResearchType; + uint8_t LastResearchFlags; + ResearchItem ResearchItems[200]; + uint8_t NextResearchItem; + uint8_t NextResearchRide; + uint8_t NextResearchType; + uint8_t NextResearchFlags; + uint16_t ResearchProgress; + uint8_t NextResearchCategory; + uint8_t NextResearchExpectedDay; + uint8_t NextResearchExpectedMonth; + uint8_t GuestInitialHappiness; + uint16_t ParkSize; + uint16_t GuestGenerationProbability; + money16 TotalRideValueForMoney; + money32 MaxLoan; + money16 GuestInitialCash; + uint8_t GuestInitialHunger; + uint8_t GuestInitialThirst; + uint8_t ScenarioObjectiveType; + uint8_t ScenarioObjectiveYears; + uint16_t Unk199552; + money32 ScenarioObjectiveCurrency; + uint16_t ScenarioObjectiveNumGuests; + uint8_t MarketingStatus[20]; + uint8_t MarketingAssoc[20]; + uint8_t Unk199582[2]; + money32 CashHistory[Limits::FinanceGraphSize]; + money32 TotalExpenditure; + money32 Profit; + uint8_t Unk199788[8]; + money32 WeeklyProfitHistory[Limits::FinanceGraphSize]; + money32 ParkValue; + money32 ParkValueHistory[Limits::FinanceGraphSize]; + money32 CompletedCompanyValue; + uint32_t NumAdmissions; + money32 AdmissionTotalIncome; + money32 CompanyValue; + uint8_t ThoughtTimer[16]; + rct12_award Awards[Limits::MaxAwards]; + money16 LandPrice; + money16 ConstructionRightsPrice; + uint16_t Unk199BCC; + uint16_t Unk199BCE; + uint32_t Unk199BD0; char username[64]; - uint32_t game_version; - money32 objective_completion_company_value; - uint32_t finance_checksum; - uint16_t num_rides; - uint16_t cheat_detection_neg_num_rides; - uint16_t cheat_detection_max_owned_tiles; - uint16_t cheat_detection_neg_max_owned_tiles; - uint32_t finance_checksum_3; - uint32_t scenario_slot_index_checksum; - char scenario_winner[32]; - uint32_t finance_checksum_2; - char copyright_notice[40]; - uint16_t cheat_detection_sv6_sc4[4]; - uint16_t unk_199C84; - uint16_t unk_199C86; - uint16_t map_size_units; - uint16_t map_size_unk_b; - uint16_t map_size; - uint16_t map_size_max_xy; - uint32_t same_price_throughout; - uint16_t unk_199C94; - uint8_t unk_199C96[3]; - uint8_t water_colour; - uint16_t unk_199C9A; - ResearchItem research_items_LL[180]; - uint8_t unk_19A020[5468]; - RCT12Banner banners[Limits::MaxBanners]; - char string_table[Limits::MaxUserStrings][Limits::MaxUserStringLength]; - uint32_t game_time_counter; - Ride rides[Limits::MaxRidesInPark]; - uint16_t unk_game_time_counter; - int16_t view_x; - int16_t view_y; - uint8_t view_zoom; - uint8_t view_rotation; - RCT12MapAnimation map_animations[Limits::MaxAnimatedObjects]; - uint32_t num_map_animations; - uint8_t unk_1CADBC[12]; - uint16_t scrolling_text_step; - uint32_t unk_1CADCA; - uint16_t unk_1CADCE; - uint8_t unk_1CADD0[116]; - RCT12RideMeasurement ride_measurements[8]; - uint32_t next_guest_index; - uint16_t game_counter_5; - uint8_t patrol_areas[(Limits::MaxStaff + Limits::StaffTypeCount) * Limits::PatrolAreaSize]; - uint8_t staff_modes[Limits::MaxStaff]; - uint8_t unk_1F431E[4]; - uint8_t unk_1F4322[8]; - uint8_t climate; - uint8_t unk_1F432B; - uint16_t climate_timer; - uint8_t weather; - uint8_t target_weather; - uint8_t temperature; - uint8_t target_temperature; - uint8_t thunder_frequency; - uint8_t target_thunder_frequency; - uint8_t weather_gloom; - uint8_t target_weather_gloom; - uint8_t rain; - uint8_t target_rain; - rct12_news_item messages[Limits::MaxNewsItems]; - char scenario_name[62]; - uint16_t scenario_slot_index; - uint32_t scenario_flags; - uint8_t unk_1F8358[432]; - uint32_t expansion_pack_checksum; + uint32_t GameVersion; + money32 ObjectiveCompletionCompanyValue; + uint32_t FinanceChecksum; + uint16_t NumRides; + uint16_t CheatDetectionNegNumRides; + uint16_t CheatDetectionMaxOwnedTiles; + uint16_t CheatDetectionNegMaxOwnedTiles; + uint32_t FinanceChecksum3; + uint32_t ScenarioSlotIndexChecksum; + char ScenarioWinner[32]; + uint32_t FinanceChecksum2; + char CopyrightNotice[40]; + uint16_t CheatDetectionSV6SC4[4]; + uint16_t Unk199C84; + uint16_t Unk199C86; + uint16_t MapSizeUnits; + uint16_t MapSizeUnkB; + uint16_t MapSize; + uint16_t MapSizeMaxXY; + uint32_t SamePriceThroughout; + uint16_t Unk199C94; + uint8_t Unk199C96[3]; + uint8_t WaterColour; + uint16_t Unk199C9A; + ResearchItem ResearchItemsLL[180]; + uint8_t Unk19A020[5468]; + RCT12Banner Banners[Limits::MaxBanners]; + char StringTable[Limits::MaxUserStrings][Limits::MaxUserStringLength]; + uint32_t GameTimeCounter; + Ride Rides[Limits::MaxRidesInPark]; + uint16_t UnkGameTimeCounter; + int16_t ViewX; + int16_t ViewY; + uint8_t ViewZoom; + uint8_t ViewRotation; + RCT12MapAnimation MapAnimations[Limits::MaxAnimatedObjects]; + uint32_t NumMapAnimations; + uint8_t Unk1CADBC[12]; + uint16_t ScrollingTextStep; + uint32_t Unk1CADCA; + uint16_t Unk1CADCE; + uint8_t Unk1CADD0[116]; + RCT12RideMeasurement RideMeasurements[8]; + uint32_t NextGuestIndex; + uint16_t GameCounter5; + uint8_t PatrolAreas[(Limits::MaxStaff + Limits::StaffTypeCount) * Limits::PatrolAreaSize]; + uint8_t StaffModes[Limits::MaxStaff]; + uint8_t Unk1F431E[4]; + uint8_t Unk1F4322[8]; + uint8_t Climate; + uint8_t Unk1F432B; + uint16_t ClimateTimer; + uint8_t Weather; + uint8_t TargetWeather; + uint8_t Temperature; + uint8_t TargetTemperature; + uint8_t ThunderFrequency; + uint8_t TargetThunderFrequency; + uint8_t WeatherGloom; + uint8_t TargetWeatherGloom; + uint8_t Rain; + uint8_t TargetRain; + rct12_news_item Messages[Limits::MaxNewsItems]; + char ScenarioName[62]; + uint16_t ScenarioSlotIndex; + uint32_t ScenarioFlags; + uint8_t Unk1F8358[432]; + uint32_t ExpansionPackChecksum; }; assert_struct_size(S4, 0x1F850C); @@ -791,44 +791,44 @@ namespace RCT1 */ struct TD4 { - RideType type; // 0x00 - uint8_t vehicle_type; - uint32_t flags; // 0x02 - uint8_t mode; // 0x06 - uint8_t version_and_colour_scheme; // 0x07 0b0000_VVCC - RCT12VehicleColour vehicle_colours[Limits::MaxTrainsPerRide]; // 0x08 - uint8_t track_spine_colour_v0; // 0x20 - uint8_t track_rail_colour_v0; // 0x21 - uint8_t track_support_colour_v0; // 0x22 - uint8_t depart_flags; // 0x23 - uint8_t number_of_trains; // 0x24 - uint8_t number_of_cars_per_train; // 0x25 - uint8_t min_waiting_time; // 0x26 - uint8_t max_waiting_time; // 0x27 + RideType Type; // 0x00 + uint8_t VehicleType; + uint32_t Flags; // 0x02 + uint8_t Mode; // 0x06 + uint8_t VersionAndColourScheme; // 0x07 0b0000_VVCC + RCT12VehicleColour VehicleColours[Limits::MaxTrainsPerRide]; // 0x08 + uint8_t TrackSpineColourV0; // 0x20 + uint8_t TrackRailColourV0; // 0x21 + uint8_t TrackSupportColourV0; // 0x22 + uint8_t DepartFlags; // 0x23 + uint8_t NumberOfTrains; // 0x24 + uint8_t NumberOfCarsPerTrain; // 0x25 + uint8_t MinWaitingTime; // 0x26 + uint8_t MaxWaitingTime; // 0x27 union { - uint8_t operation_setting; - uint8_t launch_speed; + uint8_t OperationSetting; + uint8_t LaunchSpeed; uint8_t NumLaps; - uint8_t max_people; + uint8_t MaxPeople; }; - int8_t max_speed; // 0x29 - int8_t average_speed; // 0x2A - uint16_t ride_length; // 0x2B - uint8_t max_positive_vertical_g; // 0x2D - int8_t max_negative_vertical_g; // 0x2C - uint8_t max_lateral_g; // 0x2F + int8_t MaxSpeed; // 0x29 + int8_t AverageSpeed; // 0x2A + uint16_t RideLength; // 0x2B + uint8_t MaxPositiveVerticalG; // 0x2D + int8_t MaxNegativeVerticalG; // 0x2C + uint8_t MaxLateralG; // 0x2F union { - uint8_t num_inversions; // 0x30 - uint8_t num_holes; // 0x30 + uint8_t NumInversions; // 0x30 + uint8_t NumHoles; // 0x30 }; - uint8_t num_drops; // 0x31 - uint8_t highest_drop_height; // 0x32 - uint8_t excitement; // 0x33 - uint8_t intensity; // 0x34 - uint8_t nausea; // 0x35 - money16 upkeep_cost; // 0x36 + uint8_t NumDrops; // 0x31 + uint8_t HighestDropHeight; // 0x32 + uint8_t Excitement; // 0x33 + uint8_t Intensity; // 0x34 + uint8_t Nausea; // 0x35 + money16 UpkeepCost; // 0x36 }; assert_struct_size(TD4, 0x38); @@ -839,12 +839,12 @@ namespace RCT1 */ struct TD4AA : public TD4 { - uint8_t track_spine_colour[Limits::NumColourSchemes]; // 0x38 - uint8_t track_rail_colour[Limits::NumColourSchemes]; // 0x3C - uint8_t track_support_colour[Limits::NumColourSchemes]; // 0x40 - uint8_t flags2; // 0x44 + uint8_t TrackSpineColour[Limits::NumColourSchemes]; // 0x38 + uint8_t TrackRailColour[Limits::NumColourSchemes]; // 0x3C + uint8_t TrackSupportColour[Limits::NumColourSchemes]; // 0x40 + uint8_t Flags2; // 0x44 - uint8_t pad_45[0x7F]; // 0x45 + uint8_t Pad45[0x7F]; // 0x45 }; assert_struct_size(TD4AA, 0xC4); diff --git a/src/openrct2/rct1/S4Importer.cpp b/src/openrct2/rct1/S4Importer.cpp index d8ade35abe..29aff13f8b 100644 --- a/src/openrct2/rct1/S4Importer.cpp +++ b/src/openrct2/rct1/S4Importer.cpp @@ -77,7 +77,7 @@ #include #include -static constexpr const ObjectEntryIndex OBJECT_ENTRY_INDEX_IGNORE = 254; +static constexpr const ObjectEntryIndex ObjectEntryIndexIgnore = 254; using namespace OpenRCT2; @@ -163,7 +163,7 @@ namespace RCT1 _s4 = *ReadAndDecodeS4(stream, isScenario); _s4Path = path; _isScenario = isScenario; - _gameVersion = SawyerCodingDetectRCT1Version(_s4.game_version) & FILE_VERSION_MASK; + _gameVersion = SawyerCodingDetectRCT1Version(_s4.GameVersion) & FILE_VERSION_MASK; // Only determine what objects we required to import this saved game InitialiseEntryMaps(); @@ -209,28 +209,28 @@ namespace RCT1 source_desc desc; // If no entry is found, this is a custom scenario. - bool isOfficial = ScenarioSources::TryGetById(_s4.scenario_slot_index, &desc); + bool isOfficial = ScenarioSources::TryGetById(_s4.ScenarioSlotIndex, &desc); dst->category = desc.category; dst->source_game = ScenarioSource{ desc.source }; dst->source_index = desc.index; dst->sc_id = desc.id; - dst->objective_type = _s4.scenario_objective_type; - dst->objective_arg_1 = _s4.scenario_objective_years; + dst->objective_type = _s4.ScenarioObjectiveType; + dst->objective_arg_1 = _s4.ScenarioObjectiveYears; // RCT1 used another way of calculating park value. - if (_s4.scenario_objective_type == OBJECTIVE_PARK_VALUE_BY) - dst->objective_arg_2 = CorrectRCT1ParkValue(_s4.scenario_objective_currency); + if (_s4.ScenarioObjectiveType == OBJECTIVE_PARK_VALUE_BY) + dst->objective_arg_2 = CorrectRCT1ParkValue(_s4.ScenarioObjectiveCurrency); else - dst->objective_arg_2 = _s4.scenario_objective_currency; - dst->objective_arg_3 = _s4.scenario_objective_num_guests; + dst->objective_arg_2 = _s4.ScenarioObjectiveCurrency; + dst->objective_arg_3 = _s4.ScenarioObjectiveNumGuests; // This does not seem to be saved in the objective arguments, so look up the ID from the available rides instead. - if (_s4.scenario_objective_type == OBJECTIVE_BUILD_THE_BEST) + if (_s4.ScenarioObjectiveType == OBJECTIVE_BUILD_THE_BEST) { dst->objective_arg_3 = GetBuildTheBestRideId(); } - auto name = RCT2StringToUTF8(_s4.scenario_name, RCT2LanguageId::EnglishUK); + auto name = RCT2StringToUTF8(_s4.ScenarioName, RCT2LanguageId::EnglishUK); std::string details; // TryGetById won't set this property if the scenario is not recognised, @@ -270,12 +270,12 @@ namespace RCT1 if (_parkValueConversionFactor == 0) { - if (_s4.park_value != 0) + if (_s4.ParkValue != 0) { // Use the ratio between the old and new park value to calcute the ratio to // use for the park value history and the goal. auto& park = GetContext()->GetGameState()->GetPark(); - _parkValueConversionFactor = (park.CalculateParkValue() * 10) / _s4.park_value; + _parkValueConversionFactor = (park.CalculateParkValue() * 10) / _s4.ParkValue; } else { @@ -320,7 +320,7 @@ namespace RCT1 // Avoid reusing the value used for last import _parkValueConversionFactor = 0; - uint16_t mapSize = _s4.map_size == 0 ? Limits::MaxMapSize : _s4.map_size; + uint16_t mapSize = _s4.MapSize == 0 ? Limits::MaxMapSize : _s4.MapSize; gScenarioFileName = GetRCT1ScenarioName(); @@ -334,7 +334,7 @@ namespace RCT1 std::string GetRCT1ScenarioName() { - const scenario_index_entry* scenarioEntry = _scenarioRepository->GetByInternalName(_s4.scenario_name); + const scenario_index_entry* scenarioEntry = _scenarioRepository->GetByInternalName(_s4.ScenarioName); if (scenarioEntry == nullptr) { return ""; @@ -429,33 +429,33 @@ namespace RCT1 { const ResearchItem* researchItem = &researchList[i]; - if (researchItem->flags == RCT1_RESEARCH_FLAGS_SEPARATOR) + if (researchItem->Flags == RCT1ResearchFlagsSeparator) { - if (researchItem->item == RCT1_RESEARCH_END) + if (researchItem->Item == RCT1_RESEARCH_END) { break; } - if (researchItem->item == RCT1_RESEARCH_END_AVAILABLE - || researchItem->item == RCT1_RESEARCH_END_RESEARCHABLE) + if (researchItem->Item == RCT1_RESEARCH_END_AVAILABLE + || researchItem->Item == RCT1_RESEARCH_END_RESEARCHABLE) { continue; } } - switch (researchItem->type) + switch (researchItem->Type) { case RCT1_RESEARCH_TYPE_THEME: - AddEntriesForSceneryTheme(researchItem->item); + AddEntriesForSceneryTheme(researchItem->Item); break; case RCT1_RESEARCH_TYPE_RIDE: - AddEntryForRideType(static_cast(researchItem->item)); + AddEntryForRideType(static_cast(researchItem->Item)); break; case RCT1_RESEARCH_TYPE_VEHICLE: // For some bizarre reason, RCT1 research lists contain vehicles that aren't actually researched. // Extra bizarrely, this does not seem to apply to Loopy Landscapes saves/scenarios. - if (rideTypeInResearch[researchItem->related_ride] || _gameVersion == FILE_VERSION_RCT1_LL) + if (rideTypeInResearch[researchItem->RelatedRide] || _gameVersion == FILE_VERSION_RCT1_LL) { - AddEntryForVehicleType(static_cast(researchItem->related_ride), researchItem->item); + AddEntryForVehicleType(static_cast(researchItem->RelatedRide), researchItem->Item); } break; } @@ -466,7 +466,7 @@ namespace RCT1 { size_t maxTiles = Limits::MaxMapSize * Limits::MaxMapSize; size_t tileIndex = 0; - RCT12TileElement* tileElement = _s4.tile_elements; + RCT12TileElement* tileElement = _s4.TileElements; while (tileIndex < maxTiles) { @@ -528,15 +528,15 @@ namespace RCT1 void AddAvailableEntriesFromRides() { - for (size_t i = 0; i < std::size(_s4.rides); i++) + for (size_t i = 0; i < std::size(_s4.Rides); i++) { - auto ride = &_s4.rides[i]; - if (ride->type != RideType::Null) + auto ride = &_s4.Rides[i]; + if (ride->Type != RideType::Null) { - if (RCT1::RideTypeUsesVehicles(ride->type)) - AddEntryForVehicleType(ride->type, ride->vehicle_type); + if (RCT1::RideTypeUsesVehicles(ride->Type)) + AddEntryForVehicleType(ride->Type, ride->VehicleType); else - AddEntryForRideType(ride->type); + AddEntryForRideType(ride->Type); } } } @@ -596,7 +596,7 @@ namespace RCT1 } else { - entryName = RCT1::GetWaterObject(_s4.water_colour); + entryName = RCT1::GetWaterObject(_s4.WaterColour); } _waterEntry.GetOrAddEntry(entryName); } @@ -709,7 +709,7 @@ namespace RCT1 if (sceneryThemeType == RCT1_SCENERY_THEME_GENERAL || sceneryThemeType == RCT1_SCENERY_THEME_JUMPING_FOUNTAINS || sceneryThemeType == RCT1_SCENERY_THEME_GARDEN_CLOCK) { - _sceneryThemeTypeToEntryMap[sceneryThemeType] = OBJECT_ENTRY_INDEX_IGNORE; + _sceneryThemeTypeToEntryMap[sceneryThemeType] = ObjectEntryIndexIgnore; } else { @@ -774,10 +774,10 @@ namespace RCT1 { for (int32_t i = 0; i < Limits::MaxRidesInPark; i++) { - if (_s4.rides[i].type != RideType::Null) + if (_s4.Rides[i].Type != RideType::Null) { const auto rideId = RideId::FromUnderlying(i); - ImportRide(GetOrAllocateRide(rideId), &_s4.rides[i], rideId); + ImportRide(GetOrAllocateRide(rideId), &_s4.Rides[i], rideId); } } } @@ -788,22 +788,22 @@ namespace RCT1 dst->id = rideIndex; // This is a peculiarity of this exact version number, which only Heide-Park seems to use. - if (_s4.game_version == 110018 && src->type == RideType::InvertedRollerCoaster) + if (_s4.GameVersion == 110018 && src->Type == RideType::InvertedRollerCoaster) { dst->type = RIDE_TYPE_COMPACT_INVERTED_COASTER; } else { - dst->type = RCT1::GetRideType(src->type, src->vehicle_type); + dst->type = RCT1::GetRideType(src->Type, src->VehicleType); } - if (RCT1::RideTypeUsesVehicles(src->type)) + if (RCT1::RideTypeUsesVehicles(src->Type)) { - dst->subtype = _vehicleTypeToRideEntryMap[src->vehicle_type]; + dst->subtype = _vehicleTypeToRideEntryMap[src->VehicleType]; } else { - dst->subtype = _rideTypeToRideEntryMap[EnumValue(src->type)]; + dst->subtype = _rideTypeToRideEntryMap[EnumValue(src->Type)]; } rct_ride_entry* rideEntry = GetRideEntryByIndex(dst->subtype); @@ -816,15 +816,15 @@ namespace RCT1 } // Ride name - if (IsUserStringID(src->name)) + if (IsUserStringID(src->Name)) { - dst->custom_name = GetUserString(src->name); + dst->custom_name = GetUserString(src->Name); } - dst->status = static_cast(src->status); + dst->status = static_cast(src->Status); // Flags - dst->lifecycle_flags = src->lifecycle_flags; + dst->lifecycle_flags = src->LifecycleFlags; // These flags were not in the base game if (_gameVersion == FILE_VERSION_RCT1) { @@ -834,50 +834,50 @@ namespace RCT1 } // Station - if (src->overall_view.IsNull()) + if (src->OverallView.IsNull()) { dst->overall_view.SetNull(); } else { - dst->overall_view = TileCoordsXY{ src->overall_view.x, src->overall_view.y }.ToCoordsXY(); + dst->overall_view = TileCoordsXY{ src->OverallView.x, src->OverallView.y }.ToCoordsXY(); } for (StationIndex::UnderlyingType i = 0; i < Limits::MaxStationsPerRide; i++) { auto& dstStation = dst->GetStation(StationIndex::FromUnderlying(i)); - if (src->station_starts[i].IsNull()) + if (src->StationStarts[i].IsNull()) { dstStation.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 }; dstStation.Start = tileStartLoc.ToCoordsXY(); } - dstStation.SetBaseZ(src->station_height[i] * Limits::CoordsZStep); - dstStation.Length = src->station_length[i]; - dstStation.Depart = src->station_light[i]; + dstStation.SetBaseZ(src->StationHeights[i] * Limits::CoordsZStep); + dstStation.Length = src->StationLengths[i]; + dstStation.Depart = src->StationLights[i]; - dstStation.TrainAtStation = src->station_depart[i]; + dstStation.TrainAtStation = src->StationDeparts[i]; // Direction is fixed later. - if (src->entrance[i].IsNull()) + if (src->Entrances[i].IsNull()) dstStation.Entrance.SetNull(); else - dstStation.Entrance = { src->entrance[i].x, src->entrance[i].y, src->station_height[i] / 2, 0 }; + dstStation.Entrance = { src->Entrances[i].x, src->Entrances[i].y, src->StationHeights[i] / 2, 0 }; - if (src->exit[i].IsNull()) + if (src->Exits[i].IsNull()) dstStation.Exit.SetNull(); else - dstStation.Exit = { src->exit[i].x, src->exit[i].y, src->station_height[i] / 2, 0 }; + dstStation.Exit = { src->Exits[i].x, src->Exits[i].y, src->StationHeights[i] / 2, 0 }; - dstStation.QueueTime = src->queue_time[i]; - dstStation.LastPeepInQueue = EntityId::FromUnderlying(src->last_peep_in_queue[i]); - dstStation.QueueLength = src->num_peeps_in_queue[i]; + dstStation.QueueTime = src->QueueTime[i]; + dstStation.LastPeepInQueue = EntityId::FromUnderlying(src->LastPeepInQueue[i]); + dstStation.QueueLength = src->NumPeepsInQueue[i]; - dstStation.SegmentTime = src->time[i]; - dstStation.SegmentLength = src->length[i]; + dstStation.SegmentTime = src->Time[i]; + dstStation.SegmentLength = src->Length[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++) @@ -890,12 +890,12 @@ namespace RCT1 dstStation.LastPeepInQueue = EntityId::GetNull(); } - dst->num_stations = src->num_stations; + dst->num_stations = src->NumStations; // Vehicle links (indexes converted later) 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; i <= OpenRCT2::Limits::MaxTrainsPerRide; i++) { @@ -903,19 +903,19 @@ namespace RCT1 } dst->NumTrains = src->NumTrains; - dst->num_cars_per_train = src->num_cars_per_train + rideEntry->zero_cars; + dst->num_cars_per_train = src->NumCarsPerTrain + rideEntry->zero_cars; dst->ProposedNumTrains = src->NumTrains; - dst->max_trains = src->max_trains; - dst->proposed_num_cars_per_train = src->num_cars_per_train + rideEntry->zero_cars; - dst->special_track_elements = src->special_track_elements; - dst->num_sheltered_sections = src->num_sheltered_sections; - dst->sheltered_length = src->sheltered_length; + dst->max_trains = src->MaxTrains; + dst->proposed_num_cars_per_train = src->NumCarsPerTrain + rideEntry->zero_cars; + dst->special_track_elements = src->SpecialTrackElements; + dst->num_sheltered_sections = src->NumShelteredSections; + dst->sheltered_length = src->ShelteredLength; // Operation - dst->depart_flags = src->depart_flags; - dst->min_waiting_time = src->min_waiting_time; - dst->max_waiting_time = src->max_waiting_time; - dst->operation_option = src->operation_option; + dst->depart_flags = src->DepartFlags; + dst->min_waiting_time = src->MinWaitingTime; + dst->max_waiting_time = src->MaxWaitingTime; + dst->operation_option = src->OperationOption; dst->num_circuits = 1; dst->MinCarsPerTrain = rideEntry->min_cars_in_train; dst->MaxCarsPerTrain = rideEntry->max_cars_in_train; @@ -937,9 +937,9 @@ namespace RCT1 // Only merry-go-round and dodgems had music and used // the same flag as synchronise stations for the option to enable it - if (src->type == RideType::MerryGoRound || src->type == RideType::Dodgems) + if (src->Type == RideType::MerryGoRound || src->Type == RideType::Dodgems) { - if (src->depart_flags & RCT1_RIDE_DEPART_PLAY_MUSIC) + if (src->DepartFlags & RCT1_RIDE_DEPART_PLAY_MUSIC) { dst->depart_flags &= ~RCT1_RIDE_DEPART_PLAY_MUSIC; dst->lifecycle_flags |= RIDE_LIFECYCLE_MUSIC; @@ -948,112 +948,111 @@ namespace RCT1 } else { - dst->music = src->music; + dst->music = src->Music; } } - if (src->operating_mode == RCT1_RIDE_MODE_POWERED_LAUNCH) + if (src->OperatingMode == RCT1_RIDE_MODE_POWERED_LAUNCH) { // Launched rides never passed through the station in RCT1. dst->mode = RideMode::PoweredLaunch; } else { - dst->mode = static_cast(src->operating_mode); + dst->mode = static_cast(src->OperatingMode); } SetRideColourScheme(dst, src); // Maintenance - dst->build_date = static_cast(src->build_date); - dst->inspection_interval = src->inspection_interval; - dst->last_inspection = src->last_inspection; - dst->reliability = src->reliability; - dst->unreliability_factor = src->unreliability_factor; - dst->downtime = src->downtime; - dst->breakdown_reason = src->breakdown_reason; - dst->mechanic_status = src->mechanic_status; - dst->mechanic = EntityId::FromUnderlying(src->mechanic); - dst->breakdown_reason_pending = src->breakdown_reason_pending; - dst->inspection_station = StationIndex::FromUnderlying(src->inspection_station); - dst->broken_car = src->broken_car; - dst->broken_vehicle = src->broken_vehicle; + dst->build_date = static_cast(src->BuildDate); + dst->inspection_interval = src->InspectionInterval; + dst->last_inspection = src->LastInspection; + dst->reliability = src->Reliability; + dst->unreliability_factor = src->UnreliabilityFactor; + dst->downtime = src->Downtime; + dst->breakdown_reason = src->BreakdownReason; + dst->mechanic_status = src->MechanicStatus; + dst->mechanic = EntityId::FromUnderlying(src->Mechanic); + dst->breakdown_reason_pending = src->BreakdownReasonPending; + dst->inspection_station = StationIndex::FromUnderlying(src->InspectionStation); + dst->broken_car = src->BrokenCar; + dst->broken_vehicle = src->BrokenVehicle; // Measurement data - dst->excitement = src->excitement; - dst->intensity = src->intensity; - dst->nausea = src->nausea; + dst->excitement = src->Excitement; + dst->intensity = src->Intensity; + dst->nausea = src->Nausea; - dst->max_speed = src->max_speed; - dst->average_speed = src->average_speed; + dst->max_speed = src->MaxSpeed; + dst->average_speed = src->AverageSpeed; - 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_lateral_g = src->previous_lateral_g; - dst->previous_vertical_g = src->previous_vertical_g; - dst->turn_count_banked = src->turn_count_banked; - dst->turn_count_default = src->turn_count_default; - dst->turn_count_sloped = src->turn_count_sloped; - dst->drops = src->num_drops; - dst->start_drop_height = src->start_drop_height / 2; - dst->highest_drop_height = src->highest_drop_height / 2; + dst->max_positive_vertical_g = src->MaxPositiveVerticalG; + dst->max_negative_vertical_g = src->MaxNegativeVerticalG; + dst->max_lateral_g = src->MaxLateralG; + dst->previous_lateral_g = src->PreviousLateralG; + dst->previous_vertical_g = src->PreviousVerticalG; + dst->turn_count_banked = src->TurnCountBanked; + dst->turn_count_default = src->TurnCountDefault; + dst->turn_count_sloped = src->TurnCountSloped; + dst->drops = src->NumDrops; + dst->start_drop_height = src->StartDropHeight / 2; + dst->highest_drop_height = src->HighestDropHeight / 2; if (dst->type == RIDE_TYPE_MINI_GOLF) - dst->holes = src->num_inversions & 0x1F; + dst->holes = src->NumInversions & 0x1F; else - dst->inversions = src->num_inversions & 0x1F; - dst->sheltered_eighths = src->num_inversions >> 5; - 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->chairlift_bullwheel_rotation = src->chairlift_bullwheel_rotation; + dst->inversions = src->NumInversions & 0x1F; + dst->sheltered_eighths = src->NumInversions >> 5; + dst->boat_hire_return_direction = src->BoatHireReturnDirection; + dst->boat_hire_return_position = { src->BoatHireReturnPosition.x, src->BoatHireReturnPosition.y }; + dst->chairlift_bullwheel_rotation = src->ChairliftBullwheelRotation; for (int 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] / 2 }; + dst->ChairliftBullwheelLocation[i] = { src->ChairliftBullwheelLocation[i].x, + src->ChairliftBullwheelLocation[i].y, src->ChairliftBullwheelZ[i] / 2 }; } - 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 / 2 }; + dst->CurTestTrackLocation = { src->CurTestTrackLocation.x, src->CurTestTrackLocation.y, + src->CurTestTrackZ / 2 }; } - dst->testing_flags = src->testing_flags; - dst->current_test_segment = src->current_test_segment; + dst->testing_flags = src->TestingFlags; + dst->current_test_segment = src->CurrentTestSegment; dst->current_test_station = StationIndex::GetNull(); - dst->average_speed_test_timeout = src->average_speed_test_timeout; - dst->slide_in_use = src->slide_in_use; - dst->slide_peep_t_shirt_colour = RCT1::GetColour(src->slide_peep_t_shirt_colour); - dst->spiral_slide_progress = src->spiral_slide_progress; + dst->average_speed_test_timeout = src->AverageSpeedTestTimeout; + dst->slide_in_use = src->SlideInUse; + dst->slide_peep_t_shirt_colour = RCT1::GetColour(src->SlidePeepTshirtColour); + dst->spiral_slide_progress = src->SpiralSlideProgress; // Doubles as slide_peep - dst->maze_tiles = src->maze_tiles; + dst->maze_tiles = src->MazeTiles; // Finance / customers - dst->upkeep_cost = src->upkeep_cost; - dst->price[0] = src->price; - dst->price[1] = src->price_secondary; - dst->income_per_hour = ToMoney64(src->income_per_hour); - dst->total_customers = src->total_customers; - dst->profit = ToMoney64(src->profit); - dst->total_profit = ToMoney64(src->total_profit); - dst->value = src->value; - for (size_t i = 0; i < std::size(src->num_customers); i++) + dst->upkeep_cost = src->UpkeepCost; + dst->price[0] = src->Price; + dst->price[1] = src->PriceSecondary; + dst->income_per_hour = ToMoney64(src->IncomePerHour); + dst->total_customers = src->TotalCustomers; + dst->profit = ToMoney64(src->Profit); + dst->total_profit = ToMoney64(src->TotalProfit); + dst->value = src->Value; + for (size_t i = 0; i < std::size(src->NumCustomers); i++) { - dst->num_customers[i] = src->num_customers[i]; + dst->num_customers[i] = src->NumCustomers[i]; } - dst->satisfaction = src->satisfaction; - dst->satisfaction_time_out = src->satisfaction_time_out; - dst->satisfaction_next = src->satisfaction_next; - dst->popularity = src->popularity; - dst->popularity_next = src->popularity_next; - dst->popularity_time_out = src->popularity_time_out; + dst->satisfaction = src->Satisfaction; + dst->satisfaction_time_out = src->SatisfactionTimeOut; + dst->satisfaction_next = src->SatisfactionNext; + dst->popularity = src->Popularity; + dst->popularity_next = src->PopularityNext; + dst->popularity_time_out = src->PopularityTimeOut; - dst->num_riders = src->num_riders; + dst->num_riders = src->NumRiders; dst->music_tune_id = TUNE_ID_NULL; } @@ -1061,19 +1060,19 @@ namespace RCT1 void SetRideColourScheme(::Ride* dst, RCT1::Ride* src) { // Colours - dst->colour_scheme_type = src->colour_scheme; + dst->colour_scheme_type = src->ColourScheme; if (_gameVersion == FILE_VERSION_RCT1) { - dst->track_colour[0].main = RCT1::GetColour(src->track_primary_colour); - dst->track_colour[0].additional = RCT1::GetColour(src->track_secondary_colour); - dst->track_colour[0].supports = RCT1::GetColour(src->track_support_colour); + dst->track_colour[0].main = RCT1::GetColour(src->TrackPrimaryColour); + dst->track_colour[0].additional = RCT1::GetColour(src->TrackSecondaryColour); + dst->track_colour[0].supports = RCT1::GetColour(src->TrackSupportColour); // Balloons were always blue in the original RCT. - if (src->type == RideType::BalloonStall) + if (src->Type == RideType::BalloonStall) { dst->track_colour[0].main = COLOUR_LIGHT_BLUE; } - else if (src->type == RideType::RiverRapids) + else if (src->Type == RideType::RiverRapids) { dst->track_colour[0].main = COLOUR_WHITE; } @@ -1082,9 +1081,9 @@ namespace RCT1 { for (int i = 0; i < Limits::NumColourSchemes; i++) { - dst->track_colour[i].main = RCT1::GetColour(src->track_colour_main[i]); - dst->track_colour[i].additional = RCT1::GetColour(src->track_colour_additional[i]); - dst->track_colour[i].supports = RCT1::GetColour(src->track_colour_supports[i]); + dst->track_colour[i].main = RCT1::GetColour(src->TrackColourMain[i]); + dst->track_colour[i].additional = RCT1::GetColour(src->TrackColourAdditional[i]); + dst->track_colour[i].supports = RCT1::GetColour(src->TrackColourSupports[i]); } } @@ -1098,7 +1097,7 @@ namespace RCT1 } else { - dst->entrance_style = src->entrance_style; + dst->entrance_style = src->EntranceStyle; } } @@ -1113,14 +1112,14 @@ namespace RCT1 for (int i = 0; i < Limits::MaxTrainsPerRide; i++) { // RCT1 had no third colour - const auto colourSchemeCopyDescriptor = GetColourSchemeCopyDescriptor(src->vehicle_type); + const auto colourSchemeCopyDescriptor = GetColourSchemeCopyDescriptor(src->VehicleType); if (colourSchemeCopyDescriptor.colour1 == COPY_COLOUR_1) { - dst->vehicle_colours[i].Body = RCT1::GetColour(src->vehicle_colours[i].body); + dst->vehicle_colours[i].Body = RCT1::GetColour(src->VehicleColours[i].Body); } else if (colourSchemeCopyDescriptor.colour1 == COPY_COLOUR_2) { - dst->vehicle_colours[i].Body = RCT1::GetColour(src->vehicle_colours[i].trim); + dst->vehicle_colours[i].Body = RCT1::GetColour(src->VehicleColours[i].Trim); } else { @@ -1129,11 +1128,11 @@ namespace RCT1 if (colourSchemeCopyDescriptor.colour2 == COPY_COLOUR_1) { - dst->vehicle_colours[i].Trim = RCT1::GetColour(src->vehicle_colours[i].body); + dst->vehicle_colours[i].Trim = RCT1::GetColour(src->VehicleColours[i].Body); } else if (colourSchemeCopyDescriptor.colour2 == COPY_COLOUR_2) { - dst->vehicle_colours[i].Trim = RCT1::GetColour(src->vehicle_colours[i].trim); + dst->vehicle_colours[i].Trim = RCT1::GetColour(src->VehicleColours[i].Trim); } else { @@ -1142,11 +1141,11 @@ namespace RCT1 if (colourSchemeCopyDescriptor.colour3 == COPY_COLOUR_1) { - dst->vehicle_colours[i].Tertiary = RCT1::GetColour(src->vehicle_colours[i].body); + dst->vehicle_colours[i].Tertiary = RCT1::GetColour(src->VehicleColours[i].Body); } else if (colourSchemeCopyDescriptor.colour3 == COPY_COLOUR_2) { - dst->vehicle_colours[i].Tertiary = RCT1::GetColour(src->vehicle_colours[i].trim); + dst->vehicle_colours[i].Tertiary = RCT1::GetColour(src->VehicleColours[i].Trim); } else { @@ -1157,18 +1156,18 @@ namespace RCT1 // In RCT1 and AA, the maze was always hedges. // LL has 4 types, like RCT2. For LL, only guard against invalid values. - if (src->type == RideType::HedgeMaze) + if (src->Type == RideType::HedgeMaze) { - if (_gameVersion < FILE_VERSION_RCT1_LL || src->track_colour_supports[0] > 3) + if (_gameVersion < FILE_VERSION_RCT1_LL || src->TrackColourSupports[0] > 3) dst->track_colour[0].supports = MAZE_WALL_TYPE_HEDGE; else - dst->track_colour[0].supports = src->track_colour_supports[0]; + dst->track_colour[0].supports = src->TrackColourSupports[0]; } } void ImportRideMeasurements() { - for (const auto& src : _s4.ride_measurements) + for (const auto& src : _s4.RideMeasurements) { if (src.ride_index != RCT12_RIDE_ID_NULL) { @@ -1206,25 +1205,25 @@ namespace RCT1 { for (int i = 0; i < Limits::MaxEntities; i++) { - ImportEntity(_s4.sprites[i].unknown); + ImportEntity(_s4.Entities[i].Unknown); } } void SetVehicleColours(::Vehicle* dst, const RCT1::Vehicle* src) { - const auto& srcRide = _s4.rides[src->ride]; - uint8_t vehicleTypeIndex = srcRide.vehicle_type; + const auto& srcRide = _s4.Rides[src->Ride]; + uint8_t vehicleTypeIndex = srcRide.VehicleType; RCT1::VehicleColourSchemeCopyDescriptor colourSchemeCopyDescriptor = RCT1::GetColourSchemeCopyDescriptor( vehicleTypeIndex); // 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.body_colour); } else if (colourSchemeCopyDescriptor.colour1 == COPY_COLOUR_2) { - dst->colours.Body = RCT1::GetColour(src->colours.trim_colour); + dst->colours.Body = RCT1::GetColour(src->Colours.trim_colour); } else { @@ -1233,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.body_colour); } else if (colourSchemeCopyDescriptor.colour2 == COPY_COLOUR_2) { - dst->colours.Trim = RCT1::GetColour(src->colours.trim_colour); + dst->colours.Trim = RCT1::GetColour(src->Colours.trim_colour); } else { @@ -1246,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.body_colour); } else if (colourSchemeCopyDescriptor.colour3 == COPY_COLOUR_2) { - dst->colours.Tertiary = RCT1::GetColour(src->colours.trim_colour); + dst->colours.Tertiary = RCT1::GetColour(src->Colours.trim_colour); } else { @@ -1267,14 +1266,14 @@ namespace RCT1 void ImportPeep(::Peep* dst, const RCT1::Peep* src) { // Peep vs. staff (including which kind) - dst->SpriteType = RCT1::GetPeepSpriteType(src->sprite_type); - dst->Action = static_cast(src->action); - dst->SpecialSprite = src->special_sprite; - dst->NextActionSpriteType = static_cast(src->next_action_sprite_type); - dst->ActionSpriteImageOffset = src->action_sprite_image_offset; - dst->WalkingFrameNum = src->no_action_frame_num; - dst->ActionSpriteType = static_cast(src->action_sprite_type); - dst->ActionFrame = src->action_frame; + dst->SpriteType = RCT1::GetPeepSpriteType(src->SpriteType); + dst->Action = static_cast(src->Action); + dst->SpecialSprite = src->SpecialSprite; + dst->NextActionSpriteType = static_cast(src->NextActionSpriteType); + dst->ActionSpriteImageOffset = src->ActionSpriteImageOffset; + dst->WalkingFrameNum = src->NoActionFrameNum; + dst->ActionSpriteType = static_cast(src->ActionSpriteType); + dst->ActionFrame = src->ActionFrame; const rct_sprite_bounds* spriteBounds = &GetSpriteBounds(dst->SpriteType, dst->ActionSpriteType); dst->sprite_width = spriteBounds->sprite_width; @@ -1286,34 +1285,34 @@ namespace RCT1 dst->sprite_direction = src->sprite_direction; // Peep name - if (IsUserStringID(src->name_string_idx)) + if (IsUserStringID(src->NameStringID)) { - dst->SetName(GetUserString(src->name_string_idx)); + dst->SetName(GetUserString(src->NameStringID)); } - dst->State = static_cast(src->state); - dst->SubState = src->sub_state; - dst->NextLoc = { src->next_x, src->next_y, src->next_z * Limits::CoordsZStep }; - dst->NextFlags = src->next_flags; - dst->Var37 = src->var_37; - dst->StepProgress = src->step_progress; - dst->TshirtColour = RCT1::GetColour(src->tshirt_colour); - dst->TrousersColour = RCT1::GetColour(src->trousers_colour); - dst->DestinationX = src->destination_x; - dst->DestinationY = src->destination_y; - dst->DestinationTolerance = src->destination_tolerance; - dst->PeepDirection = src->direction; - dst->Energy = src->energy; - dst->EnergyTarget = src->energy_target; - dst->Mass = src->mass; + dst->State = static_cast(src->State); + dst->SubState = src->SubState; + dst->NextLoc = { src->NextX, src->NextY, src->NextZ * Limits::CoordsZStep }; + dst->NextFlags = src->NextFlags; + dst->Var37 = src->Var37; + dst->StepProgress = src->StepProgress; + dst->TshirtColour = RCT1::GetColour(src->TshirtColour); + dst->TrousersColour = RCT1::GetColour(src->TrousersColour); + dst->DestinationX = src->DestinationX; + dst->DestinationY = src->DestinationY; + dst->DestinationTolerance = src->DestinationTolerance; + dst->PeepDirection = src->Direction; + dst->Energy = src->Energy; + dst->EnergyTarget = src->EnergyTarget; + dst->Mass = src->Mass; dst->WindowInvalidateFlags = 0; - dst->CurrentRide = RCT12RideIdToOpenRCT2RideId(src->current_ride); - dst->CurrentRideStation = StationIndex::FromUnderlying(src->current_ride_station); - dst->CurrentTrain = src->current_train; - dst->CurrentCar = src->current_car; - dst->CurrentSeat = src->current_seat; - dst->InteractionRideIndex = RCT12RideIdToOpenRCT2RideId(src->interaction_ride_index); - dst->Id = src->id; + dst->CurrentRide = RCT12RideIdToOpenRCT2RideId(src->CurrentRide); + dst->CurrentRideStation = StationIndex::FromUnderlying(src->CurrentRideStation); + dst->CurrentTrain = src->CurrentTrain; + dst->CurrentCar = src->CurrentCar; + dst->CurrentSeat = src->CurrentSeat; + dst->InteractionRideIndex = RCT12RideIdToOpenRCT2RideId(src->InteractionRideIndex); + dst->Id = src->ID; dst->PathCheckOptimisation = 0; dst->PeepFlags = 0; dst->PathfindGoal.x = 0xFF; @@ -1340,7 +1339,7 @@ namespace RCT1 int32_t peepOffset = staffId * Limits::PatrolAreaSize; for (int32_t i = 0; i < Limits::PatrolAreaSize; i++) { - if (_s4.patrol_areas[peepOffset + i] == 0) + if (_s4.PatrolAreas[peepOffset + i] == 0) { // No patrol for this area continue; @@ -1349,7 +1348,7 @@ namespace RCT1 // Loop over the bits of the uint8_t for (int32_t j = 0; j < 8; j++) { - int8_t bit = (_s4.patrol_areas[peepOffset + i] >> j) & 1; + int8_t bit = (_s4.PatrolAreas[peepOffset + i] >> j) & 1; if (bit == 0) { // No patrol for this area @@ -1383,10 +1382,10 @@ namespace RCT1 gPeepSpawns.clear(); for (size_t i = 0; i < Limits::MaxPeepSpawns; i++) { - if (_s4.peep_spawn[i].x != RCT12_PEEP_SPAWN_UNDEFINED) + if (_s4.PeepSpawn[i].x != RCT12_PEEP_SPAWN_UNDEFINED) { - PeepSpawn spawn = { _s4.peep_spawn[i].x, _s4.peep_spawn[i].y, _s4.peep_spawn[i].z * 16, - _s4.peep_spawn[i].direction }; + PeepSpawn spawn = { _s4.PeepSpawn[i].x, _s4.PeepSpawn[i].y, _s4.PeepSpawn[i].z * 16, + _s4.PeepSpawn[i].direction }; gPeepSpawns.push_back(spawn); } } @@ -1394,40 +1393,40 @@ namespace RCT1 void ImportFinance() { - gParkEntranceFee = _s4.park_entrance_fee; - gLandPrice = _s4.land_price; - gConstructionRightsPrice = _s4.construction_rights_price; + gParkEntranceFee = _s4.ParkEntranceFee; + gLandPrice = _s4.LandPrice; + gConstructionRightsPrice = _s4.ConstructionRightsPrice; - gCash = ToMoney64(_s4.cash); - gBankLoan = ToMoney64(_s4.loan); - gMaxBankLoan = ToMoney64(_s4.max_loan); + gCash = ToMoney64(_s4.Cash); + gBankLoan = ToMoney64(_s4.Loan); + gMaxBankLoan = ToMoney64(_s4.MaxLoan); // It's more like 1.33%, but we can only use integers. Can be fixed once we have our own save format. gBankLoanInterestRate = 1; - gInitialCash = ToMoney64(_s4.cash); + gInitialCash = ToMoney64(_s4.Cash); - gCompanyValue = ToMoney64(_s4.company_value); - gParkValue = ToMoney64(CorrectRCT1ParkValue(_s4.park_value)); - gCurrentProfit = ToMoney64(_s4.profit); + gCompanyValue = ToMoney64(_s4.CompanyValue); + gParkValue = ToMoney64(CorrectRCT1ParkValue(_s4.ParkValue)); + gCurrentProfit = ToMoney64(_s4.Profit); for (size_t i = 0; i < Limits::FinanceGraphSize; i++) { - gCashHistory[i] = ToMoney64(_s4.cash_history[i]); - gParkValueHistory[i] = ToMoney64(CorrectRCT1ParkValue(_s4.park_value_history[i])); - gWeeklyProfitHistory[i] = ToMoney64(_s4.weekly_profit_history[i]); + gCashHistory[i] = ToMoney64(_s4.CashHistory[i]); + gParkValueHistory[i] = ToMoney64(CorrectRCT1ParkValue(_s4.ParkValueHistory[i])); + gWeeklyProfitHistory[i] = ToMoney64(_s4.WeeklyProfitHistory[i]); } for (size_t i = 0; i < Limits::ExpenditureTableMonthCount; i++) { for (size_t j = 0; j < Limits::ExpenditureTypeCount; j++) { - gExpenditureTable[i][j] = ToMoney64(_s4.expenditure[i][j]); + gExpenditureTable[i][j] = ToMoney64(_s4.Expenditure[i][j]); } } - gCurrentExpenditure = ToMoney64(_s4.total_expenditure); + gCurrentExpenditure = ToMoney64(_s4.TotalExpenditure); - gScenarioCompletedCompanyValue = RCT12CompletedCompanyValueToOpenRCT2(_s4.completed_company_value); - gTotalAdmissions = _s4.num_admissions; - gTotalIncomeFromAdmissions = ToMoney64(_s4.admission_total_income); + gScenarioCompletedCompanyValue = RCT12CompletedCompanyValueToOpenRCT2(_s4.CompletedCompanyValue); + gTotalAdmissions = _s4.NumAdmissions; + gTotalIncomeFromAdmissions = ToMoney64(_s4.AdmissionTotalIncome); // TODO marketing campaigns not working static_assert( @@ -1435,18 +1434,18 @@ namespace RCT1 "Advertising enum bigger than capacity of iterator"); for (uint8_t i = 0; i < ADVERTISING_CAMPAIGN_COUNT; i++) { - if (_s4.marketing_status[i] & CAMPAIGN_ACTIVE_FLAG) + if (_s4.MarketingStatus[i] & CAMPAIGN_ACTIVE_FLAG) { MarketingCampaign campaign; campaign.Type = i; - campaign.WeeksLeft = _s4.marketing_status[i] & ~CAMPAIGN_ACTIVE_FLAG; + campaign.WeeksLeft = _s4.MarketingStatus[i] & ~CAMPAIGN_ACTIVE_FLAG; if (campaign.Type == ADVERTISING_CAMPAIGN_RIDE_FREE || campaign.Type == ADVERTISING_CAMPAIGN_RIDE) { - campaign.RideId = RCT12RideIdToOpenRCT2RideId(_s4.marketing_assoc[i]); + campaign.RideId = RCT12RideIdToOpenRCT2RideId(_s4.MarketingAssoc[i]); } else if (campaign.Type == ADVERTISING_CAMPAIGN_FOOD_OR_DRINK_FREE) { - campaign.ShopItemType = ShopItem(_s4.marketing_assoc[i]); + campaign.ShopItemType = ShopItem(_s4.MarketingAssoc[i]); } gMarketingCampaigns.push_back(campaign); } @@ -1507,10 +1506,10 @@ namespace RCT1 // Build tile pointer cache (needed to get the first element at a certain location) auto tilePointerIndex = TilePointerIndex( - Limits::MaxMapSize, _s4.tile_elements, std::size(_s4.tile_elements)); + Limits::MaxMapSize, _s4.TileElements, std::size(_s4.TileElements)); std::vector tileElements; - const auto maxSize = _s4.map_size == 0 ? Limits::MaxMapSize : _s4.map_size; + const auto maxSize = _s4.MapSize == 0 ? Limits::MaxMapSize : _s4.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++) @@ -1835,9 +1834,9 @@ namespace RCT1 dst2->SetAllowedEdges(src2->GetAllowedEdges()); auto index = src2->GetIndex(); - if (index < std::size(_s4.banners)) + if (index < std::size(_s4.Banners)) { - auto srcBanner = &_s4.banners[index]; + auto srcBanner = &_s4.Banners[index]; auto dstBanner = GetOrCreateBanner(BannerIndex::FromUnderlying(index)); if (dstBanner == nullptr) { @@ -1888,27 +1887,27 @@ namespace RCT1 for (size_t i = 0; i < researchListCount; i++) { const auto& researchItem = researchList[i]; - if (researchItem.flags == RCT1_RESEARCH_FLAGS_SEPARATOR) + if (researchItem.Flags == RCT1ResearchFlagsSeparator) { - if (researchItem.item == RCT1_RESEARCH_END_AVAILABLE) + if (researchItem.Item == RCT1_RESEARCH_END_AVAILABLE) { researched = false; continue; } // We don't import the random items yet. - else if (researchItem.item == RCT1_RESEARCH_END_RESEARCHABLE || researchItem.item == RCT1_RESEARCH_END) + else if (researchItem.Item == RCT1_RESEARCH_END_RESEARCHABLE || researchItem.Item == RCT1_RESEARCH_END) { break; } } - switch (researchItem.type) + switch (researchItem.Type) { case RCT1_RESEARCH_TYPE_THEME: { - uint8_t rct1SceneryTheme = researchItem.item; + uint8_t rct1SceneryTheme = researchItem.Item; auto sceneryGroupEntryIndex = _sceneryThemeTypeToEntryMap[rct1SceneryTheme]; - if (sceneryGroupEntryIndex != OBJECT_ENTRY_INDEX_IGNORE + if (sceneryGroupEntryIndex != ObjectEntryIndexIgnore && sceneryGroupEntryIndex != OBJECT_ENTRY_INDEX_NULL) { ResearchInsertSceneryGroupEntry(sceneryGroupEntryIndex, researched); @@ -1917,7 +1916,7 @@ namespace RCT1 } case RCT1_RESEARCH_TYPE_RIDE: { - const auto rct1RideType = static_cast(researchItem.item); + const auto rct1RideType = static_cast(researchItem.Item); _researchRideTypeUsed[EnumValue(rct1RideType)] = true; auto ownRideEntryIndex = _rideTypeToRideEntryMap[EnumValue(rct1RideType)]; @@ -1932,10 +1931,10 @@ namespace RCT1 for (size_t j = 0; j < researchListCount; j++) { const auto& researchItem2 = researchList[j]; - if (researchItem2.flags == RCT1_RESEARCH_FLAGS_SEPARATOR) + if (researchItem2.Flags == RCT1ResearchFlagsSeparator) { - if (researchItem2.item == RCT1_RESEARCH_END_RESEARCHABLE - || researchItem2.item == RCT1_RESEARCH_END) + if (researchItem2.Item == RCT1_RESEARCH_END_RESEARCHABLE + || researchItem2.Item == RCT1_RESEARCH_END) { break; } @@ -1943,10 +1942,10 @@ namespace RCT1 continue; } - if (researchItem2.type == RCT1_RESEARCH_TYPE_VEHICLE - && static_cast(researchItem2.related_ride) == rct1RideType) + if (researchItem2.Type == RCT1_RESEARCH_TYPE_VEHICLE + && static_cast(researchItem2.RelatedRide) == rct1RideType) { - auto rideEntryIndex2 = _vehicleTypeToRideEntryMap[researchItem2.item]; + auto rideEntryIndex2 = _vehicleTypeToRideEntryMap[researchItem2.Item]; bool isOwnType = (ownRideEntryIndex == rideEntryIndex2); if (isOwnType) { @@ -1979,11 +1978,11 @@ namespace RCT1 // Only add vehicle if the related ride has been seen, this to make sure that vehicles // are researched only after the ride has been researched. Otherwise, remove them from the research // list, so that they are automatically co-invented when their master ride is invented. - if (_researchRideTypeUsed[researchItem.related_ride]) + if (_researchRideTypeUsed[researchItem.RelatedRide]) { InsertResearchVehicle(researchItem, researched); } - else if (!rideTypeInResearch[researchItem.related_ride] && _gameVersion == FILE_VERSION_RCT1_LL) + else if (!rideTypeInResearch[researchItem.RelatedRide] && _gameVersion == FILE_VERSION_RCT1_LL) { vehiclesWithMissingRideTypes.push_back(researchItem); } @@ -2002,53 +2001,53 @@ namespace RCT1 // Research funding / priority uint8_t activeResearchTypes = 0; - if (_s4.research_priority & RCT1_RESEARCH_CATEGORY_ROLLERCOASTERS) + if (_s4.ResearchPriority & RCT1_RESEARCH_CATEGORY_ROLLERCOASTERS) { activeResearchTypes |= EnumToFlag(ResearchCategory::Rollercoaster); } - if (_s4.research_priority & RCT1_RESEARCH_CATEGORY_THRILL_RIDES) + if (_s4.ResearchPriority & RCT1_RESEARCH_CATEGORY_THRILL_RIDES) { activeResearchTypes |= EnumToFlag(ResearchCategory::Thrill); activeResearchTypes |= EnumToFlag(ResearchCategory::Water); } - if (_s4.research_priority & RCT1_RESEARCH_CATEGORY_GENTLE_TRANSPORT_RIDES) + if (_s4.ResearchPriority & RCT1_RESEARCH_CATEGORY_GENTLE_TRANSPORT_RIDES) { activeResearchTypes |= EnumToFlag(ResearchCategory::Gentle); activeResearchTypes |= EnumToFlag(ResearchCategory::Transport); } - if (_s4.research_priority & RCT1_RESEARCH_CATEGORY_SHOPS) + if (_s4.ResearchPriority & RCT1_RESEARCH_CATEGORY_SHOPS) { activeResearchTypes |= EnumToFlag(ResearchCategory::Shop); } - if (_s4.research_priority & RCT1_RESEARCH_CATEGORY_SCENERY_THEMING) + if (_s4.ResearchPriority & RCT1_RESEARCH_CATEGORY_SCENERY_THEMING) { activeResearchTypes |= EnumToFlag(ResearchCategory::SceneryGroup); } gResearchPriorities = activeResearchTypes; - gResearchFundingLevel = _s4.research_level; + gResearchFundingLevel = _s4.ResearchLevel; // This will mark items as researched/unresearched according to the research list. // This needs to be called before importing progress, as it will reset it. ResearchResetCurrentItem(); // Research history - gResearchProgress = _s4.research_progress; - gResearchProgressStage = _s4.research_progress_stage; - gResearchExpectedDay = _s4.next_research_expected_day; - gResearchExpectedMonth = _s4.next_research_expected_month; + gResearchProgress = _s4.ResearchProgress; + gResearchProgressStage = _s4.ResearchProgressStage; + gResearchExpectedDay = _s4.NextResearchExpectedDay; + gResearchExpectedMonth = _s4.NextResearchExpectedMonth; - if (_s4.last_research_flags == 0xFF) + if (_s4.LastResearchFlags == 0xFF) { gResearchLastItem = std::nullopt; } else { ::ResearchItem researchItem = {}; - ConvertResearchEntry(&researchItem, _s4.last_research_item, _s4.last_research_type); + ConvertResearchEntry(&researchItem, _s4.LastResearchItem, _s4.LastResearchType); gResearchLastItem = researchItem; } - if (_s4.next_research_flags == 0xFF) + if (_s4.NextResearchFlags == 0xFF) { gResearchNextItem = std::nullopt; gResearchProgressStage = RESEARCH_STAGE_INITIAL_RESEARCH; @@ -2057,7 +2056,7 @@ namespace RCT1 else { ::ResearchItem researchItem = {}; - ConvertResearchEntry(&researchItem, _s4.next_research_item, _s4.next_research_type); + ConvertResearchEntry(&researchItem, _s4.NextResearchItem, _s4.NextResearchType); gResearchNextItem = researchItem; } } @@ -2070,21 +2069,21 @@ namespace RCT1 for (size_t i = 0; i < researchListCount; i++) { const auto& researchItem = researchList[i]; - if (researchItem.flags == RCT1_RESEARCH_FLAGS_SEPARATOR) + if (researchItem.Flags == RCT1ResearchFlagsSeparator) { - if (researchItem.item == RCT1_RESEARCH_END_AVAILABLE || researchItem.item == RCT1_RESEARCH_END_RESEARCHABLE) + if (researchItem.Item == RCT1_RESEARCH_END_AVAILABLE || researchItem.Item == RCT1_RESEARCH_END_RESEARCHABLE) { continue; } - if (researchItem.item == RCT1_RESEARCH_END) + if (researchItem.Item == RCT1_RESEARCH_END) { break; } } - if (researchItem.type == RCT1_RESEARCH_TYPE_RIDE) + if (researchItem.Type == RCT1_RESEARCH_TYPE_RIDE) { - ret[researchItem.item] = true; + ret[researchItem.Item] = true; } } @@ -2093,7 +2092,7 @@ namespace RCT1 void InsertResearchVehicle(const ResearchItem& researchItem, bool researched) { - uint8_t vehicle = researchItem.item; + uint8_t vehicle = researchItem.Item; auto rideEntryIndex = _vehicleTypeToRideEntryMap[vehicle]; if (!_researchRideEntryUsed[rideEntryIndex]) @@ -2105,10 +2104,10 @@ namespace RCT1 void ImportParkName() { - std::string parkName = std::string(_s4.scenario_name); - if (IsUserStringID(static_cast(_s4.park_name_string_index))) + std::string parkName = std::string(_s4.ScenarioName); + if (IsUserStringID(static_cast(_s4.ParkNameStringIndex))) { - std::string userString = GetUserString(_s4.park_name_string_index); + std::string userString = GetUserString(_s4.ParkNameStringIndex); if (!userString.empty()) { parkName = std::move(userString); @@ -2122,28 +2121,28 @@ namespace RCT1 void ImportParkFlags() { // Date and srand - gCurrentTicks = _s4.ticks; - ScenarioRandSeed(_s4.random_a, _s4.random_b); - gDateMonthsElapsed = static_cast(_s4.month); - gDateMonthTicks = _s4.day; + gCurrentTicks = _s4.Ticks; + ScenarioRandSeed(_s4.RandomA, _s4.RandomB); + gDateMonthsElapsed = static_cast(_s4.Month); + gDateMonthTicks = _s4.Day; // Park rating - gParkRating = _s4.park_rating; + gParkRating = _s4.ParkRating; auto& park = OpenRCT2::GetContext()->GetGameState()->GetPark(); park.ResetHistories(); - std::copy(std::begin(_s4.park_rating_history), std::end(_s4.park_rating_history), gParkRatingHistory); - for (size_t i = 0; i < std::size(_s4.guests_in_park_history); i++) + std::copy(std::begin(_s4.ParkRatingHistory), std::end(_s4.ParkRatingHistory), gParkRatingHistory); + for (size_t i = 0; i < std::size(_s4.GuestsInParkHistory); i++) { - if (_s4.guests_in_park_history[i] != RCT12ParkHistoryUndefined) + if (_s4.GuestsInParkHistory[i] != RCT12ParkHistoryUndefined) { - gGuestsInParkHistory[i] = _s4.guests_in_park_history[i] * RCT12GuestsInParkHistoryFactor; + gGuestsInParkHistory[i] = _s4.GuestsInParkHistory[i] * RCT12GuestsInParkHistoryFactor; } } // Awards auto& awards = GetAwards(); - for (auto& src : _s4.awards) + for (auto& src : _s4.Awards) { if (src.time != 0) { @@ -2153,18 +2152,18 @@ namespace RCT1 // Number of guests history std::fill(std::begin(gGuestsInParkHistory), std::end(gGuestsInParkHistory), std::numeric_limits::max()); - for (size_t i = 0; i < std::size(_s4.guests_in_park_history); i++) + for (size_t i = 0; i < std::size(_s4.GuestsInParkHistory); i++) { - if (_s4.guests_in_park_history[i] != std::numeric_limits::max()) + if (_s4.GuestsInParkHistory[i] != std::numeric_limits::max()) { - gGuestsInParkHistory[i] = _s4.guests_in_park_history[i] * 20; + gGuestsInParkHistory[i] = _s4.GuestsInParkHistory[i] * 20; } } // News items for (size_t i = 0; i < Limits::MaxNewsItems; i++) { - const rct12_news_item* src = &_s4.messages[i]; + const rct12_news_item* src = &_s4.Messages[i]; News::Item* dst = &gNewsItems[i]; dst->Type = static_cast(src->Type); @@ -2190,34 +2189,34 @@ namespace RCT1 } // Initial guest status - gGuestInitialCash = _s4.guest_initial_cash; - gGuestInitialHunger = _s4.guest_initial_hunger; - gGuestInitialThirst = _s4.guest_initial_thirst; - gGuestInitialHappiness = _s4.guest_initial_happiness; + gGuestInitialCash = _s4.GuestInitialCash; + gGuestInitialHunger = _s4.GuestInitialHunger; + gGuestInitialThirst = _s4.GuestInitialThirst; + gGuestInitialHappiness = _s4.GuestInitialHappiness; - _guestGenerationProbability = _s4.guest_generation_probability; + _guestGenerationProbability = _s4.GuestGenerationProbability; // Staff colours - gStaffHandymanColour = RCT1::GetColour(_s4.handman_colour); - gStaffMechanicColour = RCT1::GetColour(_s4.mechanic_colour); - gStaffSecurityColour = RCT1::GetColour(_s4.security_guard_colour); + gStaffHandymanColour = RCT1::GetColour(_s4.HandymanColour); + gStaffMechanicColour = RCT1::GetColour(_s4.MechanicColour); + gStaffSecurityColour = RCT1::GetColour(_s4.SecurityGuardColour); // Flags - gParkFlags = _s4.park_flags; + gParkFlags = _s4.ParkFlags; gParkFlags &= ~PARK_FLAGS_ANTI_CHEAT_DEPRECATED; // Loopy Landscape parks can set a flag to lock the entry price to free. // If this flag is not set, the player can ask money for both rides and entry. - if (!(_s4.park_flags & RCT1_PARK_FLAGS_PARK_ENTRY_LOCKED_AT_FREE)) + if (!(_s4.ParkFlags & RCT1_PARK_FLAGS_PARK_ENTRY_LOCKED_AT_FREE)) { gParkFlags |= PARK_FLAGS_UNLOCK_ALL_PRICES; } - gParkSize = _s4.park_size; - gTotalRideValueForMoney = _s4.total_ride_value_for_money; + gParkSize = _s4.ParkSize; + gTotalRideValueForMoney = _s4.TotalRideValueForMoney; gSamePriceThroughoutPark = 0; if (_gameVersion == FILE_VERSION_RCT1_LL) { - gSamePriceThroughoutPark = _s4.same_price_throughout; + gSamePriceThroughoutPark = _s4.SamePriceThroughout; } } @@ -2266,7 +2265,7 @@ namespace RCT1 { auto entryIndex = _sceneryThemeTypeToEntryMap[srcItem]; - if (entryIndex != OBJECT_ENTRY_INDEX_IGNORE && entryIndex != OBJECT_ENTRY_INDEX_NULL) + if (entryIndex != ObjectEntryIndexIgnore && entryIndex != OBJECT_ENTRY_INDEX_NULL) { dst->entryIndex = entryIndex; dst->type = Research::EntryType::Scenery; @@ -2279,26 +2278,26 @@ namespace RCT1 void ImportClimate() { - gClimate = ClimateType{ _s4.climate }; - gClimateUpdateTimer = _s4.climate_timer; - gClimateCurrent.Temperature = _s4.temperature; - gClimateCurrent.Weather = WeatherType{ _s4.weather }; + gClimate = ClimateType{ _s4.Climate }; + gClimateUpdateTimer = _s4.ClimateTimer; + gClimateCurrent.Temperature = _s4.Temperature; + gClimateCurrent.Weather = WeatherType{ _s4.Weather }; gClimateCurrent.WeatherEffect = WeatherEffectType::None; - gClimateCurrent.WeatherGloom = _s4.weather_gloom; - gClimateCurrent.Level = static_cast(_s4.rain); - gClimateNext.Temperature = _s4.target_temperature; - gClimateNext.Weather = WeatherType{ _s4.target_weather }; + gClimateCurrent.WeatherGloom = _s4.WeatherGloom; + gClimateCurrent.Level = static_cast(_s4.Rain); + gClimateNext.Temperature = _s4.TargetTemperature; + gClimateNext.Weather = WeatherType{ _s4.TargetWeather }; gClimateNext.WeatherEffect = WeatherEffectType::None; - gClimateNext.WeatherGloom = _s4.target_weather_gloom; - gClimateNext.Level = static_cast(_s4.target_rain); + gClimateNext.WeatherGloom = _s4.TargetWeatherGloom; + gClimateNext.Level = static_cast(_s4.TargetRain); } void ImportScenarioNameDetails() { - std::string name = String::ToStd(_s4.scenario_name); + std::string name = String::ToStd(_s4.ScenarioName); std::string details; - int32_t scNumber = _s4.scenario_slot_index; + int32_t scNumber = _s4.ScenarioSlotIndex; if (scNumber != -1) { source_desc sourceDesc; @@ -2325,28 +2324,28 @@ namespace RCT1 void ImportScenarioObjective() { - gScenarioObjective.Type = _s4.scenario_objective_type; - gScenarioObjective.Year = _s4.scenario_objective_years; - gScenarioObjective.NumGuests = _s4.scenario_objective_num_guests; + gScenarioObjective.Type = _s4.ScenarioObjectiveType; + gScenarioObjective.Year = _s4.ScenarioObjectiveYears; + gScenarioObjective.NumGuests = _s4.ScenarioObjectiveNumGuests; // RCT1 used a different way of calculating the park value. // This is corrected here, but since scenario_objective_currency doubles as minimum excitement rating, // we need to check the goal to avoid affecting scenarios like Volcania. - if (_s4.scenario_objective_type == OBJECTIVE_PARK_VALUE_BY) - gScenarioObjective.Currency = ToMoney64(CorrectRCT1ParkValue(_s4.scenario_objective_currency)); + if (_s4.ScenarioObjectiveType == OBJECTIVE_PARK_VALUE_BY) + gScenarioObjective.Currency = ToMoney64(CorrectRCT1ParkValue(_s4.ScenarioObjectiveCurrency)); else - gScenarioObjective.Currency = ToMoney64(_s4.scenario_objective_currency); + gScenarioObjective.Currency = ToMoney64(_s4.ScenarioObjectiveCurrency); // This does not seem to be saved in the objective arguments, so look up the ID from the available rides instead. - if (_s4.scenario_objective_type == OBJECTIVE_BUILD_THE_BEST) + if (_s4.ScenarioObjectiveType == OBJECTIVE_BUILD_THE_BEST) gScenarioObjective.RideId = GetBuildTheBestRideId(); } void ImportSavedView() { - gSavedView = ScreenCoordsXY{ _s4.view_x, _s4.view_y }; - gSavedViewZoom = ZoomLevel{ static_cast(_s4.view_zoom) }; - gSavedViewRotation = _s4.view_rotation; + gSavedView = ScreenCoordsXY{ _s4.ViewX, _s4.ViewY }; + gSavedViewZoom = ZoomLevel{ static_cast(_s4.ViewZoom) }; + gSavedViewRotation = _s4.ViewRotation; } void ConvertWall(const int32_t& type, colour_t* colourA, colour_t* colourB) @@ -2462,17 +2461,17 @@ namespace RCT1 // Loopy Landscapes stores research items in a different place if (_gameVersion == FILE_VERSION_RCT1_LL) { - *count = std::size(_s4.research_items_LL); - return _s4.research_items_LL; + *count = std::size(_s4.ResearchItemsLL); + return _s4.ResearchItemsLL; } - *count = std::size(_s4.research_items); - return _s4.research_items; + *count = std::size(_s4.ResearchItems); + return _s4.ResearchItems; } std::string GetUserString(StringId stringId) { - const auto originalString = _s4.string_table[(stringId - USER_STRING_START) % 1024]; + const auto originalString = _s4.StringTable[(stringId - USER_STRING_START) % 1024]; auto originalStringView = std::string_view( originalString, RCT2::GetRCT2StringBufferLen(originalString, USER_STRING_MAX_LENGTH)); auto asUtf8 = RCT2StringToUTF8(originalStringView, RCT2LanguageId::EnglishUK); @@ -2482,7 +2481,7 @@ namespace RCT1 void FixLandOwnership() { - switch (_s4.scenario_slot_index) + switch (_s4.ScenarioSlotIndex) { case SC_DYNAMITE_DUNES: FixLandOwnershipTiles({ { 97, 18 }, { 99, 19 }, { 83, 34 } }); @@ -2518,7 +2517,7 @@ namespace RCT1 */ void FixUrbanPark() { - if (_s4.scenario_slot_index == SC_URBAN_PARK && _isScenario) + if (_s4.ScenarioSlotIndex == SC_URBAN_PARK && _isScenario) { const auto merryGoRoundId = RideId::FromUnderlying(0); @@ -2624,14 +2623,14 @@ namespace RCT1 const RCT1::ResearchItem* researchList = GetResearchList(&researchListCount); for (size_t i = 0; i < researchListCount; i++) { - if (researchList[i].flags == 0xFF) + if (researchList[i].Flags == 0xFF) { break; } - if (researchList[i].type == RCT1_RESEARCH_TYPE_RIDE) + if (researchList[i].Type == RCT1_RESEARCH_TYPE_RIDE) { - return RCT1::GetRideType(static_cast(researchList[i].item), 0); + return RCT1::GetRideType(static_cast(researchList[i].Item), 0); } } @@ -2649,7 +2648,9 @@ namespace RCT1 output = EntityType::Vehicle; break; case RCT12SpriteIdentifier::Peep: - if (RCT12PeepType(static_cast(&src)->type) == RCT12PeepType::Guest) + { + const auto& peep = static_cast(src); + if (peep.PeepType == RCT12PeepType::Guest) { output = EntityType::Guest; } @@ -2658,6 +2659,7 @@ namespace RCT1 output = EntityType::Staff; } break; + } case RCT12SpriteIdentifier::Misc: switch (RCT12MiscEntityType(src.type)) @@ -2707,20 +2709,20 @@ namespace RCT1 { auto* dst = CreateEntityAt<::Vehicle>(EntityId::FromUnderlying(srcBase.sprite_index)); auto* src = static_cast(&srcBase); - const auto* ride = GetRide(RideId::FromUnderlying(src->ride)); + const auto* ride = GetRide(RideId::FromUnderlying(src->Ride)); if (ride == nullptr) return; - const auto& rct1Ride = _s4.rides[src->ride]; - uint8_t vehicleEntryIndex = RCT1::GetVehicleSubEntryIndex(rct1Ride.vehicle_type, src->CarType); + const auto& rct1Ride = _s4.Rides[src->Ride]; + uint8_t vehicleEntryIndex = RCT1::GetVehicleSubEntryIndex(rct1Ride.VehicleType, src->CarType); - dst->ride = RideId::FromUnderlying(src->ride); + dst->ride = RideId::FromUnderlying(src->Ride); dst->ride_subtype = RCTEntryIndexToOpenRCT2EntryIndex(ride->subtype); dst->vehicle_type = vehicleEntryIndex; dst->SubType = ::Vehicle::Type(src->type); - dst->var_44 = src->var_44; - dst->remaining_distance = src->remaining_distance; + dst->var_44 = src->Var44; + dst->remaining_distance = src->RemainingDistance; // Properties from vehicle entry dst->sprite_width = src->sprite_width; @@ -2730,64 +2732,64 @@ namespace RCT1 dst->SpriteRect = ScreenRect(src->sprite_left, src->sprite_top, src->sprite_right, src->sprite_bottom); - dst->mass = src->mass; - dst->num_seats = src->num_seats; - dst->speed = src->speed; - dst->powered_acceleration = src->powered_acceleration; - dst->brake_speed = src->brake_speed; + dst->mass = src->Mass; + dst->num_seats = src->NumSeats; + dst->speed = src->Speed; + dst->powered_acceleration = src->PoweredAcceleration; + dst->brake_speed = src->BrakeSpeed; - dst->velocity = src->velocity; - dst->acceleration = src->acceleration; + dst->velocity = src->Velocity; + dst->acceleration = src->Acceleration; dst->SwingSprite = src->SwingSprite; dst->SwingPosition = src->SwingPosition; dst->SwingSpeed = src->SwingSpeed; - dst->restraints_position = src->restraints_position; - dst->spin_sprite = src->spin_sprite; - dst->sound_vector_factor = src->sound_vector_factor; - dst->spin_speed = src->spin_speed; - dst->sound2_flags = src->sound2_flags; + dst->restraints_position = src->RestraintsPosition; + dst->spin_sprite = src->SpinSprite; + dst->sound_vector_factor = src->SoundVectorFactor; + dst->spin_speed = src->SpinSpeed; + dst->sound2_flags = src->Sound2Flags; dst->sound1_id = OpenRCT2::Audio::SoundId::Null; dst->sound2_id = OpenRCT2::Audio::SoundId::Null; - dst->var_C0 = src->var_C0; + dst->var_C0 = src->VarC0; dst->CollisionDetectionTimer = src->CollisionDetectionTimer; - dst->animation_frame = src->animation_frame; - dst->animationState = src->animationState; + dst->animation_frame = src->AnimationFrame; + dst->animationState = src->AnimationState; dst->NumLaps = src->NumLaps; - dst->var_D3 = src->var_D3; + dst->var_D3 = src->VarD3; dst->scream_sound_id = OpenRCT2::Audio::SoundId::Null; dst->Pitch = src->Pitch; - dst->bank_rotation = src->bank_rotation; + dst->bank_rotation = src->BankRotation; // Seat rotation was not in RCT1 dst->target_seat_rotation = DEFAULT_SEAT_ROTATION; dst->seat_rotation = DEFAULT_SEAT_ROTATION; // Vehicle links (indexes converted later) - 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->next_vehicle_on_train = EntityId::FromUnderlying(src->next_vehicle_on_train); + dst->prev_vehicle_on_ride = EntityId::FromUnderlying(src->PrevVehicleOnRide); + dst->next_vehicle_on_ride = EntityId::FromUnderlying(src->NextVehicleOnRide); + dst->next_vehicle_on_train = EntityId::FromUnderlying(src->NextVehicleOnTrain); // Guests (indexes converted later) for (int i = 0; i < 32; i++) { - const auto spriteIndex = EntityId::FromUnderlying(src->peep[i]); + const auto spriteIndex = EntityId::FromUnderlying(src->Peep[i]); dst->peep[i] = spriteIndex; if (!spriteIndex.IsNull()) { - dst->peep_tshirt_colours[i] = RCT1::GetColour(src->peep_tshirt_colours[i]); + dst->peep_tshirt_colours[i] = RCT1::GetColour(src->PeepTshirtColours[i]); } } ::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->TrackSubposition = VehicleTrackSubposition{ src->TrackSubposition }; - dst->TrackLocation = { src->track_x, src->track_y, src->track_z }; - dst->current_station = StationIndex::FromUnderlying(src->current_station); - if (src->boat_location.IsNull() || ride->mode != RideMode::BoatHire || statusSrc != ::Vehicle::Status::TravellingBoat) + dst->TrackLocation = { src->TrackX, src->TrackY, src->TrackZ }; + dst->current_station = StationIndex::FromUnderlying(src->CurrentStation); + if (src->BoatLocation.IsNull() || ride->mode != RideMode::BoatHire || statusSrc != ::Vehicle::Status::TravellingBoat) { dst->BoatLocation.SetNull(); dst->SetTrackDirection(src->GetTrackDirection()); @@ -2795,24 +2797,24 @@ namespace RCT1 } 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->track_progress = src->track_progress; - dst->vertical_drop_countdown = src->vertical_drop_countdown; - dst->sub_state = src->sub_state; - dst->update_flags = src->update_flags; + dst->track_progress = src->TrackProgress; + dst->vertical_drop_countdown = src->VerticalDropCountdown; + dst->sub_state = src->SubState; + dst->update_flags = src->UpdateFlags; SetVehicleColours(dst, src); - dst->mini_golf_current_animation = MiniGolfAnimation(src->mini_golf_current_animation); - dst->mini_golf_flags = src->mini_golf_flags; + dst->mini_golf_current_animation = MiniGolfAnimation(src->MiniGolfCurrentAnimation); + dst->mini_golf_flags = src->MiniGolfFlags; dst->MoveTo({ src->x, src->y, src->z }); - dst->num_peeps = src->num_peeps; - dst->next_free_seat = src->next_free_seat; + dst->num_peeps = src->NumPeeps; + dst->next_free_seat = src->NextFreeSeat; dst->IsCrashedVehicle = src->flags & RCT12_SPRITE_FLAGS_IS_CRASHED_VEHICLE_SPRITE; } @@ -2822,11 +2824,11 @@ namespace RCT1 auto* src = static_cast(&srcBase); ImportPeep(dst, src); - dst->OutsideOfPark = static_cast(src->outside_of_park); - dst->TimeToConsume = src->time_to_consume; - dst->VandalismSeen = src->vandalism_seen; - dst->UmbrellaColour = RCT1::GetColour(src->umbrella_colour); - dst->HatColour = RCT1::GetColour(src->hat_colour); + dst->OutsideOfPark = static_cast(src->OutsideOfPark); + dst->TimeToConsume = src->TimeToConsume; + dst->VandalismSeen = src->VandalismSeen; + dst->UmbrellaColour = RCT1::GetColour(src->UmbrellaColour); + dst->HatColour = RCT1::GetColour(src->HatColour); // Balloons were always blue in RCT1 without AA/LL if (_gameVersion == FILE_VERSION_RCT1) @@ -2835,47 +2837,47 @@ namespace RCT1 } else { - dst->BalloonColour = RCT1::GetColour(src->balloon_colour); + dst->BalloonColour = RCT1::GetColour(src->BalloonColour); } - 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->LitterCount = src->litter_count; - dst->DisgustingCount = src->disgusting_count; - dst->Intensity = static_cast(src->intensity); - dst->NauseaTolerance = static_cast(src->nausea_tolerance); - dst->GuestTimeOnRide = src->time_on_ride; - dst->DaysInQueue = src->days_in_queue; - dst->CashInPocket = src->cash_in_pocket; - dst->CashSpent = src->cash_spent; - dst->ParkEntryTime = src->park_entry_time; - dst->GuestNumRides = src->no_of_rides; - dst->AmountOfDrinks = src->no_of_drinks; - dst->AmountOfFood = src->no_of_food; - dst->AmountOfSouvenirs = src->no_of_souvenirs; - dst->PaidToEnter = src->paid_to_enter; - dst->PaidOnRides = src->paid_on_rides; - dst->PaidOnDrink = src->paid_on_drink; - dst->PaidOnFood = src->paid_on_food; - dst->PaidOnSouvenirs = src->paid_on_souvenirs; - dst->VoucherRideId = RCT12RideIdToOpenRCT2RideId(src->voucher_arguments); - dst->VoucherType = src->voucher_type; - dst->SurroundingsThoughtTimeout = src->surroundings_thought_timeout; - dst->Angriness = src->angriness; - dst->TimeLost = src->time_lost; + 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->LitterCount = src->LitterCount; + dst->DisgustingCount = src->DisgustingCount; + dst->Intensity = static_cast(src->Intensity); + dst->NauseaTolerance = static_cast(src->NauseaTolerance); + dst->GuestTimeOnRide = src->TimeOnRide; + dst->DaysInQueue = src->DaysInQueue; + dst->CashInPocket = src->CashInPocket; + dst->CashSpent = src->CashSpent; + dst->ParkEntryTime = src->ParkEntryTime; + dst->GuestNumRides = src->NumRides; + dst->AmountOfDrinks = src->NumDrinks; + dst->AmountOfFood = src->NumFood; + dst->AmountOfSouvenirs = src->NumSouvenirs; + dst->PaidToEnter = src->PaidToEnter; + dst->PaidOnRides = src->PaidOnRides; + dst->PaidOnDrink = src->PaidOnDrink; + dst->PaidOnFood = src->PaidOnFood; + dst->PaidOnSouvenirs = src->PaidOnSouvenirs; + dst->VoucherRideId = RCT12RideIdToOpenRCT2RideId(src->VoucherArguments); + dst->VoucherType = src->VoucherType; + dst->SurroundingsThoughtTimeout = src->SurroundingsThoughtTimeout; + dst->Angriness = src->Angriness; + dst->TimeLost = src->TimeLost; OpenRCT2::RideUse::GetHistory().Set(dst->sprite_index, RCT12GetRidesBeenOn(src)); OpenRCT2::RideUse::GetTypeHistory().Set(dst->sprite_index, RCT12GetRideTypesBeenOn(src)); - dst->Photo1RideRef = RCT12RideIdToOpenRCT2RideId(src->photo1_ride_ref); + dst->Photo1RideRef = RCT12RideIdToOpenRCT2RideId(src->Photo1RideRef); - for (size_t i = 0; i < std::size(src->thoughts); i++) + 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) @@ -2886,17 +2888,17 @@ namespace RCT1 dstThought->fresh_timeout = srcThought->fresh_timeout; } - dst->PreviousRide = RCT12RideIdToOpenRCT2RideId(src->previous_ride); - dst->PreviousRideTimeOut = src->previous_ride_time_out; - dst->GuestHeadingToRideId = RCT12RideIdToOpenRCT2RideId(src->guest_heading_to_ride_id); - dst->GuestIsLostCountdown = src->peep_is_lost_countdown; - dst->GuestNextInQueue = EntityId::FromUnderlying(src->next_in_queue); + dst->PreviousRide = RCT12RideIdToOpenRCT2RideId(src->PreviousRide); + dst->PreviousRideTimeOut = src->PreviousRideTimeOut; + dst->GuestHeadingToRideId = RCT12RideIdToOpenRCT2RideId(src->GuestHeadingToRideID); + dst->GuestIsLostCountdown = src->PeepIsLostCountdown; + dst->GuestNextInQueue = EntityId::FromUnderlying(src->NextInQueue); // Guests' favourite ride was only saved in LL. // Set it to N/A if the save comes from the original or AA. if (_gameVersion == FILE_VERSION_RCT1_LL) { - dst->FavouriteRide = RCT12RideIdToOpenRCT2RideId(src->favourite_ride); - dst->FavouriteRideRating = src->favourite_ride_rating; + dst->FavouriteRide = RCT12RideIdToOpenRCT2RideId(src->FavouriteRide); + dst->FavouriteRideRating = src->FavouriteRideRating; } else { @@ -2921,17 +2923,17 @@ namespace RCT1 auto* dst = CreateEntityAt(EntityId::FromUnderlying(srcBase.sprite_index)); auto* src = static_cast(&srcBase); ImportPeep(dst, src); - dst->AssignedStaffType = StaffType(src->staff_type); - dst->MechanicTimeSinceCall = src->mechanic_time_since_call; - 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->AssignedStaffType = StaffType(src->StaffType); + dst->MechanicTimeSinceCall = src->MechanicTimeSinceCall; + 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 S4Importer::ImportEntity(const RCT12SpriteBase& srcBase) diff --git a/src/openrct2/rct1/T4Importer.cpp b/src/openrct2/rct1/T4Importer.cpp index d709b5c590..b0b1fc2d5d 100644 --- a/src/openrct2/rct1/T4Importer.cpp +++ b/src/openrct2/rct1/T4Importer.cpp @@ -89,12 +89,12 @@ namespace RCT1 for (int32_t i = 0; i < Limits::NumColourSchemes; i++) { - td->track_spine_colour[i] = RCT1::GetColour(td4aa.track_spine_colour[i]); - td->track_rail_colour[i] = RCT1::GetColour(td4aa.track_rail_colour[i]); - td->track_support_colour[i] = RCT1::GetColour(td4aa.track_support_colour[i]); + td->track_spine_colour[i] = RCT1::GetColour(td4aa.TrackSpineColour[i]); + td->track_rail_colour[i] = RCT1::GetColour(td4aa.TrackRailColour[i]); + td->track_support_colour[i] = RCT1::GetColour(td4aa.TrackSupportColour[i]); } - td->flags2 = td4aa.flags2; + td->flags2 = td4aa.Flags2; return ImportTD4Base(std::move(td), td4aa); } @@ -106,16 +106,16 @@ namespace RCT1 _stream.Read(&td4, sizeof(TD4)); for (int32_t i = 0; i < OpenRCT2::Limits::NumColourSchemes; i++) { - td->track_spine_colour[i] = RCT1::GetColour(td4.track_spine_colour_v0); - td->track_rail_colour[i] = RCT1::GetColour(td4.track_rail_colour_v0); - td->track_support_colour[i] = RCT1::GetColour(td4.track_support_colour_v0); + td->track_spine_colour[i] = RCT1::GetColour(td4.TrackSpineColourV0); + td->track_rail_colour[i] = RCT1::GetColour(td4.TrackRailColourV0); + td->track_support_colour[i] = RCT1::GetColour(td4.TrackSupportColourV0); // Mazes were only hedges - if (td4.type == RideType::HedgeMaze) + if (td4.Type == RideType::HedgeMaze) { td->track_support_colour[i] = MAZE_WALL_TYPE_HEDGE; } - else if (td4.type == RideType::RiverRapids) + else if (td4.Type == RideType::RiverRapids) { td->track_spine_colour[i] = COLOUR_WHITE; td->track_rail_colour[i] = COLOUR_WHITE; @@ -127,45 +127,45 @@ namespace RCT1 std::unique_ptr ImportTD4Base(std::unique_ptr td, TD4& td4Base) { - td->type = RCT1::GetRideType(td4Base.type, td4Base.vehicle_type); + td->type = RCT1::GetRideType(td4Base.Type, td4Base.VehicleType); // All TD4s that use powered launch use the type that doesn't pass the station. - td->ride_mode = static_cast(td4Base.mode); - if (td4Base.mode == RCT1_RIDE_MODE_POWERED_LAUNCH) + td->ride_mode = static_cast(td4Base.Mode); + if (td4Base.Mode == RCT1_RIDE_MODE_POWERED_LAUNCH) { td->ride_mode = RideMode::PoweredLaunch; } // Convert RCT1 vehicle type to RCT2 vehicle type. Initialise with a string consisting of 8 spaces. std::string_view vehicleObject; - if (td4Base.type == RideType::HedgeMaze) + if (td4Base.Type == RideType::HedgeMaze) { - vehicleObject = RCT1::GetRideTypeObject(td4Base.type); + vehicleObject = RCT1::GetRideTypeObject(td4Base.Type); } else { - vehicleObject = RCT1::GetVehicleObject(td4Base.vehicle_type); + vehicleObject = RCT1::GetVehicleObject(td4Base.VehicleType); } assert(!vehicleObject.empty()); td->vehicle_object = ObjectEntryDescriptor(vehicleObject); - td->vehicle_type = td4Base.vehicle_type; + td->vehicle_type = td4Base.VehicleType; - td->flags = td4Base.flags; - td->colour_scheme = td4Base.version_and_colour_scheme & 0x3; + td->flags = td4Base.Flags; + td->colour_scheme = td4Base.VersionAndColourScheme & 0x3; // Vehicle colours for (int32_t i = 0; i < Limits::MaxTrainsPerRide; i++) { // RCT1 had no third colour RCT1::VehicleColourSchemeCopyDescriptor colourSchemeCopyDescriptor = RCT1::GetColourSchemeCopyDescriptor( - td4Base.vehicle_type); + td4Base.VehicleType); if (colourSchemeCopyDescriptor.colour1 == COPY_COLOUR_1) { - td->vehicle_colours[i].Body = RCT1::GetColour(td4Base.vehicle_colours[i].body_colour); + td->vehicle_colours[i].Body = RCT1::GetColour(td4Base.VehicleColours[i].body_colour); } else if (colourSchemeCopyDescriptor.colour1 == COPY_COLOUR_2) { - td->vehicle_colours[i].Body = RCT1::GetColour(td4Base.vehicle_colours[i].trim_colour); + td->vehicle_colours[i].Body = RCT1::GetColour(td4Base.VehicleColours[i].trim_colour); } else { @@ -174,11 +174,11 @@ namespace RCT1 if (colourSchemeCopyDescriptor.colour2 == COPY_COLOUR_1) { - td->vehicle_colours[i].Trim = RCT1::GetColour(td4Base.vehicle_colours[i].body_colour); + td->vehicle_colours[i].Trim = RCT1::GetColour(td4Base.VehicleColours[i].body_colour); } else if (colourSchemeCopyDescriptor.colour2 == COPY_COLOUR_2) { - td->vehicle_colours[i].Trim = RCT1::GetColour(td4Base.vehicle_colours[i].trim_colour); + td->vehicle_colours[i].Trim = RCT1::GetColour(td4Base.VehicleColours[i].trim_colour); } else { @@ -187,11 +187,11 @@ namespace RCT1 if (colourSchemeCopyDescriptor.colour3 == COPY_COLOUR_1) { - td->vehicle_colours[i].Tertiary = RCT1::GetColour(td4Base.vehicle_colours[i].body_colour); + td->vehicle_colours[i].Tertiary = RCT1::GetColour(td4Base.VehicleColours[i].body_colour); } else if (colourSchemeCopyDescriptor.colour3 == COPY_COLOUR_2) { - td->vehicle_colours[i].Tertiary = RCT1::GetColour(td4Base.vehicle_colours[i].trim_colour); + td->vehicle_colours[i].Tertiary = RCT1::GetColour(td4Base.VehicleColours[i].trim_colour); } else { @@ -204,35 +204,35 @@ namespace RCT1 td->vehicle_colours[i] = td->vehicle_colours[0]; } - td->depart_flags = td4Base.depart_flags; - td->number_of_trains = td4Base.number_of_trains; - td->number_of_cars_per_train = td4Base.number_of_cars_per_train; - td->min_waiting_time = td4Base.min_waiting_time; - td->max_waiting_time = td4Base.max_waiting_time; + td->depart_flags = td4Base.DepartFlags; + td->number_of_trains = td4Base.NumberOfTrains; + td->number_of_cars_per_train = td4Base.NumberOfCarsPerTrain; + td->min_waiting_time = td4Base.MinWaitingTime; + td->max_waiting_time = td4Base.MaxWaitingTime; td->operation_setting = std::min( - td4Base.operation_setting, GetRideTypeDescriptor(td->type).OperatingSettings.MaxValue); - td->max_speed = td4Base.max_speed; - td->average_speed = td4Base.average_speed; - td->ride_length = td4Base.ride_length; - td->max_positive_vertical_g = td4Base.max_positive_vertical_g; - td->max_negative_vertical_g = td4Base.max_negative_vertical_g; - td->max_lateral_g = td4Base.max_lateral_g; + td4Base.OperationSetting, GetRideTypeDescriptor(td->type).OperatingSettings.MaxValue); + td->max_speed = td4Base.MaxSpeed; + td->average_speed = td4Base.AverageSpeed; + td->ride_length = td4Base.RideLength; + td->max_positive_vertical_g = td4Base.MaxPositiveVerticalG; + td->max_negative_vertical_g = td4Base.MaxNegativeVerticalG; + td->max_lateral_g = td4Base.MaxLateralG; if (td->type == RIDE_TYPE_MINI_GOLF) { - td->holes = td4Base.num_holes; + td->holes = td4Base.NumHoles; } else { - td->inversions = td4Base.num_inversions; + td->inversions = td4Base.NumInversions; } - td->drops = td4Base.num_drops; - td->highest_drop_height = td4Base.highest_drop_height / 2; - td->excitement = td4Base.excitement; - td->intensity = td4Base.intensity; - td->nausea = td4Base.nausea; - td->upkeep_cost = td4Base.upkeep_cost; + td->drops = td4Base.NumDrops; + td->highest_drop_height = td4Base.HighestDropHeight / 2; + td->excitement = td4Base.Excitement; + td->intensity = td4Base.Intensity; + td->nausea = td4Base.Nausea; + td->upkeep_cost = td4Base.UpkeepCost; td->space_required_x = 255; td->space_required_y = 255; td->lift_hill_speed = 5;