clang-format root

src/openrct2-cli/Cli.cpp

@@ -9,15 +9,14 @@
 
 #include <openrct2/Context.h>
 #include <openrct2/OpenRCT2.h>
-
 #include <openrct2/platform/platform.h>
 
 using namespace OpenRCT2;
 
 /**
-* Main entry point for non-Windows sytems. Windows instead uses its own DLL proxy.
+ * Main entry point for non-Windows sytems. Windows instead uses its own DLL proxy.
-*/
+ */
-int main(int argc, const char * * argv)
+int main(int argc, const char** argv)
 {
     int runGame = cmdline_run(argv, argc);
     core_init();

src/openrct2-dll/openrct2-dll.cpp

@@ -13,47 +13,46 @@
 #undef CreateWindow
 
 // Then the rest
+#include <openrct2-ui/Ui.h>
+#include <openrct2-ui/UiContext.h>
+#include <openrct2-ui/audio/AudioContext.h>
+#include <openrct2/Context.h>
+#include <openrct2/OpenRCT2.h>
+#include <openrct2/audio/AudioContext.h>
+#include <openrct2/ui/UiContext.h>
 #include <shellapi.h>
 #include <stdio.h>
 #include <stdlib.h>
 
-#include <openrct2/audio/AudioContext.h>
-#include <openrct2/Context.h>
-#include <openrct2/OpenRCT2.h>
-#include <openrct2/ui/UiContext.h>
-#include <openrct2-ui/audio/AudioContext.h>
-#include <openrct2-ui/Ui.h>
-#include <openrct2-ui/UiContext.h>
-
 using namespace OpenRCT2;
 using namespace OpenRCT2::Audio;
 using namespace OpenRCT2::Ui;
 
 #define DLLEXPORT extern "C" __declspec(dllexport)
 
-static char * * GetCommandLineArgs(int argc, wchar_t * * argvW);
+static char** GetCommandLineArgs(int argc, wchar_t** argvW);
-static void FreeCommandLineArgs(int argc, char * * argv);
+static void FreeCommandLineArgs(int argc, char** argv);
-static char * ConvertUTF16toUTF8(const wchar_t * src);
+static char* ConvertUTF16toUTF8(const wchar_t* src);
 
-DLLEXPORT int LaunchOpenRCT2(int argc, wchar_t * * argvW)
+DLLEXPORT int LaunchOpenRCT2(int argc, wchar_t** argvW)
 {
-    char * * argv = GetCommandLineArgs(argc, argvW);
+    char** argv = GetCommandLineArgs(argc, argvW);
     if (argv == nullptr)
     {
         puts("Unable to fetch command line arguments.");
         return -1;
     }
 
-    int exitCode = NormalisedMain(argc, const_cast<const char * *>(argv));
+    int exitCode = NormalisedMain(argc, const_cast<const char**>(argv));
 
     FreeCommandLineArgs(argc, argv);
     return exitCode;
 }
 
-static char * * GetCommandLineArgs(int argc, wchar_t * * argvW)
+static char** GetCommandLineArgs(int argc, wchar_t** argvW)
 {
     // Allocate UTF-8 strings
-    char * * argv = (char * *)malloc(argc * sizeof(char *));
+    char** argv = (char**)malloc(argc * sizeof(char*));
     if (argv == nullptr)
     {
         return nullptr;
@@ -68,7 +67,7 @@ static char * * GetCommandLineArgs(int argc, wchar_t * * argvW)
     return argv;
 }
 
-static void FreeCommandLineArgs(int argc, char * * argv)
+static void FreeCommandLineArgs(int argc, char** argv)
 {
     // Free argv
     for (int i = 0; i < argc; i++)
@@ -78,11 +77,11 @@ static void FreeCommandLineArgs(int argc, char * * argv)
     free(argv);
 }
 
-static char * ConvertUTF16toUTF8(const wchar_t * src)
+static char* ConvertUTF16toUTF8(const wchar_t* src)
 {
     int srcLen = lstrlenW(src);
     int sizeReq = WideCharToMultiByte(CP_UTF8, 0, src, srcLen, nullptr, 0, nullptr, nullptr);
-    char * result = (char *)calloc(1, sizeReq + 1);
+    char* result = (char*)calloc(1, sizeReq + 1);
     WideCharToMultiByte(CP_UTF8, 0, src, srcLen, result, sizeReq, nullptr, nullptr);
     return result;
 }

src/openrct2-win/openrct2-win.cpp

@@ -12,15 +12,17 @@
 #include <windows.h>
 
 // Enable visual styles
-#pragma comment(linker, "\"/manifestdependency:type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='*' publicKeyToken='6595b64144ccf1df' language='*'\"")
+#pragma comment(                                                                                                               \
+    linker,                                                                                                                    \
+    "\"/manifestdependency:type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='*' publicKeyToken='6595b64144ccf1df' language='*'\"")
 
 #define DLLIMPORT extern "C"
-DLLIMPORT int LaunchOpenRCT2(int argc, wchar_t * * argv);
+DLLIMPORT int LaunchOpenRCT2(int argc, wchar_t** argv);
 
 /**
  * Windows entry point to OpenRCT2 with a console window using a traditional C main function.
  */
-int wmain(int argc, wchar_t * * argvW, [[maybe_unused]] wchar_t * envp)
+int wmain(int argc, wchar_t** argvW, [[maybe_unused]] wchar_t* envp)
 {
     return LaunchOpenRCT2(argc, argvW);
 }

src/openrct2/Cheats.cpp

@@ -7,10 +7,11 @@
  * OpenRCT2 is licensed under the GNU General Public License version 3.
  *****************************************************************************/
 
-#include "actions/ParkSetLoanAction.hpp"
 #include "Cheats.h"
-#include "config/Config.h"
+
 #include "GameState.h"
+#include "actions/ParkSetLoanAction.hpp"
+#include "config/Config.h"
 #include "localisation/Localisation.h"
 #include "network/network.h"
 #include "ride/Ride.h"
@@ -58,10 +59,12 @@ int32_t day_spinner_value = 1;
 static void cheat_set_grass_length(int32_t length)
 {
     int32_t x, y;
-    rct_tile_element *tileElement;
+    rct_tile_element* tileElement;
 
-    for (y = 0; y < MAXIMUM_MAP_SIZE_TECHNICAL; y++) {
+    for (y = 0; y < MAXIMUM_MAP_SIZE_TECHNICAL; y++)
-        for (x = 0; x < MAXIMUM_MAP_SIZE_TECHNICAL; x++) {
+    {
+        for (x = 0; x < MAXIMUM_MAP_SIZE_TECHNICAL; x++)
+        {
             tileElement = map_get_surface_element_at(x, y);
             if (!(tileElement->properties.surface.ownership & OWNERSHIP_OWNED))
                 continue;
@@ -84,8 +87,10 @@ static void cheat_water_plants()
     tile_element_iterator it;
 
     tile_element_iterator_begin(&it);
-    do {
+    do
-        if (it.element->GetType() == TILE_ELEMENT_TYPE_SMALL_SCENERY) {
+    {
+        if (it.element->GetType() == TILE_ELEMENT_TYPE_SMALL_SCENERY)
+        {
             it.element->properties.scenery.age = 0;
         }
     } while (tile_element_iterator_next(&it));
@@ -98,7 +103,8 @@ static void cheat_fix_vandalism()
     tile_element_iterator it;
 
     tile_element_iterator_begin(&it);
-    do {
+    do
+    {
         if (it.element->GetType() != TILE_ELEMENT_TYPE_PATH)
             continue;
 
@@ -116,17 +122,19 @@ static void cheat_remove_litter()
     rct_litter* litter;
     uint16_t spriteIndex, nextSpriteIndex;
 
-    for (spriteIndex = gSpriteListHead[SPRITE_LIST_LITTER]; spriteIndex != SPRITE_INDEX_NULL; spriteIndex = nextSpriteIndex) {
+    for (spriteIndex = gSpriteListHead[SPRITE_LIST_LITTER]; spriteIndex != SPRITE_INDEX_NULL; spriteIndex = nextSpriteIndex)
+    {
         litter = &(get_sprite(spriteIndex)->litter);
         nextSpriteIndex = litter->next;
         sprite_remove((rct_sprite*)litter);
     }
 
     tile_element_iterator it;
-    rct_scenery_entry *sceneryEntry;
+    rct_scenery_entry* sceneryEntry;
 
     tile_element_iterator_begin(&it);
-    do {
+    do
+    {
         if (it.element->GetType() != TILE_ELEMENT_TYPE_PATH)
             continue;
 
@@ -145,16 +153,18 @@ static void cheat_remove_litter()
 static void cheat_fix_rides()
 {
     int32_t rideIndex;
-    Ride *ride;
+    Ride* ride;
-    rct_peep *mechanic;
+    rct_peep* mechanic;
 
-    FOR_ALL_RIDES(rideIndex, ride)
+    FOR_ALL_RIDES (rideIndex, ride)
     {
-        if ((ride->mechanic_status != RIDE_MECHANIC_STATUS_FIXING) && (ride->lifecycle_flags & (RIDE_LIFECYCLE_BREAKDOWN_PENDING | RIDE_LIFECYCLE_BROKEN_DOWN)))
+        if ((ride->mechanic_status != RIDE_MECHANIC_STATUS_FIXING)
+            && (ride->lifecycle_flags & (RIDE_LIFECYCLE_BREAKDOWN_PENDING | RIDE_LIFECYCLE_BROKEN_DOWN)))
         {
             mechanic = ride_get_assigned_mechanic(ride);
 
-            if (mechanic != nullptr){
+            if (mechanic != nullptr)
+            {
                 mechanic->RemoveFromRide();
             }
 
@@ -167,9 +177,9 @@ static void cheat_fix_rides()
 static void cheat_renew_rides()
 {
     int32_t i;
-    Ride *ride;
+    Ride* ride;
 
-    FOR_ALL_RIDES(i, ride)
+    FOR_ALL_RIDES (i, ride)
     {
         ride_renew(ride);
     }
@@ -179,13 +189,13 @@ static void cheat_renew_rides()
 static void cheat_make_destructible()
 {
     int32_t i;
-    Ride *ride;
+    Ride* ride;
-    FOR_ALL_RIDES(i, ride)
+    FOR_ALL_RIDES (i, ride)
     {
         if (ride->lifecycle_flags & RIDE_LIFECYCLE_INDESTRUCTIBLE)
-            ride->lifecycle_flags&=~RIDE_LIFECYCLE_INDESTRUCTIBLE;
+            ride->lifecycle_flags &= ~RIDE_LIFECYCLE_INDESTRUCTIBLE;
         if (ride->lifecycle_flags & RIDE_LIFECYCLE_INDESTRUCTIBLE_TRACK)
-            ride->lifecycle_flags&=~RIDE_LIFECYCLE_INDESTRUCTIBLE_TRACK;
+            ride->lifecycle_flags &= ~RIDE_LIFECYCLE_INDESTRUCTIBLE_TRACK;
     }
     window_invalidate_by_class(WC_RIDE);
 }
@@ -193,9 +203,10 @@ static void cheat_make_destructible()
 static void cheat_reset_crash_status()
 {
     int32_t i;
-    Ride *ride;
+    Ride* ride;
 
-    FOR_ALL_RIDES(i, ride){
+    FOR_ALL_RIDES (i, ride)
+    {
         // Reset crash status
         if (ride->lifecycle_flags & RIDE_LIFECYCLE_CRASHED)
             ride->lifecycle_flags &= ~RIDE_LIFECYCLE_CRASHED;
@@ -208,9 +219,10 @@ static void cheat_reset_crash_status()
 static void cheat_10_minute_inspections()
 {
     int32_t i;
-    Ride *ride;
+    Ride* ride;
 
-    FOR_ALL_RIDES(i, ride) {
+    FOR_ALL_RIDES (i, ride)
+    {
         // Set inspection interval to 10 minutes
         ride->inspection_interval = RIDE_INSPECTION_EVERY_10_MINUTES;
     }
@@ -219,10 +231,12 @@ static void cheat_10_minute_inspections()
 
 static void cheat_no_money(bool enabled)
 {
-    if (enabled) {
+    if (enabled)
+    {
         gParkFlags |= PARK_FLAGS_NO_MONEY;
     }
-    else {
+    else
+    {
         gParkFlags &= ~PARK_FLAGS_NO_MONEY;
     }
     // Invalidate all windows that have anything to do with finance
@@ -274,59 +288,61 @@ static void cheat_generate_guests(int32_t count)
 static void cheat_set_guest_parameter(int32_t parameter, int32_t value)
 {
     int32_t spriteIndex;
-    rct_peep *peep;
+    rct_peep* peep;
 
-    FOR_ALL_GUESTS(spriteIndex, peep) {
+    FOR_ALL_GUESTS (spriteIndex, peep)
-        switch(parameter) {
+    {
-        case GUEST_PARAMETER_HAPPINESS:
+        switch (parameter)
-            peep->happiness = value;
+        {
-            peep->happiness_target = value;
+            case GUEST_PARAMETER_HAPPINESS:
-            // Clear the 'red-faced with anger' status if we're making the guest happy
+                peep->happiness = value;
-            if (value > 0)
+                peep->happiness_target = value;
-            {
+                // Clear the 'red-faced with anger' status if we're making the guest happy
-                peep->peep_flags &= ~PEEP_FLAGS_ANGRY;
+                if (value > 0)
-                peep->angriness = 0;
+                {
-            }
+                    peep->peep_flags &= ~PEEP_FLAGS_ANGRY;
-            break;
+                    peep->angriness = 0;
-        case GUEST_PARAMETER_ENERGY:
+                }
-            peep->energy = value;
+                break;
-            peep->energy_target = value;
+            case GUEST_PARAMETER_ENERGY:
-            break;
+                peep->energy = value;
-        case GUEST_PARAMETER_HUNGER:
+                peep->energy_target = value;
-            peep->hunger = value;
+                break;
-            break;
+            case GUEST_PARAMETER_HUNGER:
-        case GUEST_PARAMETER_THIRST:
+                peep->hunger = value;
-            peep->thirst = value;
+                break;
-            break;
+            case GUEST_PARAMETER_THIRST:
-        case GUEST_PARAMETER_NAUSEA:
+                peep->thirst = value;
-            peep->nausea = value;
+                break;
-            peep->nausea_target = value;
+            case GUEST_PARAMETER_NAUSEA:
-            break;
+                peep->nausea = value;
-        case GUEST_PARAMETER_NAUSEA_TOLERANCE:
+                peep->nausea_target = value;
-            peep->nausea_tolerance = value;
+                break;
-            break;
+            case GUEST_PARAMETER_NAUSEA_TOLERANCE:
-        case GUEST_PARAMETER_BATHROOM:
+                peep->nausea_tolerance = value;
-            peep->toilet = value;
+                break;
-            break;
+            case GUEST_PARAMETER_BATHROOM:
-        case GUEST_PARAMETER_PREFERRED_RIDE_INTENSITY:
+                peep->toilet = value;
-            peep->intensity = (15 << 4) | value;
+                break;
-            break;
+            case GUEST_PARAMETER_PREFERRED_RIDE_INTENSITY:
+                peep->intensity = (15 << 4) | value;
+                break;
         }
         peep->UpdateSpriteType();
     }
-
 }
 
 static void cheat_give_all_guests(int32_t object)
 {
     int32_t spriteIndex;
-    rct_peep *peep;
+    rct_peep* peep;
 
-    FOR_ALL_GUESTS(spriteIndex, peep) {
+    FOR_ALL_GUESTS (spriteIndex, peep)
-        switch(object)
+    {
+        switch (object)
         {
             case OBJECT_MONEY:
-                peep->cash_in_pocket = MONEY(1000,00);
+                peep->cash_in_pocket = MONEY(1000, 00);
                 break;
             case OBJECT_PARK_MAP:
                 peep->item_standard_flags |= PEEP_ITEM_MAP;
@@ -348,13 +364,13 @@ static void cheat_give_all_guests(int32_t object)
 
 static void cheat_remove_all_guests()
 {
-    rct_peep *peep;
+    rct_peep* peep;
-    rct_vehicle *vehicle;
+    rct_vehicle* vehicle;
     uint16_t spriteIndex, nextSpriteIndex;
     int32_t rideIndex;
-    Ride *ride;
+    Ride* ride;
 
-    FOR_ALL_RIDES(rideIndex, ride)
+    FOR_ALL_RIDES (rideIndex, ride)
     {
         ride->num_riders = 0;
 
@@ -370,7 +386,7 @@ static void cheat_remove_all_guests()
             while (spriteIndex != SPRITE_INDEX_NULL)
             {
                 vehicle = GET_VEHICLE(spriteIndex);
-                for (size_t i = 0, offset = 0; i < vehicle->num_peeps; i++) 
+                for (size_t i = 0, offset = 0; i < vehicle->num_peeps; i++)
                 {
                     while (vehicle->peep[i + offset] == SPRITE_INDEX_NULL)
                     {
@@ -380,7 +396,7 @@ static void cheat_remove_all_guests()
                     vehicle->mass -= peep->mass;
                 }
 
-                for (auto &peepInTrainIndex : vehicle->peep)
+                for (auto& peepInTrainIndex : vehicle->peep)
                 {
                     peepInTrainIndex = SPRITE_INDEX_NULL;
                 }
@@ -393,10 +409,12 @@ static void cheat_remove_all_guests()
         }
     }
 
-    for (spriteIndex = gSpriteListHead[SPRITE_LIST_PEEP]; spriteIndex != SPRITE_INDEX_NULL; spriteIndex = nextSpriteIndex) {
+    for (spriteIndex = gSpriteListHead[SPRITE_LIST_PEEP]; spriteIndex != SPRITE_INDEX_NULL; spriteIndex = nextSpriteIndex)
+    {
         peep = &(get_sprite(spriteIndex)->peep);
         nextSpriteIndex = peep->next;
-        if (peep->type == PEEP_TYPE_GUEST) {
+        if (peep->type == PEEP_TYPE_GUEST)
+        {
             peep->Remove();
         }
     }
@@ -408,10 +426,12 @@ static void cheat_remove_all_guests()
 static void cheat_explode_guests()
 {
     int32_t sprite_index;
-    rct_peep *peep;
+    rct_peep* peep;
 
-    FOR_ALL_GUESTS(sprite_index, peep) {
+    FOR_ALL_GUESTS (sprite_index, peep)
-        if (scenario_rand_max(6) == 0) {
+    {
+        if (scenario_rand_max(6) == 0)
+        {
             peep->peep_flags |= PEEP_FLAGS_EXPLODE;
         }
     }
@@ -420,9 +440,10 @@ static void cheat_explode_guests()
 static void cheat_set_staff_speed(uint8_t value)
 {
     uint16_t spriteIndex;
-    rct_peep *peep;
+    rct_peep* peep;
 
-    FOR_ALL_STAFF(spriteIndex, peep) {
+    FOR_ALL_STAFF (spriteIndex, peep)
+    {
         peep->energy = value;
         peep->energy_target = value;
     }
@@ -433,9 +454,11 @@ static void cheat_own_all_land()
     const int32_t min = 32;
     const int32_t max = gMapSizeUnits - 32;
 
-    for (CoordsXY coords = {min, min}; coords.y <= max; coords.y += 32) {
+    for (CoordsXY coords = { min, min }; coords.y <= max; coords.y += 32)
-        for (coords.x = min; coords.x <= max; coords.x += 32) {
+    {
-            rct_tile_element * surfaceElement = map_get_surface_element_at(coords);
+        for (coords.x = min; coords.x <= max; coords.x += 32)
+        {
+            rct_tile_element* surfaceElement = map_get_surface_element_at(coords);
 
             // Ignore already owned tiles.
             if (surfaceElement->properties.surface.ownership & OWNERSHIP_OWNED)
@@ -445,7 +468,8 @@ static void cheat_own_all_land()
             int32_t destOwnership = check_max_allowable_land_rights_for_tile(coords.x >> 5, coords.y >> 5, base_z);
 
             // only own tiles that were not set to 0
-            if (destOwnership != OWNERSHIP_UNOWNED) {
+            if (destOwnership != OWNERSHIP_UNOWNED)
+            {
                 surfaceElement->properties.surface.ownership |= destOwnership;
                 update_park_fences_around_tile(coords);
                 uint16_t baseHeight = surfaceElement->base_height * 8;
@@ -455,13 +479,15 @@ static void cheat_own_all_land()
     }
 
     // Completely unown peep spawn points
-    for (const auto &spawn : gPeepSpawns) {
+    for (const auto& spawn : gPeepSpawns)
+    {
         int32_t x = spawn.x;
         int32_t y = spawn.y;
-        if (x != PEEP_SPAWN_UNDEFINED) {
+        if (x != PEEP_SPAWN_UNDEFINED)
-            rct_tile_element * surfaceElement = map_get_surface_element_at({x, y});
+        {
+            rct_tile_element* surfaceElement = map_get_surface_element_at({ x, y });
             surfaceElement->properties.surface.ownership = OWNERSHIP_UNOWNED;
-            update_park_fences_around_tile({x, y});
+            update_park_fences_around_tile({ x, y });
             uint16_t baseHeight = surfaceElement->base_height * 8;
             map_invalidate_tile(x, y, baseHeight, baseHeight + 16);
         }
@@ -473,68 +499,171 @@ static void cheat_own_all_land()
 #pragma endregion
 
 void game_command_cheat(
-    [[maybe_unused]] int32_t * eax,
+    [[maybe_unused]] int32_t* eax,
-    int32_t *                  ebx,
+    int32_t* ebx,
-    int32_t *                  ecx,
+    int32_t* ecx,
-    int32_t *                  edx,
+    int32_t* edx,
-    [[maybe_unused]] int32_t * esi,
+    [[maybe_unused]] int32_t* esi,
-    int32_t *                  edi,
+    int32_t* edi,
-    [[maybe_unused]] int32_t * ebp)
+    [[maybe_unused]] int32_t* ebp)
 {
     int32_t cheat = *ecx;
     if (*ebx & GAME_COMMAND_FLAG_APPLY)
     {
         switch (cheat)
         {
-        case CHEAT_SANDBOXMODE: gCheatsSandboxMode = *edx != 0; window_invalidate_by_class(WC_MAP); window_invalidate_by_class(WC_FOOTPATH); break;
+            case CHEAT_SANDBOXMODE:
-        case CHEAT_DISABLECLEARANCECHECKS: gCheatsDisableClearanceChecks = *edx != 0; break;
+                gCheatsSandboxMode = *edx != 0;
-        case CHEAT_DISABLESUPPORTLIMITS: gCheatsDisableSupportLimits = *edx != 0; break;
+                window_invalidate_by_class(WC_MAP);
-        case CHEAT_SHOWALLOPERATINGMODES: gCheatsShowAllOperatingModes = *edx != 0; break;
+                window_invalidate_by_class(WC_FOOTPATH);
-        case CHEAT_SHOWVEHICLESFROMOTHERTRACKTYPES: gCheatsShowVehiclesFromOtherTrackTypes = *edx != 0; break;
+                break;
-        case CHEAT_FASTLIFTHILL: gCheatsFastLiftHill = *edx != 0; break;
+            case CHEAT_DISABLECLEARANCECHECKS:
-        case CHEAT_DISABLEBRAKESFAILURE: gCheatsDisableBrakesFailure = *edx != 0; break;
+                gCheatsDisableClearanceChecks = *edx != 0;
-        case CHEAT_DISABLEALLBREAKDOWNS: gCheatsDisableAllBreakdowns = *edx != 0; break;
+                break;
-        case CHEAT_DISABLETRAINLENGTHLIMIT: gCheatsDisableTrainLengthLimit = *edx != 0; break;
+            case CHEAT_DISABLESUPPORTLIMITS:
-        case CHEAT_ENABLECHAINLIFTONALLTRACK: gCheatsEnableChainLiftOnAllTrack = *edx != 0; break;
+                gCheatsDisableSupportLimits = *edx != 0;
-        case CHEAT_BUILDINPAUSEMODE: gCheatsBuildInPauseMode = *edx != 0; break;
+                break;
-        case CHEAT_IGNORERIDEINTENSITY: gCheatsIgnoreRideIntensity = *edx != 0; break;
+            case CHEAT_SHOWALLOPERATINGMODES:
-        case CHEAT_DISABLEVANDALISM: gCheatsDisableVandalism = *edx != 0; break;
+                gCheatsShowAllOperatingModes = *edx != 0;
-        case CHEAT_DISABLELITTERING: gCheatsDisableLittering = *edx != 0; break;
+                break;
-        case CHEAT_NOMONEY: cheat_no_money(*edx != 0); break;
+            case CHEAT_SHOWVEHICLESFROMOTHERTRACKTYPES:
-        case CHEAT_ADDMONEY: cheat_add_money(*edx); break;
+                gCheatsShowVehiclesFromOtherTrackTypes = *edx != 0;
-        case CHEAT_SETMONEY: cheat_set_money(*edx); break;
+                break;
-        case CHEAT_CLEARLOAN: cheat_clear_loan(); break;
+            case CHEAT_FASTLIFTHILL:
-        case CHEAT_SETGUESTPARAMETER: cheat_set_guest_parameter(*edx, *edi); break;
+                gCheatsFastLiftHill = *edx != 0;
-        case CHEAT_GENERATEGUESTS: cheat_generate_guests(*edx); break;
+                break;
-        case CHEAT_REMOVEALLGUESTS: cheat_remove_all_guests(); break;
+            case CHEAT_DISABLEBRAKESFAILURE:
-        case CHEAT_EXPLODEGUESTS: cheat_explode_guests(); break;
+                gCheatsDisableBrakesFailure = *edx != 0;
-        case CHEAT_GIVEALLGUESTS: cheat_give_all_guests(*edx); break;
+                break;
-        case CHEAT_SETGRASSLENGTH: cheat_set_grass_length(*edx); break;
+            case CHEAT_DISABLEALLBREAKDOWNS:
-        case CHEAT_WATERPLANTS: cheat_water_plants(); break;
+                gCheatsDisableAllBreakdowns = *edx != 0;
-        case CHEAT_FIXVANDALISM: cheat_fix_vandalism(); break;
+                break;
-        case CHEAT_REMOVELITTER: cheat_remove_litter(); break;
+            case CHEAT_DISABLETRAINLENGTHLIMIT:
-        case CHEAT_DISABLEPLANTAGING: gCheatsDisablePlantAging = *edx != 0; break;
+                gCheatsDisableTrainLengthLimit = *edx != 0;
-        case CHEAT_SETSTAFFSPEED: cheat_set_staff_speed(*edx); break;
+                break;
-        case CHEAT_RENEWRIDES: cheat_renew_rides(); break;
+            case CHEAT_ENABLECHAINLIFTONALLTRACK:
-        case CHEAT_MAKEDESTRUCTIBLE: cheat_make_destructible(); break;
+                gCheatsEnableChainLiftOnAllTrack = *edx != 0;
-        case CHEAT_FIXRIDES: cheat_fix_rides(); break;
+                break;
-        case CHEAT_RESETCRASHSTATUS: cheat_reset_crash_status(); break;
+            case CHEAT_BUILDINPAUSEMODE:
-        case CHEAT_10MINUTEINSPECTIONS: cheat_10_minute_inspections(); break;
+                gCheatsBuildInPauseMode = *edx != 0;
-        case CHEAT_WINSCENARIO: scenario_success(); break;
+                break;
-        case CHEAT_FORCEWEATHER: climate_force_weather(*edx); break;
+            case CHEAT_IGNORERIDEINTENSITY:
-        case CHEAT_FREEZECLIMATE: gCheatsFreezeClimate = *edx != 0; break;
+                gCheatsIgnoreRideIntensity = *edx != 0;
-        case CHEAT_NEVERENDINGMARKETING: gCheatsNeverendingMarketing = *edx != 0; break;
+                break;
-        case CHEAT_OPENCLOSEPARK: park_set_open(park_is_open() ? 0 : 1); break;
+            case CHEAT_DISABLEVANDALISM:
-        case CHEAT_HAVEFUN: gScenarioObjectiveType = OBJECTIVE_HAVE_FUN; break;
+                gCheatsDisableVandalism = *edx != 0;
-        case CHEAT_SETFORCEDPARKRATING: if(*edx > -1) { park_rating_spinner_value = *edx; } set_forced_park_rating(*edx); break;
+                break;
-        case CHEAT_RESETDATE: date_reset(); window_invalidate_by_class(WC_BOTTOM_TOOLBAR); break;
+            case CHEAT_DISABLELITTERING:
-        case CHEAT_ALLOW_ARBITRARY_RIDE_TYPE_CHANGES: gCheatsAllowArbitraryRideTypeChanges = *edx != 0; window_invalidate_by_class(WC_RIDE); break;
+                gCheatsDisableLittering = *edx != 0;
-        case CHEAT_OWNALLLAND: cheat_own_all_land(); break;
+                break;
-        case CHEAT_DISABLERIDEVALUEAGING: gCheatsDisableRideValueAging = *edx != 0; break;
+            case CHEAT_NOMONEY:
-        case CHEAT_IGNORERESEARCHSTATUS: gCheatsIgnoreResearchStatus = *edx != 0; break;
+                cheat_no_money(*edx != 0);
-        case CHEAT_ENABLEALLDRAWABLETRACKPIECES: gCheatsEnableAllDrawableTrackPieces = *edx != 0; break;
+                break;
+            case CHEAT_ADDMONEY:
+                cheat_add_money(*edx);
+                break;
+            case CHEAT_SETMONEY:
+                cheat_set_money(*edx);
+                break;
+            case CHEAT_CLEARLOAN:
+                cheat_clear_loan();
+                break;
+            case CHEAT_SETGUESTPARAMETER:
+                cheat_set_guest_parameter(*edx, *edi);
+                break;
+            case CHEAT_GENERATEGUESTS:
+                cheat_generate_guests(*edx);
+                break;
+            case CHEAT_REMOVEALLGUESTS:
+                cheat_remove_all_guests();
+                break;
+            case CHEAT_EXPLODEGUESTS:
+                cheat_explode_guests();
+                break;
+            case CHEAT_GIVEALLGUESTS:
+                cheat_give_all_guests(*edx);
+                break;
+            case CHEAT_SETGRASSLENGTH:
+                cheat_set_grass_length(*edx);
+                break;
+            case CHEAT_WATERPLANTS:
+                cheat_water_plants();
+                break;
+            case CHEAT_FIXVANDALISM:
+                cheat_fix_vandalism();
+                break;
+            case CHEAT_REMOVELITTER:
+                cheat_remove_litter();
+                break;
+            case CHEAT_DISABLEPLANTAGING:
+                gCheatsDisablePlantAging = *edx != 0;
+                break;
+            case CHEAT_SETSTAFFSPEED:
+                cheat_set_staff_speed(*edx);
+                break;
+            case CHEAT_RENEWRIDES:
+                cheat_renew_rides();
+                break;
+            case CHEAT_MAKEDESTRUCTIBLE:
+                cheat_make_destructible();
+                break;
+            case CHEAT_FIXRIDES:
+                cheat_fix_rides();
+                break;
+            case CHEAT_RESETCRASHSTATUS:
+                cheat_reset_crash_status();
+                break;
+            case CHEAT_10MINUTEINSPECTIONS:
+                cheat_10_minute_inspections();
+                break;
+            case CHEAT_WINSCENARIO:
+                scenario_success();
+                break;
+            case CHEAT_FORCEWEATHER:
+                climate_force_weather(*edx);
+                break;
+            case CHEAT_FREEZECLIMATE:
+                gCheatsFreezeClimate = *edx != 0;
+                break;
+            case CHEAT_NEVERENDINGMARKETING:
+                gCheatsNeverendingMarketing = *edx != 0;
+                break;
+            case CHEAT_OPENCLOSEPARK:
+                park_set_open(park_is_open() ? 0 : 1);
+                break;
+            case CHEAT_HAVEFUN:
+                gScenarioObjectiveType = OBJECTIVE_HAVE_FUN;
+                break;
+            case CHEAT_SETFORCEDPARKRATING:
+                if (*edx > -1)
+                {
+                    park_rating_spinner_value = *edx;
+                }
+                set_forced_park_rating(*edx);
+                break;
+            case CHEAT_RESETDATE:
+                date_reset();
+                window_invalidate_by_class(WC_BOTTOM_TOOLBAR);
+                break;
+            case CHEAT_ALLOW_ARBITRARY_RIDE_TYPE_CHANGES:
+                gCheatsAllowArbitraryRideTypeChanges = *edx != 0;
+                window_invalidate_by_class(WC_RIDE);
+                break;
+            case CHEAT_OWNALLLAND:
+                cheat_own_all_land();
+                break;
+            case CHEAT_DISABLERIDEVALUEAGING:
+                gCheatsDisableRideValueAging = *edx != 0;
+                break;
+            case CHEAT_IGNORERESEARCHSTATUS:
+                gCheatsIgnoreResearchStatus = *edx != 0;
+                break;
+            case CHEAT_ENABLEALLDRAWABLETRACKPIECES:
+                gCheatsEnableAllDrawableTrackPieces = *edx != 0;
+                break;
         }
-        if (network_get_mode() == NETWORK_MODE_NONE) {
+        if (network_get_mode() == NETWORK_MODE_NONE)
+        {
             config_save_default();
         }
         window_invalidate_by_class(WC_CHEATS);
@@ -566,121 +695,171 @@ void cheats_reset()
     gCheatsIgnoreResearchStatus = false;
 }
 
-//Generates the string to print for the server log when a cheat is used.
+// Generates the string to print for the server log when a cheat is used.
-const char* cheats_get_cheat_string(int cheat, int edx, int edi) {
+const char* cheats_get_cheat_string(int cheat, int edx, int edi)
-    switch (cheat) {
+{
+    switch (cheat)
+    {
         case CHEAT_SANDBOXMODE:
-            if (gCheatsSandboxMode) {
+            if (gCheatsSandboxMode)
+            {
                 return language_get_string(STR_CHEAT_SANDBOX_MODE_DISABLE);
-            } else {
+            }
+            else
+            {
                 return language_get_string(STR_CHEAT_SANDBOX_MODE);
             }
-        case CHEAT_DISABLECLEARANCECHECKS: return language_get_string(STR_DISABLE_CLEARANCE_CHECKS);
+        case CHEAT_DISABLECLEARANCECHECKS:
-        case CHEAT_DISABLESUPPORTLIMITS: return language_get_string(STR_DISABLE_SUPPORT_LIMITS);
+            return language_get_string(STR_DISABLE_CLEARANCE_CHECKS);
-        case CHEAT_SHOWALLOPERATINGMODES: return language_get_string(STR_CHEAT_SHOW_ALL_OPERATING_MODES);
+        case CHEAT_DISABLESUPPORTLIMITS:
-        case CHEAT_SHOWVEHICLESFROMOTHERTRACKTYPES: return language_get_string(STR_CHEAT_SHOW_VEHICLES_FROM_OTHER_TRACK_TYPES);
+            return language_get_string(STR_DISABLE_SUPPORT_LIMITS);
-        case CHEAT_FASTLIFTHILL: return language_get_string(STR_CHEAT_UNLOCK_OPERATING_LIMITS);
+        case CHEAT_SHOWALLOPERATINGMODES:
-        case CHEAT_DISABLEBRAKESFAILURE: return language_get_string(STR_CHEAT_DISABLE_BRAKES_FAILURE);
+            return language_get_string(STR_CHEAT_SHOW_ALL_OPERATING_MODES);
-        case CHEAT_DISABLEALLBREAKDOWNS: return language_get_string(STR_CHEAT_DISABLE_BREAKDOWNS);
+        case CHEAT_SHOWVEHICLESFROMOTHERTRACKTYPES:
-        case CHEAT_DISABLETRAINLENGTHLIMIT: return language_get_string(STR_CHEAT_DISABLE_TRAIN_LENGTH_LIMIT);
+            return language_get_string(STR_CHEAT_SHOW_VEHICLES_FROM_OTHER_TRACK_TYPES);
-        case CHEAT_ENABLECHAINLIFTONALLTRACK: return language_get_string(STR_CHEAT_ENABLE_CHAIN_LIFT_ON_ALL_TRACK);
+        case CHEAT_FASTLIFTHILL:
-        case CHEAT_BUILDINPAUSEMODE: return language_get_string(STR_CHEAT_BUILD_IN_PAUSE_MODE);
+            return language_get_string(STR_CHEAT_UNLOCK_OPERATING_LIMITS);
-        case CHEAT_IGNORERIDEINTENSITY: return language_get_string(STR_CHEAT_IGNORE_INTENSITY);
+        case CHEAT_DISABLEBRAKESFAILURE:
-        case CHEAT_DISABLEVANDALISM: return language_get_string(STR_CHEAT_DISABLE_VANDALISM);
+            return language_get_string(STR_CHEAT_DISABLE_BRAKES_FAILURE);
-        case CHEAT_DISABLELITTERING: return language_get_string(STR_CHEAT_DISABLE_LITTERING);
+        case CHEAT_DISABLEALLBREAKDOWNS:
-        case CHEAT_NOMONEY: return language_get_string(STR_MAKE_PARK_NO_MONEY);
+            return language_get_string(STR_CHEAT_DISABLE_BREAKDOWNS);
-        case CHEAT_ADDMONEY: return language_get_string(STR_LOG_CHEAT_ADD_MONEY);
+        case CHEAT_DISABLETRAINLENGTHLIMIT:
-        case CHEAT_CLEARLOAN: return language_get_string(STR_CHEAT_CLEAR_LOAN);
+            return language_get_string(STR_CHEAT_DISABLE_TRAIN_LENGTH_LIMIT);
+        case CHEAT_ENABLECHAINLIFTONALLTRACK:
+            return language_get_string(STR_CHEAT_ENABLE_CHAIN_LIFT_ON_ALL_TRACK);
+        case CHEAT_BUILDINPAUSEMODE:
+            return language_get_string(STR_CHEAT_BUILD_IN_PAUSE_MODE);
+        case CHEAT_IGNORERIDEINTENSITY:
+            return language_get_string(STR_CHEAT_IGNORE_INTENSITY);
+        case CHEAT_DISABLEVANDALISM:
+            return language_get_string(STR_CHEAT_DISABLE_VANDALISM);
+        case CHEAT_DISABLELITTERING:
+            return language_get_string(STR_CHEAT_DISABLE_LITTERING);
+        case CHEAT_NOMONEY:
+            return language_get_string(STR_MAKE_PARK_NO_MONEY);
+        case CHEAT_ADDMONEY:
+            return language_get_string(STR_LOG_CHEAT_ADD_MONEY);
+        case CHEAT_CLEARLOAN:
+            return language_get_string(STR_CHEAT_CLEAR_LOAN);
         case CHEAT_SETGUESTPARAMETER:
         {
             static char cheat_string[128];
             safe_strcpy(cheat_string, language_get_string(STR_CHEAT_SET_GUESTS_PARAMETERS), 128);
             safe_strcat(cheat_string, " ", 128);
-            switch (edx) {
+            switch (edx)
+            {
                 case GUEST_PARAMETER_HAPPINESS:
                     safe_strcat(cheat_string, language_get_string(STR_CHEAT_GUEST_HAPPINESS), 128);
                     safe_strcat(cheat_string, " ", 128);
-                    if (edi == 255) {
+                    if (edi == 255)
+                    {
                         safe_strcat(cheat_string, language_get_string(STR_MAX), 128);
-                    } else if (edi == 0) {
+                    }
+                    else if (edi == 0)
+                    {
                         safe_strcat(cheat_string, language_get_string(STR_MIN), 128);
                     }
                     break;
                 case GUEST_PARAMETER_ENERGY:
                     safe_strcat(cheat_string, language_get_string(STR_CHEAT_GUEST_ENERGY), 128);
                     safe_strcat(cheat_string, " ", 128);
-                    if (edi == 127) {
+                    if (edi == 127)
+                    {
                         safe_strcat(cheat_string, language_get_string(STR_MAX), 128);
-                    } else if (edi == 0) {
+                    }
+                    else if (edi == 0)
+                    {
                         safe_strcat(cheat_string, language_get_string(STR_MIN), 128);
                     }
                     break;
                 case GUEST_PARAMETER_HUNGER:
                     safe_strcat(cheat_string, language_get_string(STR_CHEAT_GUEST_HUNGER), 128);
                     safe_strcat(cheat_string, " ", 128);
-                    if (edi == 255) {
+                    if (edi == 255)
+                    {
                         safe_strcat(cheat_string, language_get_string(STR_MIN), 128);
-                    } else if (edi == 0) {
+                    }
+                    else if (edi == 0)
+                    {
                         safe_strcat(cheat_string, language_get_string(STR_MAX), 128);
                     }
                     break;
                 case GUEST_PARAMETER_THIRST:
                     safe_strcat(cheat_string, language_get_string(STR_CHEAT_GUEST_THIRST), 128);
                     safe_strcat(cheat_string, " ", 128);
-                    if (edi == 255) {
+                    if (edi == 255)
+                    {
                         safe_strcat(cheat_string, language_get_string(STR_MIN), 128);
-                    } else if (edi == 0) {
+                    }
+                    else if (edi == 0)
+                    {
                         safe_strcat(cheat_string, language_get_string(STR_MAX), 128);
                     }
                     break;
                 case GUEST_PARAMETER_NAUSEA:
                     safe_strcat(cheat_string, language_get_string(STR_CHEAT_GUEST_NAUSEA), 128);
                     safe_strcat(cheat_string, " ", 128);
-                    if (edi == 255) {
+                    if (edi == 255)
+                    {
                         safe_strcat(cheat_string, language_get_string(STR_MAX), 128);
-                    } else if (edi == 0) {
+                    }
+                    else if (edi == 0)
+                    {
                         safe_strcat(cheat_string, language_get_string(STR_MIN), 128);
                     }
                     break;
                 case GUEST_PARAMETER_NAUSEA_TOLERANCE:
                     safe_strcat(cheat_string, language_get_string(STR_CHEAT_GUEST_NAUSEA_TOLERANCE), 128);
                     safe_strcat(cheat_string, " ", 128);
-                    if (edi == PEEP_NAUSEA_TOLERANCE_HIGH) {
+                    if (edi == PEEP_NAUSEA_TOLERANCE_HIGH)
+                    {
                         safe_strcat(cheat_string, language_get_string(STR_MAX), 128);
-                    } else if (edi == PEEP_NAUSEA_TOLERANCE_NONE) {
+                    }
+                    else if (edi == PEEP_NAUSEA_TOLERANCE_NONE)
+                    {
                         safe_strcat(cheat_string, language_get_string(STR_MIN), 128);
                     }
                     break;
                 case GUEST_PARAMETER_BATHROOM:
                     safe_strcat(cheat_string, language_get_string(STR_CHEAT_GUEST_BATHROOM), 128);
                     safe_strcat(cheat_string, " ", 128);
-                    if (edi == 255) {
+                    if (edi == 255)
+                    {
                         safe_strcat(cheat_string, language_get_string(STR_MAX), 128);
-                    } else if (edi == 0) {
+                    }
+                    else if (edi == 0)
+                    {
                         safe_strcat(cheat_string, language_get_string(STR_MIN), 128);
                     }
                     break;
                 case GUEST_PARAMETER_PREFERRED_RIDE_INTENSITY:
                     safe_strcat(cheat_string, language_get_string(STR_CHEAT_GUEST_PREFERRED_INTENSITY), 128);
                     safe_strcat(cheat_string, " ", 128);
-                    if (edi == 1) {
+                    if (edi == 1)
+                    {
                         safe_strcat(cheat_string, language_get_string(STR_CHEAT_MORE_THAN_1), 128);
-                    } else if (edi == 0) {
+                    }
+                    else if (edi == 0)
+                    {
                         safe_strcat(cheat_string, language_get_string(STR_CHEAT_LESS_THAN_15), 128);
                     }
                     break;
             }
             return cheat_string;
         }
-        case CHEAT_GENERATEGUESTS: return language_get_string(STR_CHEAT_LARGE_TRAM_GUESTS);
+        case CHEAT_GENERATEGUESTS:
-        case CHEAT_REMOVEALLGUESTS: return language_get_string(STR_CHEAT_REMOVE_ALL_GUESTS);
+            return language_get_string(STR_CHEAT_LARGE_TRAM_GUESTS);
-        case CHEAT_EXPLODEGUESTS: return language_get_string(STR_CHEAT_EXPLODE);
+        case CHEAT_REMOVEALLGUESTS:
+            return language_get_string(STR_CHEAT_REMOVE_ALL_GUESTS);
+        case CHEAT_EXPLODEGUESTS:
+            return language_get_string(STR_CHEAT_EXPLODE);
         case CHEAT_GIVEALLGUESTS:
         {
             static char cheat_string[64];
             safe_strcpy(cheat_string, language_get_string(STR_CHEAT_GIVE_ALL_GUESTS), 64);
             safe_strcat(cheat_string, " ", 64);
-            switch (edx) {
+            switch (edx)
+            {
                 case OBJECT_MONEY:
                 {
                     char money[16];
@@ -689,69 +868,112 @@ const char* cheats_get_cheat_string(int cheat, int edx, int edi) {
                     safe_strcat(cheat_string, money, 64);
                     break;
                 }
-                case OBJECT_PARK_MAP: safe_strcat(cheat_string, language_get_string(STR_SHOP_ITEM_PLURAL_PARK_MAP), 64); break;
+                case OBJECT_PARK_MAP:
-                case OBJECT_BALLOON: safe_strcat(cheat_string, language_get_string(STR_SHOP_ITEM_PLURAL_BALLOON), 64); break;
+                    safe_strcat(cheat_string, language_get_string(STR_SHOP_ITEM_PLURAL_PARK_MAP), 64);
-                case OBJECT_UMBRELLA: safe_strcat(cheat_string, language_get_string(STR_SHOP_ITEM_PLURAL_UMBRELLA), 64); break;
+                    break;
+                case OBJECT_BALLOON:
+                    safe_strcat(cheat_string, language_get_string(STR_SHOP_ITEM_PLURAL_BALLOON), 64);
+                    break;
+                case OBJECT_UMBRELLA:
+                    safe_strcat(cheat_string, language_get_string(STR_SHOP_ITEM_PLURAL_UMBRELLA), 64);
+                    break;
             }
             return cheat_string;
         }
         case CHEAT_SETGRASSLENGTH:
-            if (edx == 0) {
+            if (edx == 0)
+            {
                 return language_get_string(STR_CHEAT_MOWED_GRASS);
-            } else if (edx == 1) {
+            }
+            else if (edx == 1)
+            {
                 return language_get_string(STR_CHEAT_CLEAR_GRASS);
             }
-        case CHEAT_WATERPLANTS: return language_get_string(STR_CHEAT_WATER_PLANTS);
+        case CHEAT_WATERPLANTS:
-        case CHEAT_FIXVANDALISM: return language_get_string(STR_CHEAT_FIX_VANDALISM);
+            return language_get_string(STR_CHEAT_WATER_PLANTS);
-        case CHEAT_REMOVELITTER: return language_get_string(STR_CHEAT_REMOVE_LITTER);
+        case CHEAT_FIXVANDALISM:
-        case CHEAT_DISABLEPLANTAGING: return language_get_string(STR_CHEAT_DISABLE_PLANT_AGING);
+            return language_get_string(STR_CHEAT_FIX_VANDALISM);
+        case CHEAT_REMOVELITTER:
+            return language_get_string(STR_CHEAT_REMOVE_LITTER);
+        case CHEAT_DISABLEPLANTAGING:
+            return language_get_string(STR_CHEAT_DISABLE_PLANT_AGING);
         case CHEAT_SETSTAFFSPEED:
         {
             static char cheat_string[64];
             safe_strcpy(cheat_string, language_get_string(STR_CHEAT_STAFF_SPEED), 64);
             safe_strcat(cheat_string, " ", 64);
-            if (edx == CHEATS_STAFF_FAST_SPEED) {
+            if (edx == CHEATS_STAFF_FAST_SPEED)
+            {
                 safe_strcat(cheat_string, language_get_string(STR_FAST), 64);
-            } else if (edx == CHEATS_STAFF_NORMAL_SPEED) {
+            }
+            else if (edx == CHEATS_STAFF_NORMAL_SPEED)
+            {
                 safe_strcat(cheat_string, language_get_string(STR_NORMAL), 64);
             }
             return cheat_string;
         }
-        case CHEAT_RENEWRIDES: return language_get_string(STR_CHEAT_RENEW_RIDES);
+        case CHEAT_RENEWRIDES:
-        case CHEAT_MAKEDESTRUCTIBLE: return language_get_string(STR_CHEAT_MAKE_DESTRUCTABLE);
+            return language_get_string(STR_CHEAT_RENEW_RIDES);
-        case CHEAT_FIXRIDES: return language_get_string(STR_CHEAT_FIX_ALL_RIDES);
+        case CHEAT_MAKEDESTRUCTIBLE:
-        case CHEAT_RESETCRASHSTATUS: return language_get_string(STR_CHEAT_RESET_CRASH_STATUS);
+            return language_get_string(STR_CHEAT_MAKE_DESTRUCTABLE);
-        case CHEAT_10MINUTEINSPECTIONS: return language_get_string(STR_CHEAT_10_MINUTE_INSPECTIONS);
+        case CHEAT_FIXRIDES:
-        case CHEAT_WINSCENARIO: return language_get_string(STR_CHEAT_WIN_SCENARIO);
+            return language_get_string(STR_CHEAT_FIX_ALL_RIDES);
+        case CHEAT_RESETCRASHSTATUS:
+            return language_get_string(STR_CHEAT_RESET_CRASH_STATUS);
+        case CHEAT_10MINUTEINSPECTIONS:
+            return language_get_string(STR_CHEAT_10_MINUTE_INSPECTIONS);
+        case CHEAT_WINSCENARIO:
+            return language_get_string(STR_CHEAT_WIN_SCENARIO);
         case CHEAT_FORCEWEATHER:
         {
             static char cheat_string[64];
             safe_strcpy(cheat_string, language_get_string(STR_FORCE_WEATHER), 64);
             safe_strcat(cheat_string, " ", 64);
-            switch (edx) {
+            switch (edx)
-                case 0: safe_strcat(cheat_string, language_get_string(STR_SUNNY), 64); break;
+            {
-                case 1: safe_strcat(cheat_string, language_get_string(STR_PARTIALLY_CLOUDY), 64); break;
+                case 0:
-                case 2: safe_strcat(cheat_string, language_get_string(STR_CLOUDY), 64); break;
+                    safe_strcat(cheat_string, language_get_string(STR_SUNNY), 64);
-                case 3: safe_strcat(cheat_string, language_get_string(STR_RAIN), 64); break;
+                    break;
-                case 4: safe_strcat(cheat_string, language_get_string(STR_HEAVY_RAIN), 64); break;
+                case 1:
-                case 5: safe_strcat(cheat_string, language_get_string(STR_THUNDERSTORM), 64); break;
+                    safe_strcat(cheat_string, language_get_string(STR_PARTIALLY_CLOUDY), 64);
+                    break;
+                case 2:
+                    safe_strcat(cheat_string, language_get_string(STR_CLOUDY), 64);
+                    break;
+                case 3:
+                    safe_strcat(cheat_string, language_get_string(STR_RAIN), 64);
+                    break;
+                case 4:
+                    safe_strcat(cheat_string, language_get_string(STR_HEAVY_RAIN), 64);
+                    break;
+                case 5:
+                    safe_strcat(cheat_string, language_get_string(STR_THUNDERSTORM), 64);
+                    break;
             }
             return cheat_string;
         }
         case CHEAT_FREEZECLIMATE:
-            if (gCheatsFreezeClimate) {
+            if (gCheatsFreezeClimate)
+            {
                 return language_get_string(STR_CHEAT_UNFREEZE_CLIMATE);
-            } else {
+            }
+            else
+            {
                 return language_get_string(STR_CHEAT_FREEZE_CLIMATE);
             }
-        case CHEAT_NEVERENDINGMARKETING: return language_get_string(STR_CHEAT_NEVERENDING_MARKETING);
+        case CHEAT_NEVERENDINGMARKETING:
+            return language_get_string(STR_CHEAT_NEVERENDING_MARKETING);
         case CHEAT_OPENCLOSEPARK:
-            if (park_is_open()) {
+            if (park_is_open())
+            {
                 return language_get_string(STR_CHEAT_CLOSE_PARK);
-            } else {
+            }
+            else
+            {
                 return language_get_string(STR_CHEAT_OPEN_PARK);
             }
-        case CHEAT_HAVEFUN: return language_get_string(STR_CHEAT_HAVE_FUN);
+        case CHEAT_HAVEFUN:
+            return language_get_string(STR_CHEAT_HAVE_FUN);
         case CHEAT_SETFORCEDPARKRATING:
         {
             static char cheat_string[64];
@@ -765,13 +987,20 @@ const char* cheats_get_cheat_string(int cheat, int edx, int edi) {
 
             return cheat_string;
         }
-        case CHEAT_RESETDATE: return language_get_string(STR_CHEAT_RESET_DATE);
+        case CHEAT_RESETDATE:
-        case CHEAT_ALLOW_ARBITRARY_RIDE_TYPE_CHANGES: return language_get_string(STR_CHEAT_ALLOW_ARBITRARY_RIDE_TYPE_CHANGES);
+            return language_get_string(STR_CHEAT_RESET_DATE);
-        case CHEAT_SETMONEY: return language_get_string(STR_SET_MONEY);
+        case CHEAT_ALLOW_ARBITRARY_RIDE_TYPE_CHANGES:
-        case CHEAT_OWNALLLAND: return language_get_string(STR_CHEAT_OWN_ALL_LAND);
+            return language_get_string(STR_CHEAT_ALLOW_ARBITRARY_RIDE_TYPE_CHANGES);
-        case CHEAT_DISABLERIDEVALUEAGING: return language_get_string(STR_CHEAT_DISABLE_RIDE_VALUE_AGING);
+        case CHEAT_SETMONEY:
-        case CHEAT_IGNORERESEARCHSTATUS: return language_get_string(STR_CHEAT_IGNORE_RESEARCH_STATUS);
+            return language_get_string(STR_SET_MONEY);
-        case CHEAT_ENABLEALLDRAWABLETRACKPIECES: return language_get_string(STR_CHEAT_ENABLE_ALL_DRAWABLE_TRACK_PIECES);
+        case CHEAT_OWNALLLAND:
+            return language_get_string(STR_CHEAT_OWN_ALL_LAND);
+        case CHEAT_DISABLERIDEVALUEAGING:
+            return language_get_string(STR_CHEAT_DISABLE_RIDE_VALUE_AGING);
+        case CHEAT_IGNORERESEARCHSTATUS:
+            return language_get_string(STR_CHEAT_IGNORE_RESEARCH_STATUS);
+        case CHEAT_ENABLEALLDRAWABLETRACKPIECES:
+            return language_get_string(STR_CHEAT_ENABLE_ALL_DRAWABLE_TRACK_PIECES);
     }
 
     return "";

src/openrct2/Cheats.h

@@ -34,8 +34,8 @@ extern bool gCheatsAllowArbitraryRideTypeChanges;
 extern bool gCheatsIgnoreResearchStatus;
 extern bool gCheatsEnableAllDrawableTrackPieces;
 
-
+enum
-enum {
+{
     CHEAT_SANDBOXMODE,
     CHEAT_DISABLECLEARANCECHECKS,
     CHEAT_DISABLESUPPORTLIMITS,
@@ -87,7 +87,8 @@ enum {
     CHEAT_DATE_SET,
 };
 
-enum {
+enum
+{
     GUEST_PARAMETER_HAPPINESS,
     GUEST_PARAMETER_ENERGY,
     GUEST_PARAMETER_HUNGER,
@@ -98,14 +99,15 @@ enum {
     GUEST_PARAMETER_PREFERRED_RIDE_INTENSITY
 };
 
-enum {
+enum
+{
     OBJECT_MONEY,
     OBJECT_PARK_MAP,
     OBJECT_BALLOON,
     OBJECT_UMBRELLA
 };
 
-#define CHEATS_GIVE_GUESTS_MONEY MONEY(1000,00)
+#define CHEATS_GIVE_GUESTS_MONEY MONEY(1000, 00)
 #define CHEATS_TRAM_INCREMENT 250
 #define CHEATS_STAFF_FAST_SPEED 0xFF
 #define CHEATS_STAFF_NORMAL_SPEED 0x60

src/openrct2/CmdlineSprite.cpp

@@ -9,34 +9,39 @@
 
 #pragma warning(disable : 4706) // assignment within conditional expression
 
-#include <cmath>
-#include <cstring>
-#include <jansson.h>
 #include "CmdlineSprite.h"
+
+#include "OpenRCT2.h"
 #include "core/Imaging.h"
 #include "drawing/Drawing.h"
 #include "drawing/ImageImporter.h"
 #include "localisation/Language.h"
-#include "OpenRCT2.h"
 #include "platform/platform.h"
 #include "util/Util.h"
 
+#include <cmath>
+#include <cstring>
+#include <jansson.h>
+
 using namespace OpenRCT2::Drawing;
 
 #pragma pack(push, 1)
 
-struct rct_sprite_file_header {
+struct rct_sprite_file_header
+{
     uint32_t num_entries;
     uint32_t total_size;
 };
 
 assert_struct_size(rct_sprite_file_header, 8);
 
-struct rct_sprite_file_palette_entry {
+struct rct_sprite_file_palette_entry
+{
     uint8_t b, g, r, a;
 };
 
-struct rle_code {
+struct rle_code
+{
     uint8_t num_pixels;
     uint8_t offset_x;
 };
@@ -56,16 +61,16 @@ public:
 static rct_sprite_file_palette_entry spriteFilePalette[256];
 
 static rct_sprite_file_header spriteFileHeader;
-static rct_g1_element *spriteFileEntries;
+static rct_g1_element* spriteFileEntries;
-static uint8_t *spriteFileData;
+static uint8_t* spriteFileData;
 
 #ifdef _WIN32
 
-static FILE * fopen_utf8(const char * path, const char * mode)
+static FILE* fopen_utf8(const char* path, const char* mode)
 {
-    wchar_t * pathW = utf8_to_widechar(path);
+    wchar_t* pathW = utf8_to_widechar(path);
-    wchar_t * modeW = utf8_to_widechar(mode);
+    wchar_t* modeW = utf8_to_widechar(mode);
-    FILE * file = _wfopen(pathW, modeW);
+    FILE* file = _wfopen(pathW, modeW);
     free(pathW);
     free(modeW);
     return file;
@@ -87,33 +92,38 @@ static void sprite_entries_make_relative()
         spriteFileEntries[i].offset -= (uintptr_t)spriteFileData;
 }
 
-static bool sprite_file_open(const utf8 *path)
+static bool sprite_file_open(const utf8* path)
 {
-    FILE * file = fopen(path, "rb");
+    FILE* file = fopen(path, "rb");
     if (file == nullptr)
         return false;
 
-    if (fread(&spriteFileHeader, sizeof(rct_sprite_file_header), 1, file) != 1) {
+    if (fread(&spriteFileHeader, sizeof(rct_sprite_file_header), 1, file) != 1)
+    {
         fclose(file);
         return false;
     }
 
-    if (spriteFileHeader.num_entries > 0) {
+    if (spriteFileHeader.num_entries > 0)
+    {
         int32_t openEntryTableSize = spriteFileHeader.num_entries * sizeof(rct_g1_element_32bit);
-        rct_g1_element_32bit * openElements = (rct_g1_element_32bit *)malloc(openEntryTableSize);
+        rct_g1_element_32bit* openElements = (rct_g1_element_32bit*)malloc(openEntryTableSize);
-        if (openElements == nullptr) {
+        if (openElements == nullptr)
+        {
             fclose(file);
             return false;
         }
 
-        if (fread(openElements, openEntryTableSize, 1, file) != 1) {
+        if (fread(openElements, openEntryTableSize, 1, file) != 1)
+        {
             free(openElements);
             fclose(file);
             return false;
         }
 
-        spriteFileData = (uint8_t *)malloc(spriteFileHeader.total_size);
+        spriteFileData = (uint8_t*)malloc(spriteFileHeader.total_size);
-        if (fread(spriteFileData, spriteFileHeader.total_size, 1, file) != 1) {
+        if (fread(spriteFileData, spriteFileHeader.total_size, 1, file) != 1)
+        {
             free(spriteFileData);
             free(openElements);
             fclose(file);
@@ -121,10 +131,11 @@ static bool sprite_file_open(const utf8 *path)
         }
 
         int32_t entryTableSize = spriteFileHeader.num_entries * sizeof(rct_g1_element);
-        spriteFileEntries = (rct_g1_element *)malloc(entryTableSize);
+        spriteFileEntries = (rct_g1_element*)malloc(entryTableSize);
-        for (uint32_t i = 0; i < spriteFileHeader.num_entries; i++) {
+        for (uint32_t i = 0; i < spriteFileHeader.num_entries; i++)
-            rct_g1_element_32bit * inElement = &openElements[i];
+        {
-            rct_g1_element * outElement = &spriteFileEntries[i];
+            rct_g1_element_32bit* inElement = &openElements[i];
+            rct_g1_element* outElement = &spriteFileEntries[i];
 
             outElement->offset = (uint8_t*)((uintptr_t)inElement->offset + (uintptr_t)spriteFileData);
             outElement->width = inElement->width;
@@ -142,28 +153,32 @@ static bool sprite_file_open(const utf8 *path)
     return true;
 }
 
-static bool sprite_file_save(const char *path)
+static bool sprite_file_save(const char* path)
 {
-    FILE * file = fopen(path, "wb");
+    FILE* file = fopen(path, "wb");
     if (file == nullptr)
         return false;
 
-    if (fwrite(&spriteFileHeader, sizeof(rct_sprite_file_header), 1, file) != 1) {
+    if (fwrite(&spriteFileHeader, sizeof(rct_sprite_file_header), 1, file) != 1)
+    {
         fclose(file);
         return false;
     }
 
-    if (spriteFileHeader.num_entries > 0) {
+    if (spriteFileHeader.num_entries > 0)
+    {
         int32_t saveEntryTableSize = spriteFileHeader.num_entries * sizeof(rct_g1_element_32bit);
-        rct_g1_element_32bit * saveElements = (rct_g1_element_32bit *)malloc(saveEntryTableSize);
+        rct_g1_element_32bit* saveElements = (rct_g1_element_32bit*)malloc(saveEntryTableSize);
-        if (saveElements == nullptr) {
+        if (saveElements == nullptr)
+        {
             fclose(file);
             return false;
         }
 
-        for (uint32_t i = 0; i < spriteFileHeader.num_entries; i++) {
+        for (uint32_t i = 0; i < spriteFileHeader.num_entries; i++)
-            rct_g1_element * inElement = &spriteFileEntries[i];
+        {
-            rct_g1_element_32bit * outElement = &saveElements[i];
+            rct_g1_element* inElement = &spriteFileEntries[i];
+            rct_g1_element_32bit* outElement = &saveElements[i];
 
             outElement->offset = (uint32_t)((uintptr_t)inElement->offset - (uintptr_t)spriteFileData);
             outElement->width = inElement->width;
@@ -174,14 +189,16 @@ static bool sprite_file_save(const char *path)
             outElement->zoomed_offset = inElement->zoomed_offset;
         }
 
-        if (fwrite(saveElements, saveEntryTableSize, 1, file) != 1) {
+        if (fwrite(saveElements, saveEntryTableSize, 1, file) != 1)
+        {
             free(saveElements);
             fclose(file);
             return false;
         }
         free(saveElements);
 
-        if (fwrite(spriteFileData, spriteFileHeader.total_size, 1, file) != 1) {
+        if (fwrite(spriteFileData, spriteFileHeader.total_size, 1, file) != 1)
+        {
             fclose(file);
             return false;
         }
@@ -197,16 +214,16 @@ static void sprite_file_close()
     SafeFree(spriteFileData);
 }
 
-static bool sprite_file_export(int32_t spriteIndex, const char *outPath)
+static bool sprite_file_export(int32_t spriteIndex, const char* outPath)
 {
-    rct_g1_element *spriteHeader;
+    rct_g1_element* spriteHeader;
     rct_drawpixelinfo dpi;
-    uint8_t *pixels;
+    uint8_t* pixels;
     int32_t pixelBufferSize;
 
     spriteHeader = &spriteFileEntries[spriteIndex];
     pixelBufferSize = spriteHeader->width * spriteHeader->height;
-    pixels = (uint8_t *)malloc(pixelBufferSize);
+    pixels = (uint8_t*)malloc(pixelBufferSize);
     memset(pixels, 0, pixelBufferSize);
 
     dpi.bits = pixels;
@@ -219,10 +236,30 @@ static bool sprite_file_export(int32_t spriteIndex, const char *outPath)
 
     memcpy(spriteFilePalette, CmdlineSprite::_standardPalette, 256 * 4);
 
-    if (spriteHeader->flags & G1_FLAG_RLE_COMPRESSION) {
+    if (spriteHeader->flags & G1_FLAG_RLE_COMPRESSION)
-        gfx_rle_sprite_to_buffer(spriteHeader->offset, pixels, (uint8_t*)spriteFilePalette, &dpi, IMAGE_TYPE_DEFAULT, 0, spriteHeader->height, 0, spriteHeader->width);
+    {
-    } else {
+        gfx_rle_sprite_to_buffer(
-        gfx_bmp_sprite_to_buffer((uint8_t*)spriteFilePalette, spriteHeader->offset, pixels, spriteHeader, &dpi, spriteHeader->height, spriteHeader->width, IMAGE_TYPE_DEFAULT);
+            spriteHeader->offset,
+            pixels,
+            (uint8_t*)spriteFilePalette,
+            &dpi,
+            IMAGE_TYPE_DEFAULT,
+            0,
+            spriteHeader->height,
+            0,
+            spriteHeader->width);
+    }
+    else
+    {
+        gfx_bmp_sprite_to_buffer(
+            (uint8_t*)spriteFilePalette,
+            spriteHeader->offset,
+            pixels,
+            spriteHeader,
+            &dpi,
+            spriteHeader->height,
+            spriteHeader->width,
+            IMAGE_TYPE_DEFAULT);
     }
 
     auto const pixels8 = dpi.bits;
@@ -234,7 +271,7 @@ static bool sprite_file_export(int32_t spriteIndex, const char *outPath)
         image.Height = dpi.height;
         image.Depth = 8;
         image.Stride = dpi.width + dpi.pitch;
-        image.Palette = std::make_unique<rct_palette>(*((rct_palette *)&spriteFilePalette));
+        image.Palette = std::make_unique<rct_palette>(*((rct_palette*)&spriteFilePalette));
         image.Pixels = std::vector<uint8_t>(pixels8, pixels8 + pixelsLen);
         Imaging::WriteToFile(outPath, image, IMAGE_FORMAT::PNG);
         return true;
@@ -246,7 +283,16 @@ static bool sprite_file_export(int32_t spriteIndex, const char *outPath)
     }
 }
 
-static bool sprite_file_import(const char *path, int16_t x_offset, int16_t y_offset, bool keep_palette, bool forceBmp, rct_g1_element *outElement, uint8_t **outBuffer, int *outBufferLength, int32_t mode)
+static bool sprite_file_import(
+    const char* path,
+    int16_t x_offset,
+    int16_t y_offset,
+    bool keep_palette,
+    bool forceBmp,
+    rct_g1_element* outElement,
+    uint8_t** outBuffer,
+    int* outBufferLength,
+    int32_t mode)
 {
     try
     {
@@ -269,7 +315,7 @@ static bool sprite_file_import(const char *path, int16_t x_offset, int16_t y_off
         auto result = importer.Import(image, x_offset, y_offset, flags, (ImageImporter::IMPORT_MODE)mode);
 
         *outElement = result.Element;
-        *outBuffer = (uint8_t *)result.Buffer;
+        *outBuffer = (uint8_t*)result.Buffer;
         *outBufferLength = (int)result.BufferLength;
         return true;
     }
@@ -280,20 +326,25 @@ static bool sprite_file_import(const char *path, int16_t x_offset, int16_t y_off
     }
 }
 
-int32_t cmdline_for_sprite(const char **argv, int32_t argc)
+int32_t cmdline_for_sprite(const char** argv, int32_t argc)
 {
     gOpenRCT2Headless = true;
     if (argc == 0)
         return -1;
 
-    if (_strcmpi(argv[0], "details") == 0) {
+    if (_strcmpi(argv[0], "details") == 0)
-        if (argc < 2) {
+    {
+        if (argc < 2)
+        {
             fprintf(stdout, "usage: sprite details <spritefile> [idx]\n");
             return -1;
-        } else if (argc == 2) {
+        }
-            const char *spriteFilePath = argv[1];
+        else if (argc == 2)
+        {
+            const char* spriteFilePath = argv[1];
 
-            if (!sprite_file_open(spriteFilePath)) {
+            if (!sprite_file_open(spriteFilePath))
+            {
                 fprintf(stderr, "Unable to open input sprite file.\n");
                 return -1;
             }
@@ -303,22 +354,26 @@ int32_t cmdline_for_sprite(const char **argv, int32_t argc)
 
             sprite_file_close();
             return 1;
-        } else {
+        }
-            const char *spriteFilePath = argv[1];
+        else
+        {
+            const char* spriteFilePath = argv[1];
             int32_t spriteIndex = atoi(argv[2]);
 
-            if (!sprite_file_open(spriteFilePath)) {
+            if (!sprite_file_open(spriteFilePath))
+            {
                 fprintf(stderr, "Unable to open input sprite file.\n");
                 return -1;
             }
 
-            if (spriteIndex < 0 || spriteIndex >= (int32_t)spriteFileHeader.num_entries) {
+            if (spriteIndex < 0 || spriteIndex >= (int32_t)spriteFileHeader.num_entries)
+            {
                 sprite_file_close();
                 fprintf(stderr, "Sprite #%d does not exist in sprite file.\n", spriteIndex);
                 return -1;
             }
 
-            rct_g1_element *g1 = &spriteFileEntries[spriteIndex];
+            rct_g1_element* g1 = &spriteFileEntries[spriteIndex];
             printf("width: %d\n", g1->width);
             printf("height: %d\n", g1->height);
             printf("x offset: %d\n", g1->x_offset);
@@ -328,27 +383,33 @@ int32_t cmdline_for_sprite(const char **argv, int32_t argc)
             sprite_file_close();
             return 1;
         }
-    } else if (_strcmpi(argv[0], "export") == 0) {
+    }
-        if (argc < 4) {
+    else if (_strcmpi(argv[0], "export") == 0)
+    {
+        if (argc < 4)
+        {
             fprintf(stdout, "usage: sprite export <spritefile> <idx> <output>\n");
             return -1;
         }
 
-        const char *spriteFilePath = argv[1];
+        const char* spriteFilePath = argv[1];
         int32_t spriteIndex = atoi(argv[2]);
-        const char *outputPath = argv[3];
+        const char* outputPath = argv[3];
 
-        if (!sprite_file_open(spriteFilePath)) {
+        if (!sprite_file_open(spriteFilePath))
+        {
             fprintf(stderr, "Unable to open input sprite file.\n");
             return -1;
         }
 
-        if (spriteIndex < 0 || spriteIndex >= (int32_t)spriteFileHeader.num_entries) {
+        if (spriteIndex < 0 || spriteIndex >= (int32_t)spriteFileHeader.num_entries)
+        {
             fprintf(stderr, "Sprite #%d does not exist in sprite file.\n", spriteIndex);
             return -1;
         }
 
-        if (!sprite_file_export(spriteIndex, outputPath)) {
+        if (!sprite_file_export(spriteIndex, outputPath))
+        {
             fprintf(stderr, "Could not export\n");
             sprite_file_close();
             return -1;
@@ -356,16 +417,20 @@ int32_t cmdline_for_sprite(const char **argv, int32_t argc)
 
         sprite_file_close();
         return 1;
-    } else if (_strcmpi(argv[0], "exportall") == 0) {
+    }
-        if (argc < 3) {
+    else if (_strcmpi(argv[0], "exportall") == 0)
+    {
+        if (argc < 3)
+        {
             fprintf(stdout, "usage: sprite exportall <spritefile> <output directory>\n");
             return -1;
         }
 
-        const char *spriteFilePath = argv[1];
+        const char* spriteFilePath = argv[1];
         char outputPath[MAX_PATH];
 
-        if (!sprite_file_open(spriteFilePath)) {
+        if (!sprite_file_open(spriteFilePath))
+        {
             fprintf(stderr, "Unable to open input sprite file.\n");
             return -1;
         }
@@ -373,7 +438,8 @@ int32_t cmdline_for_sprite(const char **argv, int32_t argc)
         safe_strcpy(outputPath, argv[2], MAX_PATH);
         path_end_with_separator(outputPath, MAX_PATH);
 
-        if (!platform_ensure_directory_exists(outputPath)){
+        if (!platform_ensure_directory_exists(outputPath))
+        {
             fprintf(stderr, "Unable to create directory.\n");
             return -1;
         }
@@ -382,18 +448,20 @@ int32_t cmdline_for_sprite(const char **argv, int32_t argc)
         int32_t numbers = (int32_t)std::floor(std::log(maxIndex));
         size_t pathLen = strlen(outputPath);
 
-        if (pathLen >= (size_t)(MAX_PATH - numbers - 5)) {
+        if (pathLen >= (size_t)(MAX_PATH - numbers - 5))
+        {
             fprintf(stderr, "Path too long.\n");
             return -1;
         }
 
-        for (int32_t x = 0; x < numbers; x++){
+        for (int32_t x = 0; x < numbers; x++)
+        {
             outputPath[pathLen + x] = '0';
         }
         safe_strcpy(outputPath + pathLen + numbers, ".png", MAX_PATH - pathLen - numbers);
 
-        for (int32_t spriteIndex = 0; spriteIndex < maxIndex; spriteIndex++){
+        for (int32_t spriteIndex = 0; spriteIndex < maxIndex; spriteIndex++)
-
+        {
             if (spriteIndex % 100 == 99)
             {
                 // Status indicator
@@ -408,7 +476,7 @@ int32_t cmdline_for_sprite(const char **argv, int32_t argc)
             }
 
             // Add to the index at the end of the file name
-            char *counter = outputPath + pathLen + numbers - 1;
+            char* counter = outputPath + pathLen + numbers - 1;
             (*counter)++;
             while (*counter > '9')
             {
@@ -420,14 +488,16 @@ int32_t cmdline_for_sprite(const char **argv, int32_t argc)
 
         sprite_file_close();
         return 1;
-
+    }
-    } else if (_strcmpi(argv[0], "create") == 0) {
+    else if (_strcmpi(argv[0], "create") == 0)
-        if (argc < 2) {
+    {
+        if (argc < 2)
+        {
             fprintf(stderr, "usage: sprite create <spritefile>\n");
             return -1;
         }
 
-        const char *spriteFilePath = argv[1];
+        const char* spriteFilePath = argv[1];
 
         spriteFileHeader.num_entries = 0;
         spriteFileHeader.total_size = 0;
@@ -435,21 +505,23 @@ int32_t cmdline_for_sprite(const char **argv, int32_t argc)
 
         sprite_file_close();
         return 1;
-    } else if (_strcmpi(argv[0], "append") == 0) {
+    }
-        if (argc != 3 && argc != 5) {
+    else if (_strcmpi(argv[0], "append") == 0)
+    {
+        if (argc != 3 && argc != 5)
+        {
             fprintf(stderr, "usage: sprite append <spritefile> <input> [<x offset> <y offset>]\n");
             return -1;
         }
 
-
+        const char* spriteFilePath = argv[1];
-        const char *spriteFilePath = argv[1];
+        const char* imagePath = argv[2];
-        const char *imagePath = argv[2];
         int16_t x_offset = 0;
         int16_t y_offset = 0;
 
         if (argc == 5)
         {
-            char *endptr;
+            char* endptr;
 
             x_offset = strtol(argv[3], &endptr, 0);
             if (*endptr != 0)
@@ -467,50 +539,61 @@ int32_t cmdline_for_sprite(const char **argv, int32_t argc)
         }
 
         rct_g1_element spriteElement;
-        uint8_t *buffer;
+        uint8_t* buffer;
 
         int32_t bufferLength;
-        if (!sprite_file_import(imagePath, x_offset, y_offset, false, false, &spriteElement, &buffer, &bufferLength, gSpriteMode))
+        if (!sprite_file_import(
+                imagePath, x_offset, y_offset, false, false, &spriteElement, &buffer, &bufferLength, gSpriteMode))
             return -1;
 
-        if (!sprite_file_open(spriteFilePath)) {
+        if (!sprite_file_open(spriteFilePath))
+        {
             fprintf(stderr, "Unable to open input sprite file.\n");
             return -1;
         }
 
         spriteFileHeader.num_entries++;
         spriteFileHeader.total_size += bufferLength;
-        spriteFileEntries = (rct_g1_element *)realloc(spriteFileEntries, spriteFileHeader.num_entries * sizeof(rct_g1_element));
+        spriteFileEntries = (rct_g1_element*)realloc(spriteFileEntries, spriteFileHeader.num_entries * sizeof(rct_g1_element));
 
         sprite_entries_make_relative();
-        spriteFileData = (uint8_t *)realloc(spriteFileData, spriteFileHeader.total_size);
+        spriteFileData = (uint8_t*)realloc(spriteFileData, spriteFileHeader.total_size);
         sprite_entries_make_absolute();
 
         spriteFileEntries[spriteFileHeader.num_entries - 1] = spriteElement;
         memcpy(spriteFileData + (spriteFileHeader.total_size - bufferLength), buffer, bufferLength);
-        spriteFileEntries[spriteFileHeader.num_entries - 1].offset = spriteFileData + (spriteFileHeader.total_size - bufferLength);
+        spriteFileEntries[spriteFileHeader.num_entries - 1].offset
+            = spriteFileData + (spriteFileHeader.total_size - bufferLength);
 
         free(buffer);
         if (!sprite_file_save(spriteFilePath))
             return -1;
 
         return 1;
-    } else if (_strcmpi(argv[0], "build") == 0) {
+    }
-        if (argc < 3) {
+    else if (_strcmpi(argv[0], "build") == 0)
+    {
+        if (argc < 3)
+        {
             fprintf(stdout, "usage: sprite build <spritefile> <sprite description file> [silent]\n");
             return -1;
         }
 
-        const char *spriteFilePath = argv[1];
+        const char* spriteFilePath = argv[1];
-        const char *spriteDescriptionPath = argv[2];
+        const char* spriteDescriptionPath = argv[2];
         char* directoryPath = path_get_directory(spriteDescriptionPath);
 
         json_error_t error;
-        json_t* sprite_list=json_load_file(spriteDescriptionPath, JSON_REJECT_DUPLICATES, &error);
+        json_t* sprite_list = json_load_file(spriteDescriptionPath, JSON_REJECT_DUPLICATES, &error);
 
         if (sprite_list == nullptr)
         {
-            fprintf(stderr, "Error parsing sprite description file: %s at line %d column %d\n", error.text, error.line, error.column);
+            fprintf(
+                stderr,
+                "Error parsing sprite description file: %s at line %d column %d\n",
+                error.text,
+                error.line,
+                error.column);
             return -1;
         }
 
@@ -534,15 +617,15 @@ int32_t cmdline_for_sprite(const char **argv, int32_t argc)
 
         json_array_foreach(sprite_list, i, sprite_description)
         {
-            if(!json_is_object(sprite_description))
+            if (!json_is_object(sprite_description))
             {
                 fprintf(stderr, "Error: expected object for sprite %lu\n", (unsigned long)i);
                 json_decref(sprite_list);
                 return -1;
             }
 
-            json_t* path = json_object_get(sprite_description,"path");
+            json_t* path = json_object_get(sprite_description, "path");
-            if(!path || !json_is_string(path))
+            if (!path || !json_is_string(path))
             {
                 fprintf(stderr, "Error: no path provided for sprite %lu\n", (unsigned long)i);
                 json_decref(sprite_list);
@@ -557,7 +640,7 @@ int32_t cmdline_for_sprite(const char **argv, int32_t argc)
             json_t* palette = json_object_get(sprite_description, "palette");
             if (palette && json_is_string(palette))
             {
-                const char *option = json_string_value(palette);
+                const char* option = json_string_value(palette);
                 if (strncmp(option, "keep", 4) == 0)
                 {
                     keep_palette = true;
@@ -573,16 +656,22 @@ int32_t cmdline_for_sprite(const char **argv, int32_t argc)
             }
 
             // Resolve absolute sprite path
-            char *imagePath = platform_get_absolute_path(json_string_value(path), directoryPath);
+            char* imagePath = platform_get_absolute_path(json_string_value(path), directoryPath);
 
             rct_g1_element spriteElement;
-            uint8_t *buffer;
+            uint8_t* buffer;
             int bufferLength;
 
-            if (!sprite_file_import(imagePath,
+            if (!sprite_file_import(
-                                    x_offset == nullptr ? 0 : json_integer_value(x_offset),
+                    imagePath,
-                                    y_offset == nullptr ? 0 : json_integer_value(y_offset),
+                    x_offset == nullptr ? 0 : json_integer_value(x_offset),
-                                    keep_palette, forceBmp, &spriteElement, &buffer, &bufferLength, gSpriteMode))
+                    y_offset == nullptr ? 0 : json_integer_value(y_offset),
+                    keep_palette,
+                    forceBmp,
+                    &spriteElement,
+                    &buffer,
+                    &bufferLength,
+                    gSpriteMode))
             {
                 fprintf(stderr, "Could not import image file: %s\nCanceling\n", imagePath);
                 json_decref(sprite_list);
@@ -600,15 +689,17 @@ int32_t cmdline_for_sprite(const char **argv, int32_t argc)
 
             spriteFileHeader.num_entries++;
             spriteFileHeader.total_size += bufferLength;
-            spriteFileEntries = (rct_g1_element *)realloc(spriteFileEntries, spriteFileHeader.num_entries * sizeof(rct_g1_element));
+            spriteFileEntries
+                = (rct_g1_element*)realloc(spriteFileEntries, spriteFileHeader.num_entries * sizeof(rct_g1_element));
 
             sprite_entries_make_relative();
-            spriteFileData = (uint8_t *)realloc(spriteFileData, spriteFileHeader.total_size);
+            spriteFileData = (uint8_t*)realloc(spriteFileData, spriteFileHeader.total_size);
             sprite_entries_make_absolute();
 
             spriteFileEntries[spriteFileHeader.num_entries - 1] = spriteElement;
             memcpy(spriteFileData + (spriteFileHeader.total_size - bufferLength), buffer, bufferLength);
-            spriteFileEntries[spriteFileHeader.num_entries - 1].offset = spriteFileData + (spriteFileHeader.total_size - bufferLength);
+            spriteFileEntries[spriteFileHeader.num_entries - 1].offset
+                = spriteFileData + (spriteFileHeader.total_size - bufferLength);
 
             free(buffer);
 
@@ -625,7 +716,6 @@ int32_t cmdline_for_sprite(const char **argv, int32_t argc)
 
             free(imagePath);
             sprite_file_close();
-
         }
 
         json_decref(sprite_list);
@@ -633,7 +723,9 @@ int32_t cmdline_for_sprite(const char **argv, int32_t argc)
 
         fprintf(stdout, "Finished\n");
         return 1;
-    } else {
+    }
+    else
+    {
         fprintf(stderr, "Unknown sprite command.\n");
         return 1;
     }

src/openrct2/CmdlineSprite.h

@@ -12,7 +12,7 @@
 
 #include "common.h"
 
-int32_t cmdline_for_sprite(const char **argv, int32_t argc);
+int32_t cmdline_for_sprite(const char** argv, int32_t argc);
 extern int32_t gSpriteMode;
 
 #endif

src/openrct2/Context.cpp

@@ -13,11 +13,22 @@
 #include <memory>
 #include <string>
 #ifdef __EMSCRIPTEN__
-    #include <emscripten.h>
+#include <emscripten.h>
 #endif // __EMSCRIPTEN__
-#include "audio/AudioContext.h"
 #include "Context.h"
-#include "ui/UiContext.h"
+#include "Editor.h"
+#include "FileClassifier.h"
+#include "Game.h"
+#include "GameState.h"
+#include "Input.h"
+#include "Intro.h"
+#include "OpenRCT2.h"
+#include "ParkImporter.h"
+#include "PlatformEnvironment.h"
+#include "Version.h"
+#include "audio/AudioContext.h"
+#include "audio/audio.h"
+#include "config/Config.h"
 #include "core/Console.hpp"
 #include "core/File.h"
 #include "core/FileScanner.h"
@@ -29,45 +40,31 @@
 #include "core/String.hpp"
 #include "core/Util.hpp"
 #include "drawing/IDrawingEngine.h"
-#include "localisation/Localisation.h"
-#include "FileClassifier.h"
-#include "GameState.h"
-#include "network/network.h"
-#include "object/ObjectManager.h"
-#include "object/ObjectRepository.h"
-#include "OpenRCT2.h"
-#include "paint/Painter.h"
-#include "ParkImporter.h"
-#include "platform/Crash.h"
-#include "PlatformEnvironment.h"
-#include "ride/TrackDesignRepository.h"
-#include "scenario/Scenario.h"
-#include "scenario/ScenarioRepository.h"
-#include "title/TitleScreen.h"
-#include "title/TitleSequenceManager.h"
-#include "ui/WindowManager.h"
-#include "world/Park.h"
-#include "Version.h"
-
-#include "Editor.h"
-#include "Game.h"
-#include "Input.h"
-#include "Intro.h"
-#include "audio/audio.h"
-#include "config/Config.h"
 #include "drawing/LightFX.h"
 #include "interface/Chat.h"
 #include "interface/InteractiveConsole.h"
 #include "interface/Viewport.h"
-#include "Intro.h"
 #include "localisation/Date.h"
+#include "localisation/Localisation.h"
 #include "localisation/LocalisationService.h"
 #include "network/DiscordService.h"
 #include "network/Http.h"
 #include "network/network.h"
 #include "network/twitch.h"
+#include "object/ObjectManager.h"
+#include "object/ObjectRepository.h"
+#include "paint/Painter.h"
+#include "platform/Crash.h"
 #include "platform/platform.h"
+#include "ride/TrackDesignRepository.h"
+#include "scenario/Scenario.h"
+#include "scenario/ScenarioRepository.h"
+#include "title/TitleScreen.h"
+#include "title/TitleSequenceManager.h"
+#include "ui/UiContext.h"
+#include "ui/WindowManager.h"
 #include "util/Util.h"
+#include "world/Park.h"
 
 using namespace OpenRCT2;
 using namespace OpenRCT2::Audio;
@@ -95,7 +92,7 @@ namespace OpenRCT2
 #ifdef __ENABLE_DISCORD__
         std::unique_ptr<DiscordService> _discordService;
 #endif
-        StdInOutConsole             _stdInOutConsole;
+        StdInOutConsole _stdInOutConsole;
 #ifndef DISABLE_HTTP
         Network::Http::Http _http;
 #endif
@@ -108,31 +105,32 @@ namespace OpenRCT2
         std::unique_ptr<IDrawingEngine> _drawingEngine;
         std::unique_ptr<Painter> _painter;
 
-        bool    _initialised = false;
+        bool _initialised = false;
-        bool    _isWindowMinimised = false;
+        bool _isWindowMinimised = false;
-        uint32_t  _lastTick = 0;
+        uint32_t _lastTick = 0;
-        uint32_t  _accumulator = 0;
+        uint32_t _accumulator = 0;
-        uint32_t  _lastUpdateTick = 0;
+        uint32_t _lastUpdateTick = 0;
-        bool    _variableFrame = false;
+        bool _variableFrame = false;
 
-        /** If set, will end the OpenRCT2 game loop. Intentially private to this module so that the flag can not be set back to false. */
+        /** If set, will end the OpenRCT2 game loop. Intentially private to this module so that the flag can not be set back to
+         * false. */
         bool _finished = false;
 
     public:
         // Singleton of Context.
         // Remove this when GetContext() is no longer called so that
         // multiple instances can be created in parallel
-        static Context * Instance;
+        static Context* Instance;
 
     public:
         Context(
             const std::shared_ptr<IPlatformEnvironment>& env,
             const std::shared_ptr<IAudioContext>& audioContext,
             const std::shared_ptr<IUiContext>& uiContext)
-            : _env(env),
+            : _env(env)
-            _audioContext(audioContext),
+            , _audioContext(audioContext)
-            _uiContext(uiContext),
+            , _uiContext(uiContext)
-            _localisationService(std::make_shared<LocalisationService>(env))
+            , _localisationService(std::make_shared<LocalisationService>(env))
         {
             Instance = this;
         }
@@ -159,7 +157,7 @@ namespace OpenRCT2
             return _uiContext;
         }
 
-        GameState * GetGameState() override
+        GameState* GetGameState() override
         {
             return _gameState.get();
         }
@@ -184,12 +182,12 @@ namespace OpenRCT2
             return _objectRepository;
         }
 
-        ITrackDesignRepository * GetTrackDesignRepository() override
+        ITrackDesignRepository* GetTrackDesignRepository() override
         {
             return _trackDesignRepository.get();
         }
 
-        IScenarioRepository * GetScenarioRepository() override
+        IScenarioRepository* GetScenarioRepository() override
         {
             return _scenarioRepository.get();
         }
@@ -199,12 +197,12 @@ namespace OpenRCT2
             return _drawingEngineType;
         }
 
-        IDrawingEngine * GetDrawingEngine() override
+        IDrawingEngine* GetDrawingEngine() override
         {
             return _drawingEngine.get();
         }
 
-        int32_t RunOpenRCT2(int argc, const char * * argv) override
+        int32_t RunOpenRCT2(int argc, const char** argv) override
         {
             if (Initialise())
             {
@@ -213,7 +211,7 @@ namespace OpenRCT2
             return gExitCode;
         }
 
-        void WriteLine(const std::string &s) override
+        void WriteLine(const std::string& s) override
         {
             _stdInOutConsole.WriteLine(s);
         }
@@ -234,60 +232,14 @@ namespace OpenRCT2
 
         std::string GetPathLegacy(int32_t pathId) override
         {
-            static constexpr const char * const LegacyFileNames[PATH_ID_END] =
+            static constexpr const char* const LegacyFileNames[PATH_ID_END]
-            {
+                = { nullptr,       nullptr,     "css1.dat",  "css2.dat",  "css4.dat",  "css5.dat",  "css6.dat",  "css7.dat",
-                nullptr,
+                    "css8.dat",    "css9.dat",  "css11.dat", "css12.dat", "css13.dat", "css14.dat", "css15.dat", "css3.dat",
-                nullptr,
+                    "css17.dat",   "css18.dat", "css19.dat", "css20.dat", "css21.dat", "css22.dat", nullptr,     "css23.dat",
-                "css1.dat",
+                    "css24.dat",   "css25.dat", "css26.dat", "css27.dat", "css28.dat", "css29.dat", "css30.dat", "css31.dat",
-                "css2.dat",
+                    "css32.dat",   "css33.dat", "css34.dat", "css35.dat", "css36.dat", "css37.dat", "css38.dat", "CUSTOM1.WAV",
-                "css4.dat",
+                    "CUSTOM2.WAV", "css39.dat", "css40.dat", "css41.dat", nullptr,     "css42.dat", "css43.dat", "css44.dat",
-                "css5.dat",
+                    "css45.dat",   "css46.dat", "css50.dat" };
-                "css6.dat",
-                "css7.dat",
-                "css8.dat",
-                "css9.dat",
-                "css11.dat",
-                "css12.dat",
-                "css13.dat",
-                "css14.dat",
-                "css15.dat",
-                "css3.dat",
-                "css17.dat",
-                "css18.dat",
-                "css19.dat",
-                "css20.dat",
-                "css21.dat",
-                "css22.dat",
-                nullptr,
-                "css23.dat",
-                "css24.dat",
-                "css25.dat",
-                "css26.dat",
-                "css27.dat",
-                "css28.dat",
-                "css29.dat",
-                "css30.dat",
-                "css31.dat",
-                "css32.dat",
-                "css33.dat",
-                "css34.dat",
-                "css35.dat",
-                "css36.dat",
-                "css37.dat",
-                "css38.dat",
-                "CUSTOM1.WAV",
-                "CUSTOM2.WAV",
-                "css39.dat",
-                "css40.dat",
-                "css41.dat",
-                nullptr,
-                "css42.dat",
-                "css43.dat",
-                "css44.dat",
-                "css45.dat",
-                "css46.dat",
-                "css50.dat"
-            };
 
             std::string result;
             if (pathId == PATH_ID_CSS50)
@@ -479,7 +431,7 @@ namespace OpenRCT2
                     drawingEngine->SetVSync(gConfigGeneral.use_vsync);
                     _drawingEngine = std::unique_ptr<IDrawingEngine>(std::move(drawingEngine));
                 }
-                catch (const std::exception &ex)
+                catch (const std::exception& ex)
                 {
                     _painter = nullptr;
                     if (_drawingEngineType == DRAWING_ENGINE_SOFTWARE)
@@ -509,27 +461,26 @@ namespace OpenRCT2
             _painter = nullptr;
         }
 
-        bool LoadParkFromFile(const std::string &path, bool loadTitleScreenOnFail) final override
+        bool LoadParkFromFile(const std::string& path, bool loadTitleScreenOnFail) final override
         {
             try
             {
                 auto fs = FileStream(path, FILE_MODE_OPEN);
                 return LoadParkFromStream(&fs, path, loadTitleScreenOnFail);
             }
-            catch (const std::exception &e)
+            catch (const std::exception& e)
             {
                 Console::Error::WriteLine(e.what());
             }
             return false;
         }
 
-        bool LoadParkFromStream(IStream * stream, const std::string &path, bool loadTitleScreenFirstOnFail) final override
+        bool LoadParkFromStream(IStream* stream, const std::string& path, bool loadTitleScreenFirstOnFail) final override
         {
             ClassifiedFileInfo info;
             if (TryClassifyFile(stream, &info))
             {
-                if (info.Type == FILE_TYPE::SAVED_GAME ||
+                if (info.Type == FILE_TYPE::SAVED_GAME || info.Type == FILE_TYPE::SCENARIO)
-                    info.Type == FILE_TYPE::SCENARIO)
                 {
                     std::unique_ptr<IParkImporter> parkImporter;
                     if (info.Version <= FILE_TYPE_S4_CUTOFF)
@@ -545,7 +496,8 @@ namespace OpenRCT2
 
                     try
                     {
-                        auto result = parkImporter->LoadFromStream(stream, info.Type == FILE_TYPE::SCENARIO, false, path.c_str());
+                        auto result
+                            = parkImporter->LoadFromStream(stream, info.Type == FILE_TYPE::SCENARIO, false, path.c_str());
                         _objectManager->LoadObjects(result.RequiredObjects.data(), result.RequiredObjects.size());
                         parkImporter->Import();
                         String::Set(gScenarioSavePath, Util::CountOf(gScenarioSavePath), path.c_str());
@@ -596,7 +548,7 @@ namespace OpenRCT2
                         // which the window function doesn't like
                         auto intent = Intent(WC_OBJECT_LOAD_ERROR);
                         intent.putExtra(INTENT_EXTRA_PATH, path);
-                        intent.putExtra(INTENT_EXTRA_LIST, (void *)e.MissingObjects.data());
+                        intent.putExtra(INTENT_EXTRA_LIST, (void*)e.MissingObjects.data());
                         intent.putExtra(INTENT_EXTRA_LIST_COUNT, (uint32_t)e.MissingObjects.size());
 
                         auto windowManager = _uiContext->GetWindowManager();
@@ -649,7 +601,8 @@ namespace OpenRCT2
                     {
                         utf8 path[MAX_PATH];
                         config_get_default_path(path, sizeof(path));
-                        Console::Error::WriteLine("An RCT2 install directory must be specified! Please edit \"game_path\" in %s.\n", path);
+                        Console::Error::WriteLine(
+                            "An RCT2 install directory must be specified! Please edit \"game_path\" in %s.\n", path);
                         return std::string();
                     }
                 }
@@ -696,95 +649,96 @@ namespace OpenRCT2
                 }
             }
 
-            switch (gOpenRCT2StartupAction) {
+            switch (gOpenRCT2StartupAction)
-            case STARTUP_ACTION_INTRO:
-                gIntroState = INTRO_STATE_PUBLISHER_BEGIN;
-                title_load();
-                break;
-            case STARTUP_ACTION_TITLE:
-                title_load();
-                break;
-            case STARTUP_ACTION_OPEN:
             {
-                // A path that includes "://" is illegal with all common filesystems, so it is almost certainly a URL
+                case STARTUP_ACTION_INTRO:
-                // This way all cURL supported protocols, like http, ftp, scp and smb are automatically handled
+                    gIntroState = INTRO_STATE_PUBLISHER_BEGIN;
-                if (strstr(gOpenRCT2StartupActionPath, "://") != nullptr)
+                    title_load();
+                    break;
+                case STARTUP_ACTION_TITLE:
+                    title_load();
+                    break;
+                case STARTUP_ACTION_OPEN:
                 {
+                    // A path that includes "://" is illegal with all common filesystems, so it is almost certainly a URL
+                    // This way all cURL supported protocols, like http, ftp, scp and smb are automatically handled
+                    if (strstr(gOpenRCT2StartupActionPath, "://") != nullptr)
+                    {
 #ifndef DISABLE_HTTP
-                    // Download park and open it using its temporary filename
+                        // Download park and open it using its temporary filename
-                    void * data;
+                        void* data;
-                    size_t dataSize = Network::Http::DownloadPark(gOpenRCT2StartupActionPath, &data);
+                        size_t dataSize = Network::Http::DownloadPark(gOpenRCT2StartupActionPath, &data);
-                    if (dataSize == 0)
+                        if (dataSize == 0)
-                    {
-                        title_load();
-                        break;
-                    }
-
-                    auto ms = MemoryStream(data, dataSize, MEMORY_ACCESS::OWNER);
-                    if (!LoadParkFromStream(&ms, gOpenRCT2StartupActionPath, true))
-                    {
-                        Console::Error::WriteLine("Failed to load '%s'", gOpenRCT2StartupActionPath);
-                        title_load();
-                        break;
-                    }
-#endif
-                }
-                else
-                {
-                    try
-                    {
-                        if (!LoadParkFromFile(gOpenRCT2StartupActionPath, true))
                         {
+                            title_load();
                             break;
                         }
-                    }
-                    catch (const std::exception &ex)
-                    {
-                        Console::Error::WriteLine("Failed to load '%s'", gOpenRCT2StartupActionPath);
-                        Console::Error::WriteLine("%s", ex.what());
-                        title_load();
-                        break;
-                    }
-                }
 
-                gScreenFlags = SCREEN_FLAGS_PLAYING;
+                        auto ms = MemoryStream(data, dataSize, MEMORY_ACCESS::OWNER);
-
+                        if (!LoadParkFromStream(&ms, gOpenRCT2StartupActionPath, true))
-#ifndef DISABLE_NETWORK
+                        {
-                if (gNetworkStart == NETWORK_MODE_SERVER)
+                            Console::Error::WriteLine("Failed to load '%s'", gOpenRCT2StartupActionPath);
-                {
+                            title_load();
-                    if (gNetworkStartPort == 0)
+                            break;
-                    {
+                        }
-                        gNetworkStartPort = gConfigNetwork.default_port;
+#endif
-                    }
-
-                    if (String::IsNullOrEmpty(gNetworkStartAddress))
-                    {
-                        gNetworkStartAddress = gConfigNetwork.listen_address;
-                    }
-
-                    if (String::IsNullOrEmpty(gCustomPassword))
-                    {
-                        network_set_password(gConfigNetwork.default_password);
                     }
                     else
                     {
-                        network_set_password(gCustomPassword);
+                        try
+                        {
+                            if (!LoadParkFromFile(gOpenRCT2StartupActionPath, true))
+                            {
+                                break;
+                            }
+                        }
+                        catch (const std::exception& ex)
+                        {
+                            Console::Error::WriteLine("Failed to load '%s'", gOpenRCT2StartupActionPath);
+                            Console::Error::WriteLine("%s", ex.what());
+                            title_load();
+                            break;
+                        }
+                    }
+
+                    gScreenFlags = SCREEN_FLAGS_PLAYING;
+
+#ifndef DISABLE_NETWORK
+                    if (gNetworkStart == NETWORK_MODE_SERVER)
+                    {
+                        if (gNetworkStartPort == 0)
+                        {
+                            gNetworkStartPort = gConfigNetwork.default_port;
+                        }
+
+                        if (String::IsNullOrEmpty(gNetworkStartAddress))
+                        {
+                            gNetworkStartAddress = gConfigNetwork.listen_address;
+                        }
+
+                        if (String::IsNullOrEmpty(gCustomPassword))
+                        {
+                            network_set_password(gConfigNetwork.default_password);
+                        }
+                        else
+                        {
+                            network_set_password(gCustomPassword);
+                        }
+                        network_begin_server(gNetworkStartPort, gNetworkStartAddress);
                     }
-                    network_begin_server(gNetworkStartPort, gNetworkStartAddress);
-                }
 #endif // DISABLE_NETWORK
-                break;
+                    break;
-            }
-            case STARTUP_ACTION_EDIT:
-                if (String::SizeOf(gOpenRCT2StartupActionPath) == 0)
-                {
-                    Editor::Load();
                 }
-                else if (!Editor::LoadLandscape(gOpenRCT2StartupActionPath))
+                case STARTUP_ACTION_EDIT:
-                {
+                    if (String::SizeOf(gOpenRCT2StartupActionPath) == 0)
-                    title_load();
+                    {
-                }
+                        Editor::Load();
-                break;
+                    }
+                    else if (!Editor::LoadLandscape(gOpenRCT2StartupActionPath))
+                    {
+                        title_load();
+                    }
+                    break;
             }
 
 #ifndef DISABLE_NETWORK
@@ -808,16 +762,20 @@ namespace OpenRCT2
 
         bool ShouldRunVariableFrame()
         {
-            if (!gConfigGeneral.uncap_fps) return false;
+            if (!gConfigGeneral.uncap_fps)
-            if (gGameSpeed > 4) return false;
+                return false;
-            if (gOpenRCT2Headless) return false;
+            if (gGameSpeed > 4)
-            if (_uiContext->IsMinimised()) return false;
+                return false;
+            if (gOpenRCT2Headless)
+                return false;
+            if (_uiContext->IsMinimised())
+                return false;
             return true;
         }
 
         /**
-        * Run the main game loop until the finished flag is set.
+         * Run the main game loop until the finished flag is set.
-        */
+         */
         void RunGameLoop()
         {
             log_verbose("begin openrct2 loop");
@@ -828,14 +786,16 @@ namespace OpenRCT2
             do
             {
                 RunFrame();
-            }
+            } while (!_finished);
-            while (!_finished);
 #else
-            emscripten_set_main_loop_arg([](void * vctx) ->
+            emscripten_set_main_loop_arg(
-                {
+                [](void* vctx) -> {
-                    auto ctx = reinterpret_cast<Context *>(vctx);
+                    auto ctx = reinterpret_cast<Context*>(vctx);
                     ctx->RunFrame();
-                }, this, 0, 1);
+                },
+                this,
+                0,
+                1);
 #endif // __EMSCRIPTEN__
             log_verbose("finish openrct2 loop");
         }
@@ -914,7 +874,7 @@ namespace OpenRCT2
             while (_accumulator >= GAME_UPDATE_TIME_MS)
             {
                 // Get the original position of each sprite
-                if(draw)
+                if (draw)
                     sprite_position_tween_store_a();
 
                 Update();
@@ -922,7 +882,7 @@ namespace OpenRCT2
                 _accumulator -= GAME_UPDATE_TIME_MS;
 
                 // Get the next position of each sprite
-                if(draw)
+                if (draw)
                     sprite_position_tween_store_b();
             }
 
@@ -979,22 +939,22 @@ namespace OpenRCT2
         }
 
         /**
-        * Copy saved games and landscapes to user directory
+         * Copy saved games and landscapes to user directory
-        */
+         */
         void CopyOriginalUserFilesOver()
         {
             CopyOriginalUserFilesOver(DIRID::SAVE, "*.sv6");
             CopyOriginalUserFilesOver(DIRID::LANDSCAPE, "*.sc6");
         }
 
-        void CopyOriginalUserFilesOver(DIRID dirid, const std::string &pattern)
+        void CopyOriginalUserFilesOver(DIRID dirid, const std::string& pattern)
         {
             auto src = _env->GetDirectoryPath(DIRBASE::RCT2, dirid);
             auto dst = _env->GetDirectoryPath(DIRBASE::USER, dirid);
             CopyOriginalUserFilesOver(src, dst, pattern);
         }
 
-        void CopyOriginalUserFilesOver(const std::string &srcRoot, const std::string &dstRoot, const std::string &pattern)
+        void CopyOriginalUserFilesOver(const std::string& srcRoot, const std::string& dstRoot, const std::string& pattern)
         {
             log_verbose("CopyOriginalUserFilesOver('%s', '%s', '%s')", srcRoot.c_str(), dstRoot.c_str(), pattern.c_str());
 
@@ -1031,7 +991,7 @@ namespace OpenRCT2
         }
     };
 
-    Context * Context::Instance = nullptr;
+    Context* Context::Instance = nullptr;
 
     std::unique_ptr<IContext> CreateContext()
     {
@@ -1046,28 +1006,28 @@ namespace OpenRCT2
         return std::make_unique<Context>(env, audioContext, uiContext);
     }
 
-    IContext * GetContext()
+    IContext* GetContext()
     {
         return Context::Instance;
     }
-}
+} // namespace OpenRCT2
 
 void context_init()
 {
     GetContext()->GetUiContext()->GetWindowManager()->Init();
 }
 
-bool context_load_park_from_file(const utf8 * path)
+bool context_load_park_from_file(const utf8* path)
 {
     return GetContext()->LoadParkFromFile(path);
 }
 
-bool context_load_park_from_stream(void * stream)
+bool context_load_park_from_stream(void* stream)
 {
     return GetContext()->LoadParkFromStream((IStream*)stream, "");
 }
 
-void openrct2_write_full_version_info(utf8 * buffer, size_t bufferSize)
+void openrct2_write_full_version_info(utf8* buffer, size_t bufferSize)
 {
     String::Set(buffer, bufferSize, gVersionInfoFull);
 }
@@ -1097,12 +1057,12 @@ void context_show_cursor()
     GetContext()->GetUiContext()->SetCursorVisible(true);
 }
 
-void context_get_cursor_position(int32_t * x, int32_t * y)
+void context_get_cursor_position(int32_t* x, int32_t* y)
 {
     GetContext()->GetUiContext()->GetCursorPosition(x, y);
 }
 
-void context_get_cursor_position_scaled(int32_t * x, int32_t * y)
+void context_get_cursor_position_scaled(int32_t* x, int32_t* y)
 {
     context_get_cursor_position(x, y);
 
@@ -1116,22 +1076,22 @@ void context_set_cursor_position(int32_t x, int32_t y)
     GetContext()->GetUiContext()->SetCursorPosition(x, y);
 }
 
-const CursorState * context_get_cursor_state()
+const CursorState* context_get_cursor_state()
 {
     return GetContext()->GetUiContext()->GetCursorState();
 }
 
-const uint8_t * context_get_keys_state()
+const uint8_t* context_get_keys_state()
 {
     return GetContext()->GetUiContext()->GetKeysState();
 }
 
-const uint8_t * context_get_keys_pressed()
+const uint8_t* context_get_keys_pressed()
 {
     return GetContext()->GetUiContext()->GetKeysPressed();
 }
 
-TextInputSession * context_start_text_input(utf8 * buffer, size_t maxLength)
+TextInputSession* context_start_text_input(utf8* buffer, size_t maxLength)
 {
     return GetContext()->GetUiContext()->StartTextInput(buffer, maxLength);
 }
@@ -1161,13 +1121,13 @@ void context_recreate_window()
     GetContext()->GetUiContext()->RecreateWindow();
 }
 
-int32_t context_get_resolutions(Resolution * * outResolutions)
+int32_t context_get_resolutions(Resolution** outResolutions)
 {
-auto resolutions = GetContext()->GetUiContext()->GetFullscreenResolutions();
+    auto resolutions = GetContext()->GetUiContext()->GetFullscreenResolutions();
-int32_t count = (int32_t)resolutions.size();
+    int32_t count = (int32_t)resolutions.size();
-*outResolutions = Memory::AllocateArray<Resolution>(count);
+    *outResolutions = Memory::AllocateArray<Resolution>(count);
-std::copy_n(resolutions.begin(), count, *outResolutions);
+    std::copy_n(resolutions.begin(), count, *outResolutions);
-return count;
+    return count;
 }
 
 int32_t context_get_width()
@@ -1190,31 +1150,31 @@ void context_set_cursor_trap(bool value)
     GetContext()->GetUiContext()->SetCursorTrap(value);
 }
 
-rct_window * context_open_window(rct_windowclass wc)
+rct_window* context_open_window(rct_windowclass wc)
 {
     auto windowManager = GetContext()->GetUiContext()->GetWindowManager();
     return windowManager->OpenWindow(wc);
 }
 
-rct_window * context_open_window_view(rct_windowclass wc)
+rct_window* context_open_window_view(rct_windowclass wc)
 {
     auto windowManager = GetContext()->GetUiContext()->GetWindowManager();
     return windowManager->OpenView(wc);
 }
 
-rct_window * context_open_detail_window(uint8_t type, int32_t id)
+rct_window* context_open_detail_window(uint8_t type, int32_t id)
 {
     auto windowManager = GetContext()->GetUiContext()->GetWindowManager();
     return windowManager->OpenDetails(type, id);
 }
 
-rct_window * context_open_intent(Intent * intent)
+rct_window* context_open_intent(Intent* intent)
 {
     auto windowManager = GetContext()->GetUiContext()->GetWindowManager();
     return windowManager->OpenIntent(intent);
 }
 
-void context_broadcast_intent(Intent * intent)
+void context_broadcast_intent(Intent* intent)
 {
     auto windowManager = GetContext()->GetUiContext()->GetWindowManager();
     windowManager->BroadcastIntent(*intent);
@@ -1226,7 +1186,7 @@ void context_force_close_window_by_class(rct_windowclass windowClass)
     windowManager->ForceClose(windowClass);
 }
 
-rct_window * context_show_error(rct_string_id title, rct_string_id message)
+rct_window* context_show_error(rct_string_id title, rct_string_id message)
 {
     auto windowManager = GetContext()->GetUiContext()->GetWindowManager();
     return windowManager->ShowError(title, message);
@@ -1255,7 +1215,7 @@ void context_quit()
     GetContext()->Quit();
 }
 
-const utf8 * context_get_path_legacy(int32_t pathId)
+const utf8* context_get_path_legacy(int32_t pathId)
 {
     static utf8 result[MAX_PATH];
     auto path = GetContext()->GetPathLegacy(pathId);
@@ -1263,7 +1223,7 @@ const utf8 * context_get_path_legacy(int32_t pathId)
     return result;
 }
 
-bool platform_open_common_file_dialog(utf8 * outFilename, file_dialog_desc * desc, size_t outSize)
+bool platform_open_common_file_dialog(utf8* outFilename, file_dialog_desc* desc, size_t outSize)
 {
     try
     {
@@ -1272,7 +1232,7 @@ bool platform_open_common_file_dialog(utf8 * outFilename, file_dialog_desc * des
         desc2.Title = String::ToStd(desc->title);
         desc2.InitialDirectory = String::ToStd(desc->initial_directory);
         desc2.DefaultFilename = String::ToStd(desc->default_filename);
-        for (const auto &filter : desc->filters)
+        for (const auto& filter : desc->filters)
         {
             if (filter.name != nullptr)
             {
@@ -1283,7 +1243,7 @@ bool platform_open_common_file_dialog(utf8 * outFilename, file_dialog_desc * des
         String::Set(outFilename, outSize, result.c_str());
         return !result.empty();
     }
-    catch (const std::exception &ex)
+    catch (const std::exception& ex)
     {
         log_error(ex.what());
         outFilename[0] = '\0';
@@ -1291,14 +1251,14 @@ bool platform_open_common_file_dialog(utf8 * outFilename, file_dialog_desc * des
     }
 }
 
-utf8 * platform_open_directory_browser(const utf8 * title)
+utf8* platform_open_directory_browser(const utf8* title)
 {
     try
     {
         std::string result = GetContext()->GetUiContext()->ShowDirectoryDialog(title);
         return String::Duplicate(result.c_str());
     }
-    catch (const std::exception &ex)
+    catch (const std::exception& ex)
     {
         log_error(ex.what());
         return nullptr;
@@ -1314,7 +1274,7 @@ bool platform_place_string_on_clipboard(utf8* target)
  * This function is deprecated.
  * Use IPlatformEnvironment instead.
  */
-void platform_get_user_directory(utf8 * outPath, const utf8 * subDirectory, size_t outSize)
+void platform_get_user_directory(utf8* outPath, const utf8* subDirectory, size_t outSize)
 {
     auto env = GetContext()->GetPlatformEnvironment();
     auto path = env->GetDirectoryPath(DIRBASE::USER);
@@ -1329,7 +1289,7 @@ void platform_get_user_directory(utf8 * outPath, const utf8 * subDirectory, size
  * This function is deprecated.
  * Use IPlatformEnvironment instead.
  */
-void platform_get_openrct_data_path(utf8 * outPath, size_t outSize)
+void platform_get_openrct_data_path(utf8* outPath, size_t outSize)
 {
     auto env = GetContext()->GetPlatformEnvironment();
     auto path = env->GetDirectoryPath(DIRBASE::OPENRCT2);

src/openrct2/Context.h

@@ -26,24 +26,24 @@ using rct_windowclass = uint8_t;
 
 struct CursorState
 {
-    int32_t  x, y;
+    int32_t x, y;
-    uint8_t   left, middle, right, any;
+    uint8_t left, middle, right, any;
-    int32_t  wheel;
+    int32_t wheel;
-    int32_t  old;
+    int32_t old;
-    bool    touch, touchIsDouble;
+    bool touch, touchIsDouble;
-    uint32_t  touchDownTimestamp;
+    uint32_t touchDownTimestamp;
 };
 
 struct TextInputSession
 {
-    utf8 * Buffer;          // UTF-8 stream
+    utf8* Buffer;          // UTF-8 stream
-    size_t BufferSize;      // Maximum number of bytes (excluding null terminator)
+    size_t BufferSize;     // Maximum number of bytes (excluding null terminator)
-    size_t Size;            // Number of bytes (excluding null terminator)
+    size_t Size;           // Number of bytes (excluding null terminator)
-    size_t Length;          // Number of codepoints
+    size_t Length;         // Number of codepoints
-    size_t SelectionStart;  // Selection start, in bytes
+    size_t SelectionStart; // Selection start, in bytes
-    size_t SelectionSize;   // Selection length in bytes
+    size_t SelectionSize;  // Selection length in bytes
 
-    const utf8 * ImeBuffer; // IME UTF-8 stream
+    const utf8* ImeBuffer; // IME UTF-8 stream
 };
 
 struct Resolution
@@ -95,24 +95,25 @@ namespace OpenRCT2
 
         virtual std::shared_ptr<Audio::IAudioContext> GetAudioContext() abstract;
         virtual std::shared_ptr<Ui::IUiContext> GetUiContext() abstract;
-        virtual GameState * GetGameState() abstract;
+        virtual GameState* GetGameState() abstract;
         virtual std::shared_ptr<IPlatformEnvironment> GetPlatformEnvironment() abstract;
         virtual Localisation::LocalisationService& GetLocalisationService() abstract;
         virtual std::shared_ptr<IObjectManager> GetObjectManager() abstract;
         virtual std::shared_ptr<IObjectRepository> GetObjectRepository() abstract;
-        virtual ITrackDesignRepository * GetTrackDesignRepository() abstract;
+        virtual ITrackDesignRepository* GetTrackDesignRepository() abstract;
-        virtual IScenarioRepository *    GetScenarioRepository() abstract;
+        virtual IScenarioRepository* GetScenarioRepository() abstract;
         virtual int32_t GetDrawingEngineType() abstract;
-        virtual Drawing::IDrawingEngine * GetDrawingEngine() abstract;
+        virtual Drawing::IDrawingEngine* GetDrawingEngine() abstract;
 
-        virtual int32_t RunOpenRCT2(int argc, const char * * argv) abstract;
+        virtual int32_t RunOpenRCT2(int argc, const char** argv) abstract;
 
         virtual bool Initialise() abstract;
         virtual void InitialiseDrawingEngine() abstract;
         virtual void DisposeDrawingEngine() abstract;
-        virtual bool LoadParkFromFile(const std::string &path, bool loadTitleScreenOnFail = false) abstract;
+        virtual bool LoadParkFromFile(const std::string& path, bool loadTitleScreenOnFail = false) abstract;
-        virtual bool LoadParkFromStream(IStream * stream, const std::string &path, bool loadTitleScreenFirstOnFail = false) abstract;
+        virtual bool LoadParkFromStream(IStream * stream, const std::string& path, bool loadTitleScreenFirstOnFail = false)
-        virtual void WriteLine(const std::string &s) abstract;
+            abstract;
+        virtual void WriteLine(const std::string& s) abstract;
         virtual void Finish() abstract;
         virtual void Quit() abstract;
 
@@ -127,7 +128,7 @@ namespace OpenRCT2
         const std::shared_ptr<IPlatformEnvironment>& env,
         const std::shared_ptr<Audio::IAudioContext>& audioContext,
         const std::shared_ptr<Ui::IUiContext>& uiContext);
-    IContext * GetContext();
+    IContext* GetContext();
 } // namespace OpenRCT2
 
 enum
@@ -207,35 +208,35 @@ void context_setcurrentcursor(int32_t cursor);
 void context_update_cursor_scale();
 void context_hide_cursor();
 void context_show_cursor();
-void context_get_cursor_position(int32_t * x, int32_t * y);
+void context_get_cursor_position(int32_t* x, int32_t* y);
-void context_get_cursor_position_scaled(int32_t * x, int32_t * y);
+void context_get_cursor_position_scaled(int32_t* x, int32_t* y);
 void context_set_cursor_position(int32_t x, int32_t y);
-const CursorState * context_get_cursor_state();
+const CursorState* context_get_cursor_state();
-const uint8_t * context_get_keys_state();
+const uint8_t* context_get_keys_state();
-const uint8_t * context_get_keys_pressed();
+const uint8_t* context_get_keys_pressed();
-TextInputSession * context_start_text_input(utf8 * buffer, size_t maxLength);
+TextInputSession* context_start_text_input(utf8* buffer, size_t maxLength);
 void context_stop_text_input();
 bool context_is_input_active();
 void context_trigger_resize();
 void context_set_fullscreen_mode(int32_t mode);
 void context_recreate_window();
-int32_t context_get_resolutions(struct Resolution * * outResolutions);
+int32_t context_get_resolutions(struct Resolution** outResolutions);
 int32_t context_get_width();
 int32_t context_get_height();
 bool context_has_focus();
 void context_set_cursor_trap(bool value);
-rct_window * context_open_window(rct_windowclass wc);
+rct_window* context_open_window(rct_windowclass wc);
-rct_window * context_open_detail_window(uint8_t type, int32_t id);
+rct_window* context_open_detail_window(uint8_t type, int32_t id);
-rct_window * context_open_window_view(uint8_t view);
+rct_window* context_open_window_view(uint8_t view);
-rct_window * context_show_error(rct_string_id title, rct_string_id message);
+rct_window* context_show_error(rct_string_id title, rct_string_id message);
-rct_window * context_open_intent(Intent * intent);
+rct_window* context_open_intent(Intent* intent);
-void context_broadcast_intent(Intent * intent);
+void context_broadcast_intent(Intent* intent);
 void context_force_close_window_by_class(rct_windowclass wc);
 void context_update_map_tooltip();
 void context_handle_input();
 void context_input_handle_keyboard(bool isTitle);
-bool context_read_bmp(void * * outPixels, uint32_t * outWidth, uint32_t * outHeight, const utf8 * path);
+bool context_read_bmp(void** outPixels, uint32_t* outWidth, uint32_t* outHeight, const utf8* path);
 void context_quit();
-const utf8 * context_get_path_legacy(int32_t pathId);
+const utf8* context_get_path_legacy(int32_t pathId);
-bool context_load_park_from_file(const utf8 * path);
+bool context_load_park_from_file(const utf8* path);
-bool context_load_park_from_stream(void * stream);
+bool context_load_park_from_stream(void* stream);

src/openrct2/Date.cpp

@@ -7,21 +7,22 @@
  * OpenRCT2 is licensed under the GNU General Public License version 3.
  *****************************************************************************/
 
+#include "localisation/Date.h"
+
+#include "Date.h"
 #include "core/Guard.hpp"
 #include "core/Math.hpp"
-#include "localisation/Date.h"
-#include "Date.h"
 
 using namespace OpenRCT2;
 
-constexpr int32_t MONTH_TICKS_INCREMENT  = 4;
+constexpr int32_t MONTH_TICKS_INCREMENT = 4;
-constexpr int32_t MASK_WEEK_TICKS        = 0x3FFF;
+constexpr int32_t MASK_WEEK_TICKS = 0x3FFF;
-constexpr int32_t MASK_FORTNIGHT_TICKS   = 0x7FFF;
+constexpr int32_t MASK_FORTNIGHT_TICKS = 0x7FFF;
-constexpr int32_t MASK_MONTH_TICKS       = 0xFFFF;
+constexpr int32_t MASK_MONTH_TICKS = 0xFFFF;
 
 Date::Date(uint32_t monthsElapsed, uint16_t monthTicks)
-    : _monthTicks(monthTicks),
+    : _monthTicks(monthTicks)
-      _monthsElapsed(monthsElapsed)
+    , _monthsElapsed(monthsElapsed)
 {
 }
 

src/openrct2/Date.h

@@ -19,8 +19,8 @@ namespace OpenRCT2
     class Date final
     {
     private:
-        uint16_t _monthTicks      = 0;
+        uint16_t _monthTicks = 0;
-        uint32_t _monthsElapsed   = 0;
+        uint32_t _monthsElapsed = 0;
 
     public:
         Date() = default;
@@ -43,4 +43,4 @@ namespace OpenRCT2
 
         static int32_t GetDaysInMonth(int32_t month);
     };
-}
+} // namespace OpenRCT2

src/openrct2/Diagnostic.cpp

@@ -7,10 +7,12 @@
  * OpenRCT2 is licensed under the GNU General Public License version 3.
  *****************************************************************************/
 
+#include "Diagnostic.h"
+
+#include "core/String.hpp"
+
 #include <cstdarg>
 #include <cstdio>
-#include "core/String.hpp"
-#include "Diagnostic.h"
 
 #ifdef __ANDROID__
 #include <android/log.h>
@@ -19,22 +21,24 @@
 [[maybe_unused]] static bool _log_location_enabled = true;
 bool _log_levels[DIAGNOSTIC_LEVEL_COUNT] = { true, true, true, false, true };
 
-static FILE * diagnostic_get_stream(DIAGNOSTIC_LEVEL level)
+static FILE* diagnostic_get_stream(DIAGNOSTIC_LEVEL level)
 {
-    switch (level) {
+    switch (level)
-    case DIAGNOSTIC_LEVEL_VERBOSE:
+    {
-    case DIAGNOSTIC_LEVEL_INFORMATION:
+        case DIAGNOSTIC_LEVEL_VERBOSE:
-        return stdout;
+        case DIAGNOSTIC_LEVEL_INFORMATION:
-    default:
+            return stdout;
-        return stderr;
+        default:
+            return stderr;
     }
 }
 
 #ifdef __ANDROID__
 
-int _android_log_priority[DIAGNOSTIC_LEVEL_COUNT] = {ANDROID_LOG_FATAL, ANDROID_LOG_ERROR, ANDROID_LOG_WARN, ANDROID_LOG_VERBOSE, ANDROID_LOG_INFO};
+int _android_log_priority[DIAGNOSTIC_LEVEL_COUNT]
+    = { ANDROID_LOG_FATAL, ANDROID_LOG_ERROR, ANDROID_LOG_WARN, ANDROID_LOG_VERBOSE, ANDROID_LOG_INFO };
 
-void diagnostic_log(DIAGNOSTIC_LEVEL diagnosticLevel, const char *format, ...)
+void diagnostic_log(DIAGNOSTIC_LEVEL diagnosticLevel, const char* format, ...)
 {
     va_list args;
 
@@ -46,7 +50,8 @@ void diagnostic_log(DIAGNOSTIC_LEVEL diagnosticLevel, const char *format, ...)
     va_end(args);
 }
 
-void diagnostic_log_with_location(DIAGNOSTIC_LEVEL diagnosticLevel, const char *file, const char *function, int32_t line, const char *format, ...)
+void diagnostic_log_with_location(
+    DIAGNOSTIC_LEVEL diagnosticLevel, const char* file, const char* function, int32_t line, const char* format, ...)
 {
     va_list args;
     char buf[1024];
@@ -63,15 +68,9 @@ void diagnostic_log_with_location(DIAGNOSTIC_LEVEL diagnosticLevel, const char *
 
 #else
 
-static constexpr const char * _level_strings[] = {
+static constexpr const char* _level_strings[] = { "FATAL", "ERROR", "WARNING", "VERBOSE", "INFO" };
-    "FATAL",
-    "ERROR",
-    "WARNING",
-    "VERBOSE",
-    "INFO"
-};
 
-void diagnostic_log(DIAGNOSTIC_LEVEL diagnosticLevel, const char *format, ...)
+void diagnostic_log(DIAGNOSTIC_LEVEL diagnosticLevel, const char* format, ...)
 {
     va_list args;
     if (_log_levels[diagnosticLevel])
@@ -89,7 +88,8 @@ void diagnostic_log(DIAGNOSTIC_LEVEL diagnosticLevel, const char *format, ...)
     }
 }
 
-void diagnostic_log_with_location(DIAGNOSTIC_LEVEL diagnosticLevel, const char *file, const char *function, int32_t line, const char *format, ...)
+void diagnostic_log_with_location(
+    DIAGNOSTIC_LEVEL diagnosticLevel, const char* file, const char* function, int32_t line, const char* format, ...)
 {
     va_list args;
     if (_log_levels[diagnosticLevel])

src/openrct2/Diagnostic.h

@@ -12,7 +12,8 @@
 
 #include <cstdint>
 
-enum DIAGNOSTIC_LEVEL {
+enum DIAGNOSTIC_LEVEL
+{
     DIAGNOSTIC_LEVEL_FATAL,
     DIAGNOSTIC_LEVEL_ERROR,
     DIAGNOSTIC_LEVEL_WARNING,
@@ -44,45 +45,48 @@ enum DIAGNOSTIC_LEVEL {
  */
 
 #if defined(DEBUG)
-    #if DEBUG > 0
+#if DEBUG > 0
-        #define DEBUG_LEVEL_1 1
+#define DEBUG_LEVEL_1 1
-        #if DEBUG > 1
+#if DEBUG > 1
-            #define DEBUG_LEVEL_2 1
+#define DEBUG_LEVEL_2 1
-            #if DEBUG > 2
+#if DEBUG > 2
-                #define DEBUG_LEVEL_3 1
+#define DEBUG_LEVEL_3 1
-            #else
-                #define DEBUG_LEVEL_3 0
-            #endif // DEBUG > 2
-        #else
-            #define DEBUG_LEVEL_3 0
-            #define DEBUG_LEVEL_2 0
-        #endif // DEBUG > 1
-    #else
-        #define DEBUG_LEVEL_1 0
-        #define DEBUG_LEVEL_2 0
-        #define DEBUG_LEVEL_3 0
-    #endif // DEBUG > 0
 #else
-    #define DEBUG_LEVEL_3 0
+#define DEBUG_LEVEL_3 0
-    #define DEBUG_LEVEL_2 0
+#endif // DEBUG > 2
-    #define DEBUG_LEVEL_1 0
+#else
+#define DEBUG_LEVEL_3 0
+#define DEBUG_LEVEL_2 0
+#endif // DEBUG > 1
+#else
+#define DEBUG_LEVEL_1 0
+#define DEBUG_LEVEL_2 0
+#define DEBUG_LEVEL_3 0
+#endif // DEBUG > 0
+#else
+#define DEBUG_LEVEL_3 0
+#define DEBUG_LEVEL_2 0
+#define DEBUG_LEVEL_1 0
 #endif // defined(DEBUG)
 
 extern bool _log_levels[DIAGNOSTIC_LEVEL_COUNT];
 
-void diagnostic_log(DIAGNOSTIC_LEVEL diagnosticLevel, const char *format, ...);
+void diagnostic_log(DIAGNOSTIC_LEVEL diagnosticLevel, const char* format, ...);
-void diagnostic_log_with_location(DIAGNOSTIC_LEVEL diagnosticLevel, const char *file, const char *function, int32_t line, const char *format, ...);
+void diagnostic_log_with_location(
+    DIAGNOSTIC_LEVEL diagnosticLevel, const char* file, const char* function, int32_t line, const char* format, ...);
 
 #ifdef _MSC_VER
-#define diagnostic_log_macro(level, format, ...)    diagnostic_log_with_location(level, __FILE__, __FUNCTION__, __LINE__, format, ## __VA_ARGS__)
+#define diagnostic_log_macro(level, format, ...)                                                                               \
+    diagnostic_log_with_location(level, __FILE__, __FUNCTION__, __LINE__, format, ##__VA_ARGS__)
 #else
-    #define diagnostic_log_macro(level, format, ...)    diagnostic_log_with_location(level, __FILE__, __func__, __LINE__, format, ## __VA_ARGS__)
+#define diagnostic_log_macro(level, format, ...)                                                                               \
+    diagnostic_log_with_location(level, __FILE__, __func__, __LINE__, format, ##__VA_ARGS__)
 #endif // _MSC_VER
 
-#define log_fatal(format, ...)      diagnostic_log_macro(DIAGNOSTIC_LEVEL_FATAL, format, ## __VA_ARGS__)
+#define log_fatal(format, ...) diagnostic_log_macro(DIAGNOSTIC_LEVEL_FATAL, format, ##__VA_ARGS__)
-#define log_error(format, ...)      diagnostic_log_macro(DIAGNOSTIC_LEVEL_ERROR, format, ## __VA_ARGS__)
+#define log_error(format, ...) diagnostic_log_macro(DIAGNOSTIC_LEVEL_ERROR, format, ##__VA_ARGS__)
-#define log_warning(format, ...)    diagnostic_log_macro(DIAGNOSTIC_LEVEL_WARNING, format, ## __VA_ARGS__)
+#define log_warning(format, ...) diagnostic_log_macro(DIAGNOSTIC_LEVEL_WARNING, format, ##__VA_ARGS__)
-#define log_verbose(format, ...)    diagnostic_log(DIAGNOSTIC_LEVEL_VERBOSE, format, ## __VA_ARGS__)
+#define log_verbose(format, ...) diagnostic_log(DIAGNOSTIC_LEVEL_VERBOSE, format, ##__VA_ARGS__)
-#define log_info(format, ...)       diagnostic_log_macro(DIAGNOSTIC_LEVEL_INFORMATION, format, ## __VA_ARGS__)
+#define log_info(format, ...) diagnostic_log_macro(DIAGNOSTIC_LEVEL_INFORMATION, format, ##__VA_ARGS__)
 
 #endif

src/openrct2/Editor.cpp

@@ -7,10 +7,9 @@
  * OpenRCT2 is licensed under the GNU General Public License version 3.
  *****************************************************************************/
 
-#include <array>
-#include <vector>
-#include "Context.h"
 #include "Editor.h"
+
+#include "Context.h"
 #include "EditorObjectSelectionSession.h"
 #include "FileClassifier.h"
 #include "Game.h"
@@ -26,15 +25,18 @@
 #include "peep/Staff.h"
 #include "rct1/RCT1.h"
 #include "scenario/Scenario.h"
+#include "ui/UiContext.h"
+#include "ui/WindowManager.h"
 #include "util/Util.h"
 #include "windows/Intent.h"
 #include "world/Climate.h"
 #include "world/Entrance.h"
 #include "world/Footpath.h"
-#include "world/Scenery.h"
 #include "world/Park.h"
-#include "ui/UiContext.h"
+#include "world/Scenery.h"
-#include "ui/WindowManager.h"
+
+#include <array>
+#include <vector>
 
 using namespace OpenRCT2;
 
@@ -42,12 +44,12 @@ namespace Editor
 {
     static std::array<std::vector<uint8_t>, OBJECT_TYPE_COUNT> _editorSelectedObjectFlags;
 
-    static void ConvertSaveToScenarioCallback(int32_t result, const utf8 * path);
+    static void ConvertSaveToScenarioCallback(int32_t result, const utf8* path);
     static void SetAllLandOwned();
-    static bool LoadLandscapeFromSV4(const char * path);
+    static bool LoadLandscapeFromSV4(const char* path);
-    static bool LoadLandscapeFromSC4(const char * path);
+    static bool LoadLandscapeFromSC4(const char* path);
     static void FinaliseMainView();
-    static bool ReadS6(const char * path);
+    static bool ReadS6(const char* path);
     static void ClearMapForEditing(bool fromSave);
 
     /**
@@ -65,7 +67,7 @@ namespace Editor
         gParkFlags |= PARK_FLAGS_SHOW_REAL_GUEST_NAMES;
         gS6Info.category = SCENARIO_CATEGORY_OTHER;
         viewport_init_all();
-        rct_window * mainWindow = context_open_window_view(WV_EDITOR_MAIN);
+        rct_window* mainWindow = context_open_window_view(WV_EDITOR_MAIN);
         window_set_location(mainWindow, 2400, 2400, 112);
         load_palette();
         gScreenAge = 0;
@@ -82,11 +84,11 @@ namespace Editor
         tool_cancel();
         auto intent = Intent(WC_LOADSAVE);
         intent.putExtra(INTENT_EXTRA_LOADSAVE_TYPE, LOADSAVETYPE_LOAD | LOADSAVETYPE_GAME);
-        intent.putExtra(INTENT_EXTRA_CALLBACK, (void *) ConvertSaveToScenarioCallback);
+        intent.putExtra(INTENT_EXTRA_CALLBACK, (void*)ConvertSaveToScenarioCallback);
         context_open_intent(&intent);
     }
 
-    static void ConvertSaveToScenarioCallback(int32_t result, const utf8 * path)
+    static void ConvertSaveToScenarioCallback(int32_t result, const utf8* path)
     {
         if (result != MODAL_RESULT_OK)
         {
@@ -110,7 +112,7 @@ namespace Editor
 
         safe_strcpy(gS6Info.name, gScenarioName, 64);
         safe_strcpy(gS6Info.details, gScenarioDetails, 256);
-        gS6Info.objective_type  = gScenarioObjectiveType;
+        gS6Info.objective_type = gScenarioObjectiveType;
         gS6Info.objective_arg_1 = gScenarioObjectiveYear;
         gS6Info.objective_arg_2 = gScenarioObjectiveCurrency;
         gS6Info.objective_arg_3 = gScenarioObjectiveNumGuests;
@@ -118,7 +120,7 @@ namespace Editor
 
         gScreenFlags = SCREEN_FLAGS_SCENARIO_EDITOR;
         gS6Info.editor_step = EDITOR_STEP_OBJECTIVE_SELECTION;
-        gS6Info.category    = SCENARIO_CATEGORY_OTHER;
+        gS6Info.category = SCENARIO_CATEGORY_OTHER;
         viewport_init_all();
         news_item_init_queue();
         context_open_window_view(WV_EDITOR_MAIN);
@@ -134,7 +136,7 @@ namespace Editor
     {
         audio_stop_all_music_and_sounds();
         gScreenFlags = SCREEN_FLAGS_TRACK_DESIGNER;
-        gScreenAge   = 0;
+        gScreenAge = 0;
 
         object_manager_unload_all_objects();
         object_list_load();
@@ -142,7 +144,7 @@ namespace Editor
         SetAllLandOwned();
         gS6Info.editor_step = EDITOR_STEP_OBJECT_SELECTION;
         viewport_init_all();
-        rct_window * mainWindow = context_open_window_view(WV_EDITOR_MAIN);
+        rct_window* mainWindow = context_open_window_view(WV_EDITOR_MAIN);
         window_set_location(mainWindow, 2400, 2400, 112);
         load_palette();
     }
@@ -155,7 +157,7 @@ namespace Editor
     {
         audio_stop_all_music_and_sounds();
         gScreenFlags = SCREEN_FLAGS_TRACK_MANAGER;
-        gScreenAge   = 0;
+        gScreenAge = 0;
 
         object_manager_unload_all_objects();
         object_list_load();
@@ -163,7 +165,7 @@ namespace Editor
         SetAllLandOwned();
         gS6Info.editor_step = EDITOR_STEP_OBJECT_SELECTION;
         viewport_init_all();
-        rct_window * mainWindow = context_open_window_view(WV_EDITOR_MAIN);
+        rct_window* mainWindow = context_open_window_view(WV_EDITOR_MAIN);
         window_set_location(mainWindow, 2400, 2400, 112);
         load_palette();
     }
@@ -183,7 +185,7 @@ namespace Editor
      *
      *  rct2: 0x006758C0
      */
-    bool LoadLandscape(const utf8 * path)
+    bool LoadLandscape(const utf8* path)
     {
         // #4996: Make sure the object selection window closes here to prevent unload objects
         //        after we have loaded a new park.
@@ -192,15 +194,15 @@ namespace Editor
         uint32_t extension = get_file_extension_type(path);
         switch (extension)
         {
-        case FILE_EXTENSION_SC6:
+            case FILE_EXTENSION_SC6:
-        case FILE_EXTENSION_SV6:
+            case FILE_EXTENSION_SV6:
-            return ReadS6(path);
+                return ReadS6(path);
-        case FILE_EXTENSION_SC4:
+            case FILE_EXTENSION_SC4:
-            return LoadLandscapeFromSC4(path);
+                return LoadLandscapeFromSC4(path);
-        case FILE_EXTENSION_SV4:
+            case FILE_EXTENSION_SV4:
-            return LoadLandscapeFromSV4(path);
+                return LoadLandscapeFromSV4(path);
-        default:
+            default:
-            return false;
+                return false;
         }
     }
 
@@ -208,13 +210,13 @@ namespace Editor
      *
      *  rct2: 0x006A2B02
      */
-    static bool LoadLandscapeFromSV4(const char * path)
+    static bool LoadLandscapeFromSV4(const char* path)
     {
         load_from_sv4(path);
         ClearMapForEditing(true);
 
         gS6Info.editor_step = EDITOR_STEP_LANDSCAPE_EDITOR;
-        gScreenAge   = 0;
+        gScreenAge = 0;
         gScreenFlags = SCREEN_FLAGS_SCENARIO_EDITOR;
         viewport_init_all();
         context_open_window_view(WV_EDITOR_MAIN);
@@ -222,13 +224,13 @@ namespace Editor
         return true;
     }
 
-    static bool LoadLandscapeFromSC4(const char * path)
+    static bool LoadLandscapeFromSC4(const char* path)
     {
         load_from_sc4(path);
         ClearMapForEditing(false);
 
         gS6Info.editor_step = EDITOR_STEP_LANDSCAPE_EDITOR;
-        gScreenAge   = 0;
+        gScreenAge = 0;
         gScreenFlags = SCREEN_FLAGS_SCENARIO_EDITOR;
         viewport_init_all();
         context_open_window_view(WV_EDITOR_MAIN);
@@ -240,9 +242,9 @@ namespace Editor
      *
      *  rct2: 0x006758FE
      */
-    static bool ReadS6(const char * path)
+    static bool ReadS6(const char* path)
     {
-        auto extension  = path_get_extension(path);
+        auto extension = path_get_extension(path);
         if (_stricmp(extension, ".sc6") == 0)
         {
             load_from_sc6(path);
@@ -255,7 +257,7 @@ namespace Editor
         ClearMapForEditing(true);
 
         gS6Info.editor_step = EDITOR_STEP_LANDSCAPE_EDITOR;
-        gScreenAge   = 0;
+        gScreenAge = 0;
         gScreenFlags = SCREEN_FLAGS_SCENARIO_EDITOR;
         viewport_init_all();
         context_open_window_view(WV_EDITOR_MAIN);
@@ -268,7 +270,7 @@ namespace Editor
         map_remove_all_rides();
 
         //
-        for (auto &banner : gBanners)
+        for (auto& banner : gBanners)
         {
             if (banner.type == 255)
             {
@@ -279,11 +281,11 @@ namespace Editor
         //
         {
             int32_t i;
-            Ride * ride;
+            Ride* ride;
-            FOR_ALL_RIDES(i, ride)
+            FOR_ALL_RIDES (i, ride)
-                {
+            {
-                    user_string_free(ride->name);
+                user_string_free(ride->name);
-                }
+            }
         }
 
         ride_init_all();
@@ -291,16 +293,16 @@ namespace Editor
         //
         for (int32_t i = 0; i < MAX_SPRITES; i++)
         {
-            rct_sprite * sprite = get_sprite(i);
+            rct_sprite* sprite = get_sprite(i);
             user_string_free(sprite->unknown.name_string_idx);
         }
 
         reset_sprite_list();
         staff_reset_modes();
-        gNumGuestsInPark         = 0;
+        gNumGuestsInPark = 0;
         gNumGuestsHeadingForPark = 0;
         gNumGuestsInParkLastWeek = 0;
-        gGuestChangeModifier     = 0;
+        gGuestChangeModifier = 0;
         if (fromSave)
         {
             research_populate_list_random();
@@ -331,17 +333,9 @@ namespace Editor
             gInitialCash = std::min(gInitialCash, 100000);
             finance_reset_cash_to_initial();
 
-            gBankLoan = Math::Clamp(
+            gBankLoan = Math::Clamp(MONEY(0, 00), gBankLoan, MONEY(5000000, 00));
-                MONEY(0, 00),
-                gBankLoan,
-                MONEY(5000000, 00)
-            );
 
-            gMaxBankLoan = Math::Clamp(
+            gMaxBankLoan = Math::Clamp(MONEY(0, 00), gMaxBankLoan, MONEY(5000000, 00));
-                MONEY(0, 00),
-                gMaxBankLoan,
-                MONEY(5000000, 00)
-            );
 
             gBankLoanInterestRate = Math::Clamp((uint8_t)5, gBankLoanInterestRate, (uint8_t)80);
         }
@@ -364,48 +358,48 @@ namespace Editor
 
         switch (gS6Info.editor_step)
         {
-        case EDITOR_STEP_OBJECT_SELECTION:
+            case EDITOR_STEP_OBJECT_SELECTION:
-            if (window_find_by_class(WC_EDITOR_OBJECT_SELECTION))
+                if (window_find_by_class(WC_EDITOR_OBJECT_SELECTION))
-            {
+                {
-                return;
+                    return;
-            }
+                }
 
-            if (window_find_by_class(WC_INSTALL_TRACK))
+                if (window_find_by_class(WC_INSTALL_TRACK))
-            {
+                {
-                return;
+                    return;
-            }
+                }
 
-            if (gScreenFlags & SCREEN_FLAGS_TRACK_MANAGER)
+                if (gScreenFlags & SCREEN_FLAGS_TRACK_MANAGER)
-            {
+                {
-                object_manager_unload_all_objects();
+                    object_manager_unload_all_objects();
-            }
+                }
 
-            context_open_window(WC_EDITOR_OBJECT_SELECTION);
+                context_open_window(WC_EDITOR_OBJECT_SELECTION);
-            break;
+                break;
-        case EDITOR_STEP_INVENTIONS_LIST_SET_UP:
+            case EDITOR_STEP_INVENTIONS_LIST_SET_UP:
-            if (window_find_by_class(WC_EDITOR_INVENTION_LIST))
+                if (window_find_by_class(WC_EDITOR_INVENTION_LIST))
-            {
+                {
-                return;
+                    return;
-            }
+                }
 
-            context_open_window(WC_EDITOR_INVENTION_LIST);
+                context_open_window(WC_EDITOR_INVENTION_LIST);
-            break;
+                break;
-        case EDITOR_STEP_OPTIONS_SELECTION:
+            case EDITOR_STEP_OPTIONS_SELECTION:
-            if (window_find_by_class(WC_EDITOR_SCENARIO_OPTIONS))
+                if (window_find_by_class(WC_EDITOR_SCENARIO_OPTIONS))
-            {
+                {
-                return;
+                    return;
-            }
+                }
 
-            context_open_window(WC_EDITOR_SCENARIO_OPTIONS);
+                context_open_window(WC_EDITOR_SCENARIO_OPTIONS);
-            break;
+                break;
-        case EDITOR_STEP_OBJECTIVE_SELECTION:
+            case EDITOR_STEP_OBJECTIVE_SELECTION:
-            if (window_find_by_class(WC_EDTIOR_OBJECTIVE_OPTIONS))
+                if (window_find_by_class(WC_EDTIOR_OBJECTIVE_OPTIONS))
-            {
+                {
-                return;
+                    return;
-            }
+                }
 
-            context_open_window(WC_EDTIOR_OBJECTIVE_OPTIONS);
+                context_open_window(WC_EDTIOR_OBJECTIVE_OPTIONS);
-            break;
+                break;
         }
     }
 
@@ -431,8 +425,7 @@ namespace Editor
      */
     int32_t CheckObjectSelection()
     {
-        bool isTrackDesignerManager =
+        bool isTrackDesignerManager = gScreenFlags & (SCREEN_FLAGS_TRACK_DESIGNER | SCREEN_FLAGS_TRACK_MANAGER);
-                 gScreenFlags & (SCREEN_FLAGS_TRACK_DESIGNER | SCREEN_FLAGS_TRACK_MANAGER);
 
         if (!isTrackDesignerManager)
         {
@@ -494,31 +487,31 @@ namespace Editor
             }
         }
 
-        for (const auto &parkEntrance : gParkEntrances)
+        for (const auto& parkEntrance : gParkEntrances)
         {
             if (parkEntrance.x == LOCATION_NULL)
             {
                 continue;
             }
 
-            int32_t x         = parkEntrance.x;
+            int32_t x = parkEntrance.x;
-            int32_t y         = parkEntrance.y;
+            int32_t y = parkEntrance.y;
-            int32_t z         = parkEntrance.z / 8;
+            int32_t z = parkEntrance.z / 8;
             int32_t direction = parkEntrance.direction ^ 2;
 
             switch (footpath_is_connected_to_map_edge(x, y, z, direction, 0))
             {
-            case FOOTPATH_SEARCH_NOT_FOUND:
+                case FOOTPATH_SEARCH_NOT_FOUND:
-                gGameCommandErrorText = STR_PARK_ENTRANCE_WRONG_DIRECTION_OR_NO_PATH;
+                    gGameCommandErrorText = STR_PARK_ENTRANCE_WRONG_DIRECTION_OR_NO_PATH;
-                return false;
+                    return false;
-            case FOOTPATH_SEARCH_INCOMPLETE:
+                case FOOTPATH_SEARCH_INCOMPLETE:
-            case FOOTPATH_SEARCH_TOO_COMPLEX:
+                case FOOTPATH_SEARCH_TOO_COMPLEX:
-                gGameCommandErrorText = STR_PARK_ENTRANCE_PATH_INCOMPLETE_OR_COMPLEX;
+                    gGameCommandErrorText = STR_PARK_ENTRANCE_PATH_INCOMPLETE_OR_COMPLEX;
-                return false;
+                    return false;
-            case FOOTPATH_SEARCH_SUCCESS:
+                case FOOTPATH_SEARCH_SUCCESS:
-                // Run the search again and unown the path
+                    // Run the search again and unown the path
-                footpath_is_connected_to_map_edge(x, y, z, direction, (1 << 5));
+                    footpath_is_connected_to_map_edge(x, y, z, direction, (1 << 5));
-                break;
+                    break;
             }
         }
 
@@ -540,13 +533,13 @@ namespace Editor
     }
 
     void GameCommandEditScenarioOptions(
-        [[maybe_unused]] int32_t * eax,
+        [[maybe_unused]] int32_t* eax,
-        int32_t *                  ebx,
+        int32_t* ebx,
-        int32_t *                  ecx,
+        int32_t* ecx,
-        int32_t *                  edx,
+        int32_t* edx,
-        [[maybe_unused]] int32_t * esi,
+        [[maybe_unused]] int32_t* esi,
-        [[maybe_unused]] int32_t * edi,
+        [[maybe_unused]] int32_t* edi,
-        [[maybe_unused]] int32_t * ebp)
+        [[maybe_unused]] int32_t* ebp)
     {
         if (!(*ebx & GAME_COMMAND_FLAG_APPLY))
         {
@@ -556,202 +549,202 @@ namespace Editor
 
         switch (*ecx)
         {
-        case EDIT_SCENARIOOPTIONS_SETNOMONEY:
+            case EDIT_SCENARIOOPTIONS_SETNOMONEY:
-            if (gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR)
+                if (gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR)
-            {
-                if (*edx != 0)
                 {
-                    gParkFlags |= PARK_FLAGS_NO_MONEY_SCENARIO;
+                    if (*edx != 0)
+                    {
+                        gParkFlags |= PARK_FLAGS_NO_MONEY_SCENARIO;
+                    }
+                    else
+                    {
+                        gParkFlags &= ~PARK_FLAGS_NO_MONEY_SCENARIO;
+                    }
                 }
                 else
                 {
-                    gParkFlags &= ~PARK_FLAGS_NO_MONEY_SCENARIO;
+                    if (*edx != 0)
+                    {
+                        gParkFlags |= PARK_FLAGS_NO_MONEY;
+                    }
+                    else
+                    {
+                        gParkFlags &= ~PARK_FLAGS_NO_MONEY;
+                    }
+                    // Invalidate all windows that have anything to do with finance
+                    window_invalidate_by_class(WC_RIDE);
+                    window_invalidate_by_class(WC_PEEP);
+                    window_invalidate_by_class(WC_PARK_INFORMATION);
+                    window_invalidate_by_class(WC_FINANCES);
+                    window_invalidate_by_class(WC_BOTTOM_TOOLBAR);
+                    window_invalidate_by_class(WC_TOP_TOOLBAR);
                 }
-            }
+                break;
-            else
+            case EDIT_SCENARIOOPTIONS_SETINITIALCASH:
-            {
+                gInitialCash = Math::Clamp(MONEY(0, 00), *edx, MONEY(1000000, 00));
-                if (*edx != 0)
+                gCash = gInitialCash;
-                {
-                    gParkFlags |= PARK_FLAGS_NO_MONEY;
-                }
-                else
-                {
-                    gParkFlags &= ~PARK_FLAGS_NO_MONEY;
-                }
-                // Invalidate all windows that have anything to do with finance
-                window_invalidate_by_class(WC_RIDE);
-                window_invalidate_by_class(WC_PEEP);
-                window_invalidate_by_class(WC_PARK_INFORMATION);
                 window_invalidate_by_class(WC_FINANCES);
                 window_invalidate_by_class(WC_BOTTOM_TOOLBAR);
-                window_invalidate_by_class(WC_TOP_TOOLBAR);
+                break;
-            }
+            case EDIT_SCENARIOOPTIONS_SETINITIALLOAN:
-            break;
+                gBankLoan = Math::Clamp(MONEY(0, 00), *edx, MONEY(5000000, 00));
-        case EDIT_SCENARIOOPTIONS_SETINITIALCASH:
+                gMaxBankLoan = std::max(gBankLoan, gMaxBankLoan);
-            gInitialCash   = Math::Clamp(MONEY(0, 00), *edx, MONEY(1000000, 00));
+                window_invalidate_by_class(WC_FINANCES);
-            gCash = gInitialCash;
+                break;
-            window_invalidate_by_class(WC_FINANCES);
+            case EDIT_SCENARIOOPTIONS_SETMAXIMUMLOANSIZE:
-            window_invalidate_by_class(WC_BOTTOM_TOOLBAR);
+                gMaxBankLoan = Math::Clamp(MONEY(0, 00), *edx, MONEY(5000000, 00));
-            break;
+                gBankLoan = std::min(gBankLoan, gMaxBankLoan);
-        case EDIT_SCENARIOOPTIONS_SETINITIALLOAN:
+                window_invalidate_by_class(WC_FINANCES);
-            gBankLoan    = Math::Clamp(MONEY(0, 00), *edx, MONEY(5000000, 00));
+                break;
-            gMaxBankLoan = std::max(gBankLoan, gMaxBankLoan);
+            case EDIT_SCENARIOOPTIONS_SETANNUALINTERESTRATE:
-            window_invalidate_by_class(WC_FINANCES);
+                gBankLoanInterestRate = Math::Clamp(0, *edx, 80);
-            break;
+                window_invalidate_by_class(WC_FINANCES);
-        case EDIT_SCENARIOOPTIONS_SETMAXIMUMLOANSIZE:
+                break;
-            gMaxBankLoan = Math::Clamp(MONEY(0, 00), *edx, MONEY(5000000, 00));
+            case EDIT_SCENARIOOPTIONS_SETFORBIDMARKETINGCAMPAIGNS:
-            gBankLoan    = std::min(gBankLoan, gMaxBankLoan);
+                if (*edx != 0)
-            window_invalidate_by_class(WC_FINANCES);
-            break;
-        case EDIT_SCENARIOOPTIONS_SETANNUALINTERESTRATE:
-            gBankLoanInterestRate = Math::Clamp(0, *edx, 80);
-            window_invalidate_by_class(WC_FINANCES);
-            break;
-        case EDIT_SCENARIOOPTIONS_SETFORBIDMARKETINGCAMPAIGNS:
-            if (*edx != 0)
-            {
-                gParkFlags |= PARK_FLAGS_FORBID_MARKETING_CAMPAIGN;
-            }
-            else
-            {
-                gParkFlags &= ~PARK_FLAGS_FORBID_MARKETING_CAMPAIGN;
-            }
-            break;
-        case EDIT_SCENARIOOPTIONS_SETAVERAGECASHPERGUEST:
-            gGuestInitialCash = Math::Clamp(MONEY(0, 00), *edx, MONEY(1000, 00));
-            break;
-        case EDIT_SCENARIOOPTIONS_SETGUESTINITIALHAPPINESS:
-            gGuestInitialHappiness = Math::Clamp(40, *edx, 250);
-            break;
-        case EDIT_SCENARIOOPTIONS_SETGUESTINITIALHUNGER:
-            gGuestInitialHunger = Math::Clamp(40, *edx, 250);
-            break;
-        case EDIT_SCENARIOOPTIONS_SETGUESTINITIALTHIRST:
-            gGuestInitialThirst = Math::Clamp(40, *edx, 250);
-            break;
-        case EDIT_SCENARIOOPTIONS_SETGUESTSPREFERLESSINTENSERIDES:
-            if (*edx != 0)
-            {
-                gParkFlags |= PARK_FLAGS_PREF_LESS_INTENSE_RIDES;
-            }
-            else
-            {
-                gParkFlags &= ~PARK_FLAGS_PREF_LESS_INTENSE_RIDES;
-            }
-            break;
-        case EDIT_SCENARIOOPTIONS_SETGUESTSPREFERMOREINTENSERIDES:
-            if (*edx != 0)
-            {
-                gParkFlags |= PARK_FLAGS_PREF_MORE_INTENSE_RIDES;
-            }
-            else
-            {
-                gParkFlags &= ~PARK_FLAGS_PREF_MORE_INTENSE_RIDES;
-            }
-            break;
-        case EDIT_SCENARIOOPTIONS_SETCOSTTOBUYLAND:
-            gLandPrice = Math::Clamp(MONEY(5, 00), *edx, MONEY(200, 00));
-            break;
-        case EDIT_SCENARIOOPTIONS_SETCOSTTOBUYCONSTRUCTIONRIGHTS:
-            gConstructionRightsPrice = Math::Clamp(MONEY(5, 00), *edx, MONEY(200, 00));
-            break;
-        case EDIT_SCENARIOOPTIONS_SETPARKCHARGEMETHOD:
-            if (gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR)
-            {
-                if (*edx == 0)
                 {
-                    gParkFlags |= PARK_FLAGS_PARK_FREE_ENTRY;
+                    gParkFlags |= PARK_FLAGS_FORBID_MARKETING_CAMPAIGN;
-                    gParkFlags &= ~PARK_FLAGS_UNLOCK_ALL_PRICES;
-                    gParkEntranceFee = MONEY(0, 00);
-                }
-                else if (*edx == 1)
-                {
-                    gParkFlags &= ~PARK_FLAGS_PARK_FREE_ENTRY;
-                    gParkFlags &= ~PARK_FLAGS_UNLOCK_ALL_PRICES;
-                    gParkEntranceFee = MONEY(10, 00);
                 }
                 else
                 {
-                    gParkFlags |= PARK_FLAGS_PARK_FREE_ENTRY;
+                    gParkFlags &= ~PARK_FLAGS_FORBID_MARKETING_CAMPAIGN;
-                    gParkFlags |= PARK_FLAGS_UNLOCK_ALL_PRICES;
-                    gParkEntranceFee = MONEY(10, 00);
                 }
-            }
+                break;
-            else
+            case EDIT_SCENARIOOPTIONS_SETAVERAGECASHPERGUEST:
-            {
+                gGuestInitialCash = Math::Clamp(MONEY(0, 00), *edx, MONEY(1000, 00));
-                if (*edx == 0)
+                break;
+            case EDIT_SCENARIOOPTIONS_SETGUESTINITIALHAPPINESS:
+                gGuestInitialHappiness = Math::Clamp(40, *edx, 250);
+                break;
+            case EDIT_SCENARIOOPTIONS_SETGUESTINITIALHUNGER:
+                gGuestInitialHunger = Math::Clamp(40, *edx, 250);
+                break;
+            case EDIT_SCENARIOOPTIONS_SETGUESTINITIALTHIRST:
+                gGuestInitialThirst = Math::Clamp(40, *edx, 250);
+                break;
+            case EDIT_SCENARIOOPTIONS_SETGUESTSPREFERLESSINTENSERIDES:
+                if (*edx != 0)
                 {
-                    gParkFlags |= PARK_FLAGS_PARK_FREE_ENTRY;
+                    gParkFlags |= PARK_FLAGS_PREF_LESS_INTENSE_RIDES;
-                    gParkFlags &= ~PARK_FLAGS_UNLOCK_ALL_PRICES;
-                }
-                else if (*edx == 1)
-                {
-                    gParkFlags &= ~PARK_FLAGS_PARK_FREE_ENTRY;
-                    gParkFlags &= ~PARK_FLAGS_UNLOCK_ALL_PRICES;
                 }
                 else
                 {
-                    gParkFlags |= PARK_FLAGS_PARK_FREE_ENTRY;
+                    gParkFlags &= ~PARK_FLAGS_PREF_LESS_INTENSE_RIDES;
-                    gParkFlags |= PARK_FLAGS_UNLOCK_ALL_PRICES;
                 }
+                break;
+            case EDIT_SCENARIOOPTIONS_SETGUESTSPREFERMOREINTENSERIDES:
+                if (*edx != 0)
+                {
+                    gParkFlags |= PARK_FLAGS_PREF_MORE_INTENSE_RIDES;
+                }
+                else
+                {
+                    gParkFlags &= ~PARK_FLAGS_PREF_MORE_INTENSE_RIDES;
+                }
+                break;
+            case EDIT_SCENARIOOPTIONS_SETCOSTTOBUYLAND:
+                gLandPrice = Math::Clamp(MONEY(5, 00), *edx, MONEY(200, 00));
+                break;
+            case EDIT_SCENARIOOPTIONS_SETCOSTTOBUYCONSTRUCTIONRIGHTS:
+                gConstructionRightsPrice = Math::Clamp(MONEY(5, 00), *edx, MONEY(200, 00));
+                break;
+            case EDIT_SCENARIOOPTIONS_SETPARKCHARGEMETHOD:
+                if (gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR)
+                {
+                    if (*edx == 0)
+                    {
+                        gParkFlags |= PARK_FLAGS_PARK_FREE_ENTRY;
+                        gParkFlags &= ~PARK_FLAGS_UNLOCK_ALL_PRICES;
+                        gParkEntranceFee = MONEY(0, 00);
+                    }
+                    else if (*edx == 1)
+                    {
+                        gParkFlags &= ~PARK_FLAGS_PARK_FREE_ENTRY;
+                        gParkFlags &= ~PARK_FLAGS_UNLOCK_ALL_PRICES;
+                        gParkEntranceFee = MONEY(10, 00);
+                    }
+                    else
+                    {
+                        gParkFlags |= PARK_FLAGS_PARK_FREE_ENTRY;
+                        gParkFlags |= PARK_FLAGS_UNLOCK_ALL_PRICES;
+                        gParkEntranceFee = MONEY(10, 00);
+                    }
+                }
+                else
+                {
+                    if (*edx == 0)
+                    {
+                        gParkFlags |= PARK_FLAGS_PARK_FREE_ENTRY;
+                        gParkFlags &= ~PARK_FLAGS_UNLOCK_ALL_PRICES;
+                    }
+                    else if (*edx == 1)
+                    {
+                        gParkFlags &= ~PARK_FLAGS_PARK_FREE_ENTRY;
+                        gParkFlags &= ~PARK_FLAGS_UNLOCK_ALL_PRICES;
+                    }
+                    else
+                    {
+                        gParkFlags |= PARK_FLAGS_PARK_FREE_ENTRY;
+                        gParkFlags |= PARK_FLAGS_UNLOCK_ALL_PRICES;
+                    }
+                    window_invalidate_by_class(WC_PARK_INFORMATION);
+                    window_invalidate_by_class(WC_RIDE);
+                }
+                break;
+            case EDIT_SCENARIOOPTIONS_SETPARKCHARGEENTRYFEE:
+                gParkEntranceFee = Math::Clamp(MONEY(0, 00), *edx, MAX_ENTRANCE_FEE);
                 window_invalidate_by_class(WC_PARK_INFORMATION);
-                window_invalidate_by_class(WC_RIDE);
+                break;
-            }
+            case EDIT_SCENARIOOPTIONS_SETFORBIDTREEREMOVAL:
-            break;
+                if (*edx != 0)
-        case EDIT_SCENARIOOPTIONS_SETPARKCHARGEENTRYFEE:
+                {
-            gParkEntranceFee = Math::Clamp(MONEY(0, 00), *edx, MAX_ENTRANCE_FEE);
+                    gParkFlags |= PARK_FLAGS_FORBID_TREE_REMOVAL;
-            window_invalidate_by_class(WC_PARK_INFORMATION);
+                }
-            break;
+                else
-        case EDIT_SCENARIOOPTIONS_SETFORBIDTREEREMOVAL:
+                {
-            if (*edx != 0)
+                    gParkFlags &= ~PARK_FLAGS_FORBID_TREE_REMOVAL;
-            {
+                }
-                gParkFlags |= PARK_FLAGS_FORBID_TREE_REMOVAL;
+                break;
-            }
+            case EDIT_SCENARIOOPTIONS_SETFORBIDLANDSCAPECHANGES:
-            else
+                if (*edx != 0)
-            {
+                {
-                gParkFlags &= ~PARK_FLAGS_FORBID_TREE_REMOVAL;
+                    gParkFlags |= PARK_FLAGS_FORBID_LANDSCAPE_CHANGES;
-            }
+                }
-            break;
+                else
-        case EDIT_SCENARIOOPTIONS_SETFORBIDLANDSCAPECHANGES:
+                {
-            if (*edx != 0)
+                    gParkFlags &= ~PARK_FLAGS_FORBID_LANDSCAPE_CHANGES;
-            {
+                }
-                gParkFlags |= PARK_FLAGS_FORBID_LANDSCAPE_CHANGES;
+                break;
-            }
+            case EDIT_SCENARIOOPTIONS_SETFORBIDHIGHCONSTRUCTION:
-            else
+                if (*edx != 0)
-            {
+                {
-                gParkFlags &= ~PARK_FLAGS_FORBID_LANDSCAPE_CHANGES;
+                    gParkFlags |= PARK_FLAGS_FORBID_HIGH_CONSTRUCTION;
-            }
+                }
-            break;
+                else
-        case EDIT_SCENARIOOPTIONS_SETFORBIDHIGHCONSTRUCTION:
+                {
-            if (*edx != 0)
+                    gParkFlags &= ~PARK_FLAGS_FORBID_HIGH_CONSTRUCTION;
-            {
+                }
-                gParkFlags |= PARK_FLAGS_FORBID_HIGH_CONSTRUCTION;
+                break;
-            }
+            case EDIT_SCENARIOOPTIONS_SETPARKRATINGHIGHERDIFFICULTLEVEL:
-            else
+                if (*edx != 0)
-            {
+                {
-                gParkFlags &= ~PARK_FLAGS_FORBID_HIGH_CONSTRUCTION;
+                    gParkFlags |= PARK_FLAGS_DIFFICULT_PARK_RATING;
-            }
+                }
-            break;
+                else
-        case EDIT_SCENARIOOPTIONS_SETPARKRATINGHIGHERDIFFICULTLEVEL:
+                {
-            if (*edx != 0)
+                    gParkFlags &= ~PARK_FLAGS_DIFFICULT_PARK_RATING;
-            {
+                }
-                gParkFlags |= PARK_FLAGS_DIFFICULT_PARK_RATING;
+                break;
-            }
+            case EDIT_SCENARIOOPTIONS_SETGUESTGENERATIONHIGHERDIFFICULTLEVEL:
-            else
+                if (*edx != 0)
-            {
+                {
-                gParkFlags &= ~PARK_FLAGS_DIFFICULT_PARK_RATING;
+                    gParkFlags |= PARK_FLAGS_DIFFICULT_GUEST_GENERATION;
-            }
+                }
-            break;
+                else
-        case EDIT_SCENARIOOPTIONS_SETGUESTGENERATIONHIGHERDIFFICULTLEVEL:
+                {
-            if (*edx != 0)
+                    gParkFlags &= ~PARK_FLAGS_DIFFICULT_GUEST_GENERATION;
-            {
+                }
-                gParkFlags |= PARK_FLAGS_DIFFICULT_GUEST_GENERATION;
+                break;
-            }
-            else
-            {
-                gParkFlags &= ~PARK_FLAGS_DIFFICULT_GUEST_GENERATION;
-            }
-            break;
         }
         window_invalidate_by_class(WC_EDITOR_SCENARIO_OPTIONS);
         *ebx = 0;
@@ -760,7 +753,7 @@ namespace Editor
     uint8_t GetSelectedObjectFlags(int32_t objectType, size_t index)
     {
         uint8_t result = 0;
-        auto &list = _editorSelectedObjectFlags[objectType];
+        auto& list = _editorSelectedObjectFlags[objectType];
         if (list.size() > index)
         {
             result = list[index];
@@ -770,7 +763,7 @@ namespace Editor
 
     void ClearSelectedObject(int32_t objectType, size_t index, uint32_t flags)
     {
-        auto &list = _editorSelectedObjectFlags[objectType];
+        auto& list = _editorSelectedObjectFlags[objectType];
         if (list.size() <= index)
         {
             list.resize(index + 1);
@@ -780,22 +773,22 @@ namespace Editor
 
     void SetSelectedObject(int32_t objectType, size_t index, uint32_t flags)
     {
-        auto &list = _editorSelectedObjectFlags[objectType];
+        auto& list = _editorSelectedObjectFlags[objectType];
         if (list.size() <= index)
         {
             list.resize(index + 1);
         }
         list[index] |= flags;
     }
-}
+} // namespace Editor
 
 void editor_open_windows_for_current_step()
 {
     Editor::OpenWindowsForCurrentStep();
 }
 
-void game_command_edit_scenario_options(int32_t * eax, int32_t * ebx, int32_t * ecx, int32_t * edx, int32_t * esi, int32_t * edi, int32_t * ebp)
+void game_command_edit_scenario_options(
+    int32_t* eax, int32_t* ebx, int32_t* ecx, int32_t* edx, int32_t* esi, int32_t* edi, int32_t* ebp)
 {
     Editor::GameCommandEditScenarioOptions(eax, ebx, ecx, edx, esi, edi, ebp);
 }
-

src/openrct2/Editor.h

@@ -18,7 +18,7 @@ namespace Editor
     void ConvertSaveToScenario();
     void LoadTrackDesigner();
     void LoadTrackManager();
-    bool LoadLandscape(const utf8 *path);
+    bool LoadLandscape(const utf8* path);
 
     bool CheckPark();
     int32_t CheckObjectSelection();
@@ -33,14 +33,14 @@ namespace Editor
 
 enum RCT2_EDITOR_STEP
 {
-    EDITOR_STEP_OBJECT_SELECTION,           // 0
+    EDITOR_STEP_OBJECT_SELECTION,       // 0
-    EDITOR_STEP_LANDSCAPE_EDITOR,           // 1
+    EDITOR_STEP_LANDSCAPE_EDITOR,       // 1
-    EDITOR_STEP_INVENTIONS_LIST_SET_UP,     // 2
+    EDITOR_STEP_INVENTIONS_LIST_SET_UP, // 2
-    EDITOR_STEP_OPTIONS_SELECTION,          // 3
+    EDITOR_STEP_OPTIONS_SELECTION,      // 3
-    EDITOR_STEP_OBJECTIVE_SELECTION,        // 4
+    EDITOR_STEP_OBJECTIVE_SELECTION,    // 4
-    EDITOR_STEP_SAVE_SCENARIO,              // 5
+    EDITOR_STEP_SAVE_SCENARIO,          // 5
-    EDITOR_STEP_ROLLERCOASTER_DESIGNER,     // 6
+    EDITOR_STEP_ROLLERCOASTER_DESIGNER, // 6
-    EDITOR_STEP_TRACK_DESIGNS_MANAGER       // 7
+    EDITOR_STEP_TRACK_DESIGNS_MANAGER   // 7
 };
 
 enum
@@ -70,6 +70,7 @@ enum
 
 void editor_open_windows_for_current_step();
 
-void game_command_edit_scenario_options(int32_t* eax, int32_t* ebx, int32_t* ecx, int32_t* edx, int32_t* esi, int32_t* edi, int32_t* ebp);
+void game_command_edit_scenario_options(
+    int32_t* eax, int32_t* ebx, int32_t* ecx, int32_t* edx, int32_t* esi, int32_t* edi, int32_t* ebp);
 
 #endif

src/openrct2/EditorObjectSelectionSession.cpp

@@ -7,24 +7,25 @@
  * OpenRCT2 is licensed under the GNU General Public License version 3.
  *****************************************************************************/
 
-#include <vector>
-#include "Context.h"
-#include "core/Util.hpp"
-#include "Editor.h"
 #include "EditorObjectSelectionSession.h"
+
+#include "Context.h"
+#include "Editor.h"
 #include "Game.h"
+#include "OpenRCT2.h"
+#include "core/Util.hpp"
 #include "localisation/Localisation.h"
 #include "management/Research.h"
 #include "object/DefaultObjects.h"
 #include "object/ObjectList.h"
 #include "object/ObjectManager.h"
 #include "object/ObjectRepository.h"
-#include "OpenRCT2.h"
 #include "ride/RideData.h"
 #include "windows/Intent.h"
 #include "world/Footpath.h"
 #include "world/LargeScenery.h"
 
+#include <vector>
 
 bool _maxObjectsWasHit;
 std::vector<uint8_t> _objectSelectionFlags;
@@ -44,11 +45,11 @@ static void window_editor_object_selection_select_default_objects();
 static void setup_track_manager_objects()
 {
     int32_t numObjects = (int32_t)object_repository_get_items_count();
-    const ObjectRepositoryItem * items = object_repository_get_items();
+    const ObjectRepositoryItem* items = object_repository_get_items();
     for (int32_t i = 0; i < numObjects; i++)
     {
-        uint8_t * selectionFlags = &_objectSelectionFlags[i];
+        uint8_t* selectionFlags = &_objectSelectionFlags[i];
-        const ObjectRepositoryItem * item = &items[i];
+        const ObjectRepositoryItem* item = &items[i];
         uint8_t object_type = object_entry_get_type(&item->ObjectEntry);
         if (object_type == OBJECT_TYPE_RIDE)
         {
@@ -73,11 +74,11 @@ static void setup_track_manager_objects()
 static void setup_track_designer_objects()
 {
     int32_t numObjects = (int32_t)object_repository_get_items_count();
-    const ObjectRepositoryItem * items = object_repository_get_items();
+    const ObjectRepositoryItem* items = object_repository_get_items();
     for (int32_t i = 0; i < numObjects; i++)
     {
-        uint8_t * selectionFlags = &_objectSelectionFlags[i];
+        uint8_t* selectionFlags = &_objectSelectionFlags[i];
-        const ObjectRepositoryItem * item = &items[i];
+        const ObjectRepositoryItem* item = &items[i];
         uint8_t objectType = object_entry_get_type(&item->ObjectEntry);
         if (objectType == OBJECT_TYPE_RIDE)
         {
@@ -118,86 +119,91 @@ void setup_in_use_selection_flags()
 
     tile_element_iterator iter;
     tile_element_iterator_begin(&iter);
-    do {
+    do
+    {
         uint16_t type;
         rct_banner* banner;
 
-        switch (iter.element->GetType()) {
+        switch (iter.element->GetType())
-        default:
+        {
-        case TILE_ELEMENT_TYPE_SURFACE:
+            default:
-        case TILE_ELEMENT_TYPE_TRACK:
+            case TILE_ELEMENT_TYPE_SURFACE:
-            break;
+            case TILE_ELEMENT_TYPE_TRACK:
-        case TILE_ELEMENT_TYPE_PATH:
-            type = iter.element->properties.path.type;
-            type >>= 4;
-            assert(type < object_entry_group_counts[OBJECT_TYPE_PATHS]);
-            Editor::SetSelectedObject(OBJECT_TYPE_PATHS, type, OBJECT_SELECTION_FLAG_SELECTED);
-
-            if (footpath_element_has_path_scenery(iter.element)) {
-                uint8_t path_additions = footpath_element_get_path_scenery_index(iter.element);
-                Editor::SetSelectedObject(OBJECT_TYPE_PATH_BITS, path_additions, OBJECT_SELECTION_FLAG_SELECTED);
-            }
-            break;
-        case TILE_ELEMENT_TYPE_SMALL_SCENERY:
-            type = iter.element->properties.scenery.type;
-            assert(type < object_entry_group_counts[OBJECT_TYPE_SMALL_SCENERY]);
-            Editor::SetSelectedObject(OBJECT_TYPE_SMALL_SCENERY, type, OBJECT_SELECTION_FLAG_SELECTED);
-            break;
-        case TILE_ELEMENT_TYPE_ENTRANCE:
-            if (iter.element->properties.entrance.type != ENTRANCE_TYPE_PARK_ENTRANCE)
                 break;
-            // Skip if not the middle part
+            case TILE_ELEMENT_TYPE_PATH:
-            if (iter.element->properties.entrance.index != 0)
+                type = iter.element->properties.path.type;
+                type >>= 4;
+                assert(type < object_entry_group_counts[OBJECT_TYPE_PATHS]);
+                Editor::SetSelectedObject(OBJECT_TYPE_PATHS, type, OBJECT_SELECTION_FLAG_SELECTED);
+
+                if (footpath_element_has_path_scenery(iter.element))
+                {
+                    uint8_t path_additions = footpath_element_get_path_scenery_index(iter.element);
+                    Editor::SetSelectedObject(OBJECT_TYPE_PATH_BITS, path_additions, OBJECT_SELECTION_FLAG_SELECTED);
+                }
                 break;
+            case TILE_ELEMENT_TYPE_SMALL_SCENERY:
+                type = iter.element->properties.scenery.type;
+                assert(type < object_entry_group_counts[OBJECT_TYPE_SMALL_SCENERY]);
+                Editor::SetSelectedObject(OBJECT_TYPE_SMALL_SCENERY, type, OBJECT_SELECTION_FLAG_SELECTED);
+                break;
+            case TILE_ELEMENT_TYPE_ENTRANCE:
+                if (iter.element->properties.entrance.type != ENTRANCE_TYPE_PARK_ENTRANCE)
+                    break;
+                // Skip if not the middle part
+                if (iter.element->properties.entrance.index != 0)
+                    break;
 
-            Editor::SetSelectedObject(OBJECT_TYPE_PARK_ENTRANCE, 0, OBJECT_SELECTION_FLAG_SELECTED);
+                Editor::SetSelectedObject(OBJECT_TYPE_PARK_ENTRANCE, 0, OBJECT_SELECTION_FLAG_SELECTED);
 
-            type = iter.element->properties.entrance.path_type;
+                type = iter.element->properties.entrance.path_type;
-            assert(type < object_entry_group_counts[OBJECT_TYPE_PATHS]);
+                assert(type < object_entry_group_counts[OBJECT_TYPE_PATHS]);
-            Editor::SetSelectedObject(OBJECT_TYPE_PATHS, type, OBJECT_SELECTION_FLAG_SELECTED);
+                Editor::SetSelectedObject(OBJECT_TYPE_PATHS, type, OBJECT_SELECTION_FLAG_SELECTED);
-            break;
+                break;
-        case TILE_ELEMENT_TYPE_WALL:
+            case TILE_ELEMENT_TYPE_WALL:
-            type = iter.element->properties.wall.type;
+                type = iter.element->properties.wall.type;
-            assert(type < object_entry_group_counts[OBJECT_TYPE_WALLS]);
+                assert(type < object_entry_group_counts[OBJECT_TYPE_WALLS]);
-            Editor::SetSelectedObject(OBJECT_TYPE_WALLS, type, OBJECT_SELECTION_FLAG_SELECTED);
+                Editor::SetSelectedObject(OBJECT_TYPE_WALLS, type, OBJECT_SELECTION_FLAG_SELECTED);
-            break;
+                break;
-        case TILE_ELEMENT_TYPE_LARGE_SCENERY:
+            case TILE_ELEMENT_TYPE_LARGE_SCENERY:
-            type = scenery_large_get_type(iter.element);
+                type = scenery_large_get_type(iter.element);
-            assert(type < object_entry_group_counts[OBJECT_TYPE_LARGE_SCENERY]);
+                assert(type < object_entry_group_counts[OBJECT_TYPE_LARGE_SCENERY]);
-            Editor::SetSelectedObject(OBJECT_TYPE_LARGE_SCENERY, type, OBJECT_SELECTION_FLAG_SELECTED);
+                Editor::SetSelectedObject(OBJECT_TYPE_LARGE_SCENERY, type, OBJECT_SELECTION_FLAG_SELECTED);
-            break;
+                break;
-        case TILE_ELEMENT_TYPE_BANNER:
+            case TILE_ELEMENT_TYPE_BANNER:
-            banner = &gBanners[iter.element->properties.banner.index];
+                banner = &gBanners[iter.element->properties.banner.index];
-            type = banner->type;
+                type = banner->type;
-            assert(type < object_entry_group_counts[OBJECT_TYPE_BANNERS]);
+                assert(type < object_entry_group_counts[OBJECT_TYPE_BANNERS]);
-            Editor::SetSelectedObject(OBJECT_TYPE_BANNERS, type, OBJECT_SELECTION_FLAG_SELECTED);
+                Editor::SetSelectedObject(OBJECT_TYPE_BANNERS, type, OBJECT_SELECTION_FLAG_SELECTED);
-            break;
+                break;
         }
     } while (tile_element_iterator_next(&iter));
 
-    for (uint8_t ride_index = 0; ride_index < 0xFF; ride_index++) {
+    for (uint8_t ride_index = 0; ride_index < 0xFF; ride_index++)
+    {
         Ride* ride = get_ride(ride_index);
-        if (ride->type != RIDE_TYPE_NULL) {
+        if (ride->type != RIDE_TYPE_NULL)
+        {
             uint8_t type = ride->subtype;
             Editor::SetSelectedObject(OBJECT_TYPE_RIDE, type, OBJECT_SELECTION_FLAG_SELECTED);
         }
     }
 
     int32_t numObjects = (int32_t)object_repository_get_items_count();
-    const ObjectRepositoryItem * items = object_repository_get_items();
+    const ObjectRepositoryItem* items = object_repository_get_items();
-    for (int32_t i = 0; i < numObjects; i++) {
+    for (int32_t i = 0; i < numObjects; i++)
-        uint8_t *selectionFlags = &_objectSelectionFlags[i];
+    {
-        const ObjectRepositoryItem * item = &items[i];
+        uint8_t* selectionFlags = &_objectSelectionFlags[i];
+        const ObjectRepositoryItem* item = &items[i];
         *selectionFlags &= ~OBJECT_SELECTION_FLAG_IN_USE;
 
         uint8_t entryType, entryIndex;
-        if (find_object_in_entry_group(&item->ObjectEntry, &entryType, &entryIndex)) {
+        if (find_object_in_entry_group(&item->ObjectEntry, &entryType, &entryIndex))
+        {
             auto flags = Editor::GetSelectedObjectFlags(entryType, entryIndex);
             if (flags & OBJECT_SELECTION_FLAG_SELECTED)
             {
-                *selectionFlags |=
+                *selectionFlags |= OBJECT_SELECTION_FLAG_IN_USE | OBJECT_SELECTION_FLAG_SELECTED;
-                    OBJECT_SELECTION_FLAG_IN_USE |
-                    OBJECT_SELECTION_FLAG_SELECTED;
             }
             if (flags & OBJECT_SELECTION_FLAG_2)
             {
@@ -216,33 +222,39 @@ void sub_6AB211()
     int32_t numObjects = (int32_t)object_repository_get_items_count();
     _objectSelectionFlags = std::vector<uint8_t>(numObjects);
 
-    for (uint8_t objectType = 0; objectType < OBJECT_TYPE_COUNT; objectType++) {
+    for (uint8_t objectType = 0; objectType < OBJECT_TYPE_COUNT; objectType++)
+    {
         _numSelectedObjectsForType[objectType] = 0;
         _numAvailableObjectsForType[objectType] = 0;
     }
 
-    const ObjectRepositoryItem * items = object_repository_get_items();
+    const ObjectRepositoryItem* items = object_repository_get_items();
-    for (int32_t i = 0; i < numObjects; i++) {
+    for (int32_t i = 0; i < numObjects; i++)
+    {
         uint8_t objectType = object_entry_get_type(&items[i].ObjectEntry);
         _numAvailableObjectsForType[objectType]++;
     }
 
-    if (gScreenFlags & SCREEN_FLAGS_TRACK_DESIGNER) {
+    if (gScreenFlags & SCREEN_FLAGS_TRACK_DESIGNER)
+    {
         setup_track_designer_objects();
     }
 
-    if (gScreenFlags & SCREEN_FLAGS_TRACK_MANAGER) {
+    if (gScreenFlags & SCREEN_FLAGS_TRACK_MANAGER)
+    {
         setup_track_manager_objects();
     }
 
     setup_in_use_selection_flags();
     reset_selected_object_count_and_size();
 
-    if (!(gScreenFlags & (SCREEN_FLAGS_TRACK_DESIGNER | SCREEN_FLAGS_TRACK_MANAGER))) {
+    if (!(gScreenFlags & (SCREEN_FLAGS_TRACK_DESIGNER | SCREEN_FLAGS_TRACK_MANAGER)))
+    {
         window_editor_object_selection_select_required_objects();
 
         // To prevent it breaking in scenario mode.
-        if (gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) {
+        if (gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR)
+        {
             window_editor_object_selection_select_default_objects();
         }
     }
@@ -273,7 +285,7 @@ static void remove_selected_objects_from_research(const rct_object_entry* instal
     if (entry_type == OBJECT_TYPE_RIDE)
     {
         auto rideEntry = get_ride_entry(entry_index);
-        
+
         for (auto rideType : rideEntry->ride_type)
         {
             rct_research_item tmp = {};
@@ -299,14 +311,16 @@ static void remove_selected_objects_from_research(const rct_object_entry* instal
 void unload_unselected_objects()
 {
     int32_t numItems = (int32_t)object_repository_get_items_count();
-    const ObjectRepositoryItem * items = object_repository_get_items();
+    const ObjectRepositoryItem* items = object_repository_get_items();
 
     size_t numObjectsToUnload = 0;
-    rct_object_entry * objectsToUnload = (rct_object_entry *)malloc(numItems * sizeof(rct_object_entry));
+    rct_object_entry* objectsToUnload = (rct_object_entry*)malloc(numItems * sizeof(rct_object_entry));
 
-    for (int32_t i = 0; i < numItems; i++) {
+    for (int32_t i = 0; i < numItems; i++)
-        if (!(_objectSelectionFlags[i] & OBJECT_SELECTION_FLAG_SELECTED)) {
+    {
-            const rct_object_entry * entry = &items[i].ObjectEntry;
+        if (!(_objectSelectionFlags[i] & OBJECT_SELECTION_FLAG_SELECTED))
+        {
+            const rct_object_entry* entry = &items[i].ObjectEntry;
 
             remove_selected_objects_from_research(entry);
             objectsToUnload[numObjectsToUnload++] = *entry;
@@ -318,14 +332,14 @@ void unload_unselected_objects()
 }
 
 /**
-*
+ *
-*  rct2: 0x006AA805
+ *  rct2: 0x006AA805
-*/
+ */
 static void window_editor_object_selection_select_default_objects()
 {
     if (_numSelectedObjectsForType[0] == 0)
     {
-        for (const auto &defaultSelectedObject : DefaultSelectedObjects)
+        for (const auto& defaultSelectedObject : DefaultSelectedObjects)
         {
             window_editor_object_selection_select_object(0, 7, &defaultSelectedObject);
         }
@@ -350,16 +364,18 @@ static void window_editor_object_selection_select_required_objects()
  */
 void reset_selected_object_count_and_size()
 {
-    for (auto &objectType : _numSelectedObjectsForType)
+    for (auto& objectType : _numSelectedObjectsForType)
     {
         objectType = 0;
     }
 
     int32_t numObjects = (int32_t)object_repository_get_items_count();
-    const ObjectRepositoryItem * items = object_repository_get_items();
+    const ObjectRepositoryItem* items = object_repository_get_items();
-    for (int32_t i = 0; i < numObjects; i++) {
+    for (int32_t i = 0; i < numObjects; i++)
+    {
         uint8_t objectType = object_entry_get_type(&items[i].ObjectEntry);
-        if (_objectSelectionFlags[i] & OBJECT_SELECTION_FLAG_SELECTED) {
+        if (_objectSelectionFlags[i] & OBJECT_SELECTION_FLAG_SELECTED)
+        {
             _numSelectedObjectsForType[objectType]++;
         }
     }
@@ -370,9 +386,11 @@ void reset_selected_object_count_and_size()
  * optional / required dependants of an
  * object.
  */
-static void set_object_selection_error(uint8_t is_master_object, rct_string_id error_msg){
+static void set_object_selection_error(uint8_t is_master_object, rct_string_id error_msg)
+{
     gGameCommandErrorText = error_msg;
-    if (!is_master_object){
+    if (!is_master_object)
+    {
         reset_selected_object_count_and_size();
     }
 }
@@ -381,40 +399,48 @@ static void set_object_selection_error(uint8_t is_master_object, rct_string_id e
  *
  *  rct2: 0x006AB54F
  */
-int32_t window_editor_object_selection_select_object(uint8_t bh, int32_t flags, const rct_object_entry *entry)
+int32_t window_editor_object_selection_select_object(uint8_t bh, int32_t flags, const rct_object_entry* entry)
 {
     int32_t numObjects = (int32_t)object_repository_get_items_count();
-    const ObjectRepositoryItem * item = object_repository_find_object_by_entry(entry);
+    const ObjectRepositoryItem* item = object_repository_find_object_by_entry(entry);
-    if (item == nullptr) {
+    if (item == nullptr)
+    {
         set_object_selection_error(bh, STR_OBJECT_SELECTION_ERR_OBJECT_DATA_NOT_FOUND);
         return 0;
     }
 
     // Get repository item index
     int32_t index = -1;
-    const ObjectRepositoryItem * items = object_repository_get_items();
+    const ObjectRepositoryItem* items = object_repository_get_items();
-    for (int32_t i = 0; i < numObjects; i++) {
+    for (int32_t i = 0; i < numObjects; i++)
-        if (&items[i] == item) {
+    {
+        if (&items[i] == item)
+        {
             index = i;
         }
     }
 
-    uint8_t * selectionFlags = &_objectSelectionFlags[index];
+    uint8_t* selectionFlags = &_objectSelectionFlags[index];
-    if (!(flags & 1)) {
+    if (!(flags & 1))
-        if (!(*selectionFlags & OBJECT_SELECTION_FLAG_SELECTED)) {
+    {
+        if (!(*selectionFlags & OBJECT_SELECTION_FLAG_SELECTED))
+        {
             return 1;
         }
-        else if (*selectionFlags & OBJECT_SELECTION_FLAG_IN_USE) {
+        else if (*selectionFlags & OBJECT_SELECTION_FLAG_IN_USE)
+        {
             set_object_selection_error(bh, STR_OBJECT_SELECTION_ERR_CURRENTLY_IN_USE);
             return 0;
         }
-        else if (*selectionFlags & OBJECT_SELECTION_FLAG_ALWAYS_REQUIRED) {
+        else if (*selectionFlags & OBJECT_SELECTION_FLAG_ALWAYS_REQUIRED)
+        {
             set_object_selection_error(bh, STR_OBJECT_SELECTION_ERR_ALWAYS_REQUIRED);
             return 0;
         }
 
         uint8_t objectType = object_entry_get_type(&item->ObjectEntry);
-        if (objectType == OBJECT_TYPE_SCENERY_GROUP && (flags & (1 << 2))) {
+        if (objectType == OBJECT_TYPE_SCENERY_GROUP && (flags & (1 << 2)))
+        {
             for (const auto& sgEntry : item->SceneryGroupInfo.Entries)
             {
                 window_editor_object_selection_select_object(++bh, flags, &sgEntry);
@@ -424,28 +450,36 @@ int32_t window_editor_object_selection_select_object(uint8_t bh, int32_t flags,
         _numSelectedObjectsForType[objectType]--;
         *selectionFlags &= ~OBJECT_SELECTION_FLAG_SELECTED;
         return 1;
-    } else {
+    }
-        if (bh == 0) {
+    else
-            if (flags & (1 << 3)) {
+    {
+        if (bh == 0)
+        {
+            if (flags & (1 << 3))
+            {
                 *selectionFlags |= OBJECT_SELECTION_FLAG_ALWAYS_REQUIRED;
             }
         }
-        if (*selectionFlags & OBJECT_SELECTION_FLAG_SELECTED) {
+        if (*selectionFlags & OBJECT_SELECTION_FLAG_SELECTED)
+        {
             return 1;
         }
 
         uint8_t objectType = object_entry_get_type(&item->ObjectEntry);
         uint16_t maxObjects = object_entry_group_counts[objectType];
-        if (gScreenFlags & SCREEN_FLAGS_TRACK_DESIGNER) {
+        if (gScreenFlags & SCREEN_FLAGS_TRACK_DESIGNER)
+        {
             maxObjects = 4;
         }
 
-        if (maxObjects <= _numSelectedObjectsForType[objectType]) {
+        if (maxObjects <= _numSelectedObjectsForType[objectType])
+        {
             set_object_selection_error(bh, STR_OBJECT_SELECTION_ERR_TOO_MANY_OF_TYPE_SELECTED);
             return 0;
         }
 
-        if (objectType == OBJECT_TYPE_SCENERY_GROUP && (flags & (1 << 2))) {
+        if (objectType == OBJECT_TYPE_SCENERY_GROUP && (flags & (1 << 2)))
+        {
             for (const auto& sgEntry : item->SceneryGroupInfo.Entries)
             {
                 if (!window_editor_object_selection_select_object(++bh, flags, &sgEntry))
@@ -455,15 +489,17 @@ int32_t window_editor_object_selection_select_object(uint8_t bh, int32_t flags,
             }
         }
 
-        if (bh != 0 && !(flags & (1 << 1))) {
+        if (bh != 0 && !(flags & (1 << 1)))
+        {
             char objectName[64];
             object_create_identifier_name(objectName, 64, &item->ObjectEntry);
-            set_format_arg(0, const char *, objectName);
+            set_format_arg(0, const char*, objectName);
             set_object_selection_error(bh, STR_OBJECT_SELECTION_ERR_SHOULD_SELECT_X_FIRST);
             return 0;
         }
 
-        if (maxObjects <= _numSelectedObjectsForType[objectType]) {
+        if (maxObjects <= _numSelectedObjectsForType[objectType])
+        {
             set_object_selection_error(bh, STR_OBJECT_SELECTION_ERR_TOO_MANY_OF_TYPE_SELECTED);
             return 0;
         }
@@ -478,11 +514,13 @@ int32_t window_editor_object_selection_select_object(uint8_t bh, int32_t flags,
 bool editor_check_object_group_at_least_one_selected(int32_t checkObjectType)
 {
     int32_t numObjects = (int32_t)object_repository_get_items_count();
-    const ObjectRepositoryItem * items = object_repository_get_items();
+    const ObjectRepositoryItem* items = object_repository_get_items();
 
-    for (int32_t i = 0; i < numObjects; i++) {
+    for (int32_t i = 0; i < numObjects; i++)
+    {
         uint8_t objectType = object_entry_get_type(&items[i].ObjectEntry);
-        if (checkObjectType == objectType && (_objectSelectionFlags[i] & OBJECT_SELECTION_FLAG_SELECTED)) {
+        if (checkObjectType == objectType && (_objectSelectionFlags[i] & OBJECT_SELECTION_FLAG_SELECTED))
+        {
             return true;
         }
     }
@@ -495,17 +533,19 @@ int32_t editor_remove_unused_objects()
     setup_in_use_selection_flags();
 
     int32_t numObjects = (int32_t)object_repository_get_items_count();
-    const ObjectRepositoryItem * items = object_repository_get_items();
+    const ObjectRepositoryItem* items = object_repository_get_items();
 
     int32_t numUnselectedObjects = 0;
     for (int32_t i = 0; i < numObjects; i++)
     {
-        if (!(_objectSelectionFlags[i] & OBJECT_SELECTION_FLAG_IN_USE) && !(_objectSelectionFlags[i] & OBJECT_SELECTION_FLAG_ALWAYS_REQUIRED))
+        if (!(_objectSelectionFlags[i] & OBJECT_SELECTION_FLAG_IN_USE)
+            && !(_objectSelectionFlags[i] & OBJECT_SELECTION_FLAG_ALWAYS_REQUIRED))
         {
-            const ObjectRepositoryItem * item = &items[i];
+            const ObjectRepositoryItem* item = &items[i];
             uint8_t objectType = object_entry_get_type(&item->ObjectEntry);
 
-            if (objectType == OBJECT_TYPE_PARK_ENTRANCE || objectType == OBJECT_TYPE_SCENARIO_TEXT || objectType == OBJECT_TYPE_WATER || objectType == OBJECT_TYPE_SCENERY_GROUP)
+            if (objectType == OBJECT_TYPE_PARK_ENTRANCE || objectType == OBJECT_TYPE_SCENARIO_TEXT
+                || objectType == OBJECT_TYPE_WATER || objectType == OBJECT_TYPE_SCENERY_GROUP)
             {
                 continue;
             }

src/openrct2/EditorObjectSelectionSession.h

@@ -9,10 +9,11 @@
 
 #pragma once
 
-#include <vector>
 #include "common.h"
 #include "object/Object.h"
 
+#include <vector>
+
 extern bool _maxObjectsWasHit;
 extern std::vector<uint8_t> _objectSelectionFlags;
 extern int32_t _numSelectedObjectsForType[OBJECT_TYPE_COUNT];
@@ -22,11 +23,10 @@ void editor_object_flags_free();
 void unload_unselected_objects();
 void sub_6AB211();
 void reset_selected_object_count_and_size();
-int32_t window_editor_object_selection_select_object(uint8_t bh, int32_t flags, const rct_object_entry *entry);
+int32_t window_editor_object_selection_select_object(uint8_t bh, int32_t flags, const rct_object_entry* entry);
 
 /**
-* Removes all unused objects from the object selection.
+ * Removes all unused objects from the object selection.
-* @return The number of removed objects.
+ * @return The number of removed objects.
-*/
+ */
 int32_t editor_remove_unused_objects();
-

src/openrct2/FileClassifier.cpp

@@ -7,33 +7,33 @@
  * OpenRCT2 is licensed under the GNU General Public License version 3.
  *****************************************************************************/
 
+#include "FileClassifier.h"
+
 #include "core/Console.hpp"
 #include "core/FileStream.hpp"
 #include "core/Path.hpp"
-#include "FileClassifier.h"
 #include "rct12/SawyerChunkReader.h"
-
 #include "scenario/Scenario.h"
 #include "util/SawyerCoding.h"
 
-static bool TryClassifyAsS6(IStream * stream, ClassifiedFileInfo * result);
+static bool TryClassifyAsS6(IStream* stream, ClassifiedFileInfo* result);
-static bool TryClassifyAsS4(IStream * stream, ClassifiedFileInfo * result);
+static bool TryClassifyAsS4(IStream* stream, ClassifiedFileInfo* result);
-static bool TryClassifyAsTD4_TD6(IStream * stream, ClassifiedFileInfo * result);
+static bool TryClassifyAsTD4_TD6(IStream* stream, ClassifiedFileInfo* result);
 
-bool TryClassifyFile(const std::string &path, ClassifiedFileInfo * result)
+bool TryClassifyFile(const std::string& path, ClassifiedFileInfo* result)
 {
     try
     {
         auto fs = FileStream(path, FILE_MODE_OPEN);
         return TryClassifyFile(&fs, result);
     }
-    catch (const std::exception &)
+    catch (const std::exception&)
     {
         return false;
     }
 }
 
-bool TryClassifyFile(IStream * stream, ClassifiedFileInfo * result)
+bool TryClassifyFile(IStream* stream, ClassifiedFileInfo* result)
 {
     // TODO Currently track designs get classified as SC4s because they use the
     //      same checksum algorithm. The only way after to tell the difference
@@ -61,7 +61,7 @@ bool TryClassifyFile(IStream * stream, ClassifiedFileInfo * result)
     return false;
 }
 
-static bool TryClassifyAsS6(IStream * stream, ClassifiedFileInfo * result)
+static bool TryClassifyAsS6(IStream* stream, ClassifiedFileInfo* result)
 {
     bool success = false;
     uint64_t originalPosition = stream->GetPosition();
@@ -80,7 +80,7 @@ static bool TryClassifyAsS6(IStream * stream, ClassifiedFileInfo * result)
         result->Version = s6Header.version;
         success = true;
     }
-    catch (const std::exception &e)
+    catch (const std::exception& e)
     {
         // Exceptions are likely to occur if file is not S6 format
         log_verbose(e.what());
@@ -89,14 +89,14 @@ static bool TryClassifyAsS6(IStream * stream, ClassifiedFileInfo * result)
     return success;
 }
 
-static bool TryClassifyAsS4(IStream * stream, ClassifiedFileInfo * result)
+static bool TryClassifyAsS4(IStream* stream, ClassifiedFileInfo* result)
 {
     bool success = false;
     uint64_t originalPosition = stream->GetPosition();
     try
     {
         size_t dataLength = (size_t)stream->GetLength();
-        auto deleter_lambda = [dataLength](uint8_t * ptr) { Memory::FreeArray(ptr, dataLength); };
+        auto deleter_lambda = [dataLength](uint8_t* ptr) { Memory::FreeArray(ptr, dataLength); };
         std::unique_ptr<uint8_t, decltype(deleter_lambda)> data(stream->ReadArray<uint8_t>(dataLength), deleter_lambda);
         stream->SetPosition(originalPosition);
         int32_t fileTypeVersion = sawyercoding_detect_file_type(data.get(), dataLength);
@@ -117,7 +117,7 @@ static bool TryClassifyAsS4(IStream * stream, ClassifiedFileInfo * result)
             success = true;
         }
     }
-    catch (const std::exception &e)
+    catch (const std::exception& e)
     {
         Console::Error::WriteLine(e.what());
     }
@@ -126,20 +126,21 @@ static bool TryClassifyAsS4(IStream * stream, ClassifiedFileInfo * result)
     return success;
 }
 
-static bool TryClassifyAsTD4_TD6(IStream * stream, ClassifiedFileInfo * result)
+static bool TryClassifyAsTD4_TD6(IStream* stream, ClassifiedFileInfo* result)
 {
     bool success = false;
     uint64_t originalPosition = stream->GetPosition();
     try
     {
         size_t dataLength = (size_t)stream->GetLength();
-        auto deleter_lambda = [dataLength](uint8_t * ptr) { Memory::FreeArray(ptr, dataLength); };
+        auto deleter_lambda = [dataLength](uint8_t* ptr) { Memory::FreeArray(ptr, dataLength); };
         std::unique_ptr<uint8_t, decltype(deleter_lambda)> data(stream->ReadArray<uint8_t>(dataLength), deleter_lambda);
         stream->SetPosition(originalPosition);
 
         if (sawyercoding_validate_track_checksum(data.get(), dataLength))
         {
-            std::unique_ptr<uint8_t, decltype(&Memory::Free<uint8_t>)> td6data(Memory::Allocate<uint8_t>(0x10000), &Memory::Free<uint8_t>);
+            std::unique_ptr<uint8_t, decltype(&Memory::Free<uint8_t>)> td6data(
+                Memory::Allocate<uint8_t>(0x10000), &Memory::Free<uint8_t>);
             size_t td6len = sawyercoding_decode_td6(data.get(), td6data.get(), dataLength);
             if (td6data != nullptr && td6len >= 8)
             {
@@ -161,16 +162,22 @@ static bool TryClassifyAsTD4_TD6(IStream * stream, ClassifiedFileInfo * result)
     return success;
 }
 
-uint32_t get_file_extension_type(const utf8 * path)
+uint32_t get_file_extension_type(const utf8* path)
 {
     auto extension = Path::GetExtension(path);
-    if (String::Equals(extension, ".dat", true)) return FILE_EXTENSION_DAT;
+    if (String::Equals(extension, ".dat", true))
-    if (String::Equals(extension, ".sc4", true)) return FILE_EXTENSION_SC4;
+        return FILE_EXTENSION_DAT;
-    if (String::Equals(extension, ".sv4", true)) return FILE_EXTENSION_SV4;
+    if (String::Equals(extension, ".sc4", true))
-    if (String::Equals(extension, ".td4", true)) return FILE_EXTENSION_TD4;
+        return FILE_EXTENSION_SC4;
-    if (String::Equals(extension, ".sc6", true)) return FILE_EXTENSION_SC6;
+    if (String::Equals(extension, ".sv4", true))
-    if (String::Equals(extension, ".sv6", true)) return FILE_EXTENSION_SV6;
+        return FILE_EXTENSION_SV4;
-    if (String::Equals(extension, ".td6", true)) return FILE_EXTENSION_TD6;
+    if (String::Equals(extension, ".td4", true))
+        return FILE_EXTENSION_TD4;
+    if (String::Equals(extension, ".sc6", true))
+        return FILE_EXTENSION_SC6;
+    if (String::Equals(extension, ".sv6", true))
+        return FILE_EXTENSION_SV6;
+    if (String::Equals(extension, ".td6", true))
+        return FILE_EXTENSION_TD6;
     return FILE_EXTENSION_UNKNOWN;
 }
-

src/openrct2/FileClassifier.h

@@ -43,7 +43,7 @@ struct ClassifiedFileInfo
 };
 
 #define FILE_TYPE_S4_CUTOFF 2
-bool TryClassifyFile(const std::string &path, ClassifiedFileInfo * result);
+bool TryClassifyFile(const std::string& path, ClassifiedFileInfo* result);
-bool TryClassifyFile(IStream * stream, ClassifiedFileInfo * result);
+bool TryClassifyFile(IStream* stream, ClassifiedFileInfo* result);
 
-uint32_t get_file_extension_type(const utf8 * path);
+uint32_t get_file_extension_type(const utf8* path);

src/openrct2/Game.h

@@ -22,7 +22,7 @@ enum GAME_COMMAND
     GAME_COMMAND_PLACE_TRACK,
     GAME_COMMAND_REMOVE_TRACK,
     GAME_COMMAND_LOAD_OR_QUIT,
-    GAME_COMMAND_CREATE_RIDE,   // GA
+    GAME_COMMAND_CREATE_RIDE, // GA
     GAME_COMMAND_DEMOLISH_RIDE,
     GAME_COMMAND_SET_RIDE_STATUS, // GA
     GAME_COMMAND_SET_RIDE_VEHICLES,
@@ -57,12 +57,12 @@ enum GAME_COMMAND
     GAME_COMMAND_REMOVE_PARK_ENTRANCE,
     GAME_COMMAND_SET_MAZE_TRACK,
     GAME_COMMAND_SET_PARK_ENTRANCE_FEE, // GA
-    GAME_COMMAND_SET_STAFF_COLOUR, // GA
+    GAME_COMMAND_SET_STAFF_COLOUR,      // GA
     GAME_COMMAND_PLACE_WALL,
     GAME_COMMAND_REMOVE_WALL, // GA
     GAME_COMMAND_PLACE_LARGE_SCENERY,
     GAME_COMMAND_REMOVE_LARGE_SCENERY,
-    GAME_COMMAND_SET_CURRENT_LOAN, // GA
+    GAME_COMMAND_SET_CURRENT_LOAN,     // GA
     GAME_COMMAND_SET_RESEARCH_FUNDING, // GA
     GAME_COMMAND_PLACE_TRACK_DESIGN,
     GAME_COMMAND_START_MARKETING_CAMPAIGN, // GA
@@ -76,7 +76,7 @@ enum GAME_COMMAND
     GAME_COMMAND_SET_LAND_OWNERSHIP,
     GAME_COMMAND_CLEAR_SCENERY,
     GAME_COMMAND_SET_BANNER_NAME, // GA
-    GAME_COMMAND_SET_SIGN_NAME, // GA
+    GAME_COMMAND_SET_SIGN_NAME,   // GA
     GAME_COMMAND_SET_BANNER_STYLE,
     GAME_COMMAND_SET_SIGN_STYLE,
     GAME_COMMAND_SET_PLAYER_GROUP,
@@ -94,56 +94,58 @@ enum GAME_COMMAND
 
 enum : uint32_t
 {
-    GAME_COMMAND_FLAG_APPLY               = (1 << 0), // If this flag is set, the command is applied, otherwise only the cost is retrieved
+    GAME_COMMAND_FLAG_APPLY = (1 << 0), // If this flag is set, the command is applied, otherwise only the cost is retrieved
-    GAME_COMMAND_FLAG_2                   = (1 << 2),
+    GAME_COMMAND_FLAG_2 = (1 << 2),
     GAME_COMMAND_FLAG_ALLOW_DURING_PAUSED = (1 << 3), // Allow while paused
-    GAME_COMMAND_FLAG_4                   = (1 << 4),
+    GAME_COMMAND_FLAG_4 = (1 << 4),
-    GAME_COMMAND_FLAG_5                   = (1 << 5),
+    GAME_COMMAND_FLAG_5 = (1 << 5),
-    GAME_COMMAND_FLAG_GHOST               = (1 << 6),
+    GAME_COMMAND_FLAG_GHOST = (1 << 6),
-    GAME_COMMAND_FLAG_PATH_SCENERY        = (1 << 7),
+    GAME_COMMAND_FLAG_PATH_SCENERY = (1 << 7),
-    GAME_COMMAND_FLAG_NETWORKED           = (1u << 31) // Game command is coming from network
+    GAME_COMMAND_FLAG_NETWORKED = (1u << 31) // Game command is coming from network
 };
 
 enum
 {
-    GAME_PAUSED_NORMAL       = 1 << 0,
+    GAME_PAUSED_NORMAL = 1 << 0,
-    GAME_PAUSED_MODAL        = 1 << 1,
+    GAME_PAUSED_MODAL = 1 << 1,
     GAME_PAUSED_SAVING_TRACK = 1 << 2,
 };
 
 enum
 {
-    ERROR_TYPE_NONE      = 0,
+    ERROR_TYPE_NONE = 0,
-    ERROR_TYPE_GENERIC   = 254,
+    ERROR_TYPE_GENERIC = 254,
     ERROR_TYPE_FILE_LOAD = 255
 };
 
-using GAME_COMMAND_POINTER          = void(int32_t * eax, int32_t * ebx, int32_t * ecx, int32_t * edx, int32_t * esi, int32_t * edi, int32_t * ebp);
+using GAME_COMMAND_POINTER
-using GAME_COMMAND_CALLBACK_POINTER = void(int32_t eax, int32_t ebx, int32_t ecx, int32_t edx, int32_t esi, int32_t edi, int32_t ebp);
+    = void(int32_t* eax, int32_t* ebx, int32_t* ecx, int32_t* edx, int32_t* esi, int32_t* edi, int32_t* ebp);
+using GAME_COMMAND_CALLBACK_POINTER
+    = void(int32_t eax, int32_t ebx, int32_t ecx, int32_t edx, int32_t esi, int32_t edi, int32_t ebp);
 
-extern GAME_COMMAND_CALLBACK_POINTER * game_command_callback;
+extern GAME_COMMAND_CALLBACK_POINTER* game_command_callback;
-int32_t game_command_callback_get_index(GAME_COMMAND_CALLBACK_POINTER * callback);
+int32_t game_command_callback_get_index(GAME_COMMAND_CALLBACK_POINTER* callback);
-GAME_COMMAND_CALLBACK_POINTER * game_command_callback_get_callback(uint32_t index);
+GAME_COMMAND_CALLBACK_POINTER* game_command_callback_get_callback(uint32_t index);
 extern int32_t game_command_playerid;
 
 extern rct_string_id gGameCommandErrorTitle;
 extern rct_string_id gGameCommandErrorText;
-extern uint8_t         gErrorType;
+extern uint8_t gErrorType;
 extern rct_string_id gErrorStringId;
 
-extern GAME_COMMAND_POINTER * new_game_command_table[GAME_COMMAND_COUNT];
+extern GAME_COMMAND_POINTER* new_game_command_table[GAME_COMMAND_COUNT];
 
 extern uint32_t gCurrentTicks;
 
 extern uint16_t gTicksSinceLastUpdate;
-extern uint8_t  gGamePaused;
+extern uint8_t gGamePaused;
 extern int32_t gGameSpeed;
-extern float  gDayNightCycle;
+extern float gDayNightCycle;
-extern bool   gInUpdateCode;
+extern bool gInUpdateCode;
-extern bool   gInMapInitCode;
+extern bool gInMapInitCode;
 extern int32_t gGameCommandNestLevel;
-extern bool   gGameCommandIsNetworked;
+extern bool gGameCommandIsNetworked;
-extern char   gCurrentLoadedPath[260];
+extern char gCurrentLoadedPath[260];
 
 extern bool gLoadKeepWindowsOpen;
 
@@ -158,24 +160,25 @@ void reset_all_sprite_quadrant_placements();
 void update_palette_effects();
 
 int32_t game_do_command(int32_t eax, int32_t ebx, int32_t ecx, int32_t edx, int32_t esi, int32_t edi, int32_t ebp);
-int32_t game_do_command_p(uint32_t command, int32_t * eax, int32_t * ebx, int32_t * ecx, int32_t * edx, int32_t * esi, int32_t * edi, int32_t * ebp);
+int32_t game_do_command_p(
+    uint32_t command, int32_t* eax, int32_t* ebx, int32_t* ecx, int32_t* edx, int32_t* esi, int32_t* edi, int32_t* ebp);
 
-void game_log_multiplayer_command(int command, const int * eax, const int * ebx, const int * ecx, int * edx, int * edi, int * ebp);
+void game_log_multiplayer_command(int command, const int* eax, const int* ebx, const int* ecx, int* edx, int* edi, int* ebp);
 
 void game_load_or_quit_no_save_prompt();
-void load_from_sv6(const char * path);
+void load_from_sv6(const char* path);
 void game_load_init();
-void game_pause_toggle(int32_t * eax, int32_t * ebx, int32_t * ecx, int32_t * edx, int32_t * esi, int32_t * edi, int32_t * ebp);
+void game_pause_toggle(int32_t* eax, int32_t* ebx, int32_t* ecx, int32_t* edx, int32_t* esi, int32_t* edi, int32_t* ebp);
 void pause_toggle();
 bool game_is_paused();
 bool game_is_not_paused();
 void save_game();
-void * create_save_game_as_intent();
+void* create_save_game_as_intent();
 void save_game_as();
 void game_autosave();
 void game_convert_strings_to_utf8();
 void game_convert_news_items_to_utf8();
-void game_convert_strings_to_rct2(rct_s6_data * s6);
+void game_convert_strings_to_rct2(rct_s6_data* s6);
-void utf8_to_rct2_self(char * buffer, size_t length);
+void utf8_to_rct2_self(char* buffer, size_t length);
-void rct2_to_utf8_self(char * buffer, size_t length);
+void rct2_to_utf8_self(char* buffer, size_t length);
 void game_fix_save_vars();

src/openrct2/GameState.cpp

@@ -8,26 +8,27 @@
  *****************************************************************************/
 
 #include "GameState.h"
+
 #include "Context.h"
-#include "core/Math.hpp"
 #include "Editor.h"
 #include "Input.h"
+#include "OpenRCT2.h"
+#include "core/Math.hpp"
 #include "interface/Screenshot.h"
 #include "localisation/Date.h"
 #include "localisation/Localisation.h"
 #include "management/NewsItem.h"
 #include "network/network.h"
-#include "OpenRCT2.h"
 #include "platform/Platform2.h"
 #include "scenario/Scenario.h"
 #include "title/TitleScreen.h"
 #include "title/TitleSequencePlayer.h"
+#include "ui/UiContext.h"
 #include "windows/Intent.h"
 #include "world/Climate.h"
 #include "world/MapAnimation.h"
 #include "world/Park.h"
 #include "world/Scenery.h"
-#include "ui/UiContext.h"
 
 using namespace OpenRCT2;
 
@@ -99,7 +100,8 @@ void GameState::Update()
         numUpdates = Math::Clamp<uint32_t>(1, numUpdates, GAME_MAX_UPDATES);
     }
 
-    if (network_get_mode() == NETWORK_MODE_CLIENT && network_get_status() == NETWORK_STATUS_CONNECTED && network_get_authstatus() == NETWORK_AUTH_OK)
+    if (network_get_mode() == NETWORK_MODE_CLIENT && network_get_status() == NETWORK_STATUS_CONNECTED
+        && network_get_authstatus() == NETWORK_AUTH_OK)
     {
         if (network_get_server_tick() - gCurrentTicks >= 10)
         {
@@ -127,8 +129,7 @@ void GameState::Update()
         UpdateLogic();
         if (gGameSpeed == 1)
         {
-            if (input_get_state() == INPUT_STATE_RESET ||
+            if (input_get_state() == INPUT_STATE_RESET || input_get_state() == INPUT_STATE_NORMAL)
-                input_get_state() == INPUT_STATE_NORMAL)
             {
                 if (input_test_flag(INPUT_FLAG_VIEWPORT_SCROLLING))
                 {
@@ -174,9 +175,8 @@ void GameState::Update()
     }
 
     // Always perform autosave check, even when paused
-    if (!(gScreenFlags & SCREEN_FLAGS_TITLE_DEMO) &&
+    if (!(gScreenFlags & SCREEN_FLAGS_TITLE_DEMO) && !(gScreenFlags & SCREEN_FLAGS_TRACK_DESIGNER)
-        !(gScreenFlags & SCREEN_FLAGS_TRACK_DESIGNER) &&
+        && !(gScreenFlags & SCREEN_FLAGS_TRACK_MANAGER))
-        !(gScreenFlags & SCREEN_FLAGS_TRACK_MANAGER))
     {
         scenario_autosave_check();
     }
@@ -184,7 +184,7 @@ void GameState::Update()
     window_dispatch_update_all();
 
     gGameCommandNestLevel = 0;
-    gInUpdateCode         = false;
+    gInUpdateCode = false;
 }
 
 void GameState::UpdateLogic()
@@ -195,9 +195,8 @@ void GameState::UpdateLogic()
 
     network_update();
 
-    if (network_get_mode() == NETWORK_MODE_CLIENT &&
+    if (network_get_mode() == NETWORK_MODE_CLIENT && network_get_status() == NETWORK_STATUS_CONNECTED
-        network_get_status() == NETWORK_STATUS_CONNECTED &&
+        && network_get_authstatus() == NETWORK_AUTH_OK)
-        network_get_authstatus() == NETWORK_AUTH_OK)
     {
         // Can't be in sync with server, round trips won't work if we are at same level.
         if (gCurrentTicks >= network_get_server_tick())
@@ -250,16 +249,16 @@ void GameState::UpdateLogic()
     editor_open_windows_for_current_step();
 
     // Update windows
-    //window_dispatch_update_all();
+    // window_dispatch_update_all();
 
     if (gErrorType != ERROR_TYPE_NONE)
     {
         rct_string_id title_text = STR_UNABLE_TO_LOAD_FILE;
-        rct_string_id body_text  = gErrorStringId;
+        rct_string_id body_text = gErrorStringId;
         if (gErrorType == ERROR_TYPE_GENERIC)
         {
             title_text = gErrorStringId;
-            body_text  = 0xFFFF;
+            body_text = 0xFFFF;
         }
         gErrorType = ERROR_TYPE_NONE;
 

src/openrct2/GameState.h

@@ -9,9 +9,10 @@
 
 #pragma once
 
-#include <memory>
 #include "Date.h"
 
+#include <memory>
+
 namespace OpenRCT2
 {
     class Park;
@@ -23,17 +24,23 @@ namespace OpenRCT2
     {
     private:
         std::unique_ptr<Park> _park;
-        Date                  _date;
+        Date _date;
 
     public:
         GameState();
         GameState(const GameState&) = delete;
 
-        Date& GetDate() { return _date; }
+        Date& GetDate()
-        Park& GetPark() { return *_park; }
+        {
+            return _date;
+        }
+        Park& GetPark()
+        {
+            return *_park;
+        }
 
         void InitAll(int32_t mapSize);
         void Update();
         void UpdateLogic();
     };
-}
+} // namespace OpenRCT2

src/openrct2/Input.cpp

@@ -7,9 +7,10 @@
  * OpenRCT2 is licensed under the GNU General Public License version 3.
  *****************************************************************************/
 
-#include "Context.h"
 #include "Input.h"
 
+#include "Context.h"
+
 INPUT_STATE _inputState;
 uint8_t _inputFlags;
 uint8_t gInputPlaceObjectModifier;
@@ -42,9 +43,12 @@ void game_handle_keyboard_input()
 
 void input_set_flag(INPUT_FLAGS flag, bool on)
 {
-    if (on) {
+    if (on)
+    {
         _inputFlags |= flag;
-    } else {
+    }
+    else
+    {
         _inputFlags &= ~flag;
     }
 }

src/openrct2/Input.h

@@ -12,7 +12,8 @@
 
 #include "interface/Window.h"
 
-enum INPUT_FLAGS {
+enum INPUT_FLAGS
+{
     INPUT_FLAG_WIDGET_PRESSED = (1 << 0),
 
     // The dropdown can stay open if the mouse is released, set on flag DROPDOWN_FLAG_STAY_OPEN
@@ -36,7 +37,8 @@ enum INPUT_FLAGS {
     INPUT_FLAG_VIEWPORT_SCROLLING = (1 << 7)
 };
 
-enum MOUSE_STATE {
+enum MOUSE_STATE
+{
     MOUSE_STATE_RELEASED,
     MOUSE_STATE_LEFT_PRESS,
     MOUSE_STATE_LEFT_RELEASE,
@@ -44,7 +46,8 @@ enum MOUSE_STATE {
     MOUSE_STATE_RIGHT_RELEASE
 };
 
-enum INPUT_STATE {
+enum INPUT_STATE
+{
     INPUT_STATE_RESET,
     INPUT_STATE_NORMAL,
     INPUT_STATE_WIDGET_PRESSED,
@@ -57,13 +60,15 @@ enum INPUT_STATE {
     INPUT_STATE_SCROLL_RIGHT
 };
 
-enum PLACE_OBJECT_MODIFIER {
+enum PLACE_OBJECT_MODIFIER
+{
     PLACE_OBJECT_MODIFIER_NONE = 0,
     PLACE_OBJECT_MODIFIER_SHIFT_Z = (1 << 0),
     PLACE_OBJECT_MODIFIER_COPY_Z = (1 << 1),
 };
 
-struct widget_ref {
+struct widget_ref
+{
     rct_windowclass window_classification;
     rct_windownumber window_number;
     rct_widgetindex widget_index;
@@ -90,7 +95,7 @@ extern INPUT_STATE _inputState;
 extern uint8_t _inputFlags;
 extern uint16_t _tooltipNotShownTicks;
 
-void input_window_position_begin(rct_window *w, rct_widgetindex widgetIndex, int32_t x, int32_t y);
+void input_window_position_begin(rct_window* w, rct_widgetindex widgetIndex, int32_t x, int32_t y);
 
 void title_handle_keyboard_input();
 void game_handle_input();

src/openrct2/Intro.cpp

@@ -7,32 +7,33 @@
  * OpenRCT2 is licensed under the GNU General Public License version 3.
  *****************************************************************************/
 
-#include "audio/audio.h"
-#include "audio/AudioMixer.h"
-#include "Context.h"
-#include "drawing/Drawing.h"
 #include "Intro.h"
+
+#include "Context.h"
+#include "audio/AudioMixer.h"
+#include "audio/audio.h"
+#include "drawing/Drawing.h"
 #include "sprites.h"
 
-#define BACKROUND_COLOUR_DARK       PALETTE_INDEX_10
+#define BACKROUND_COLOUR_DARK PALETTE_INDEX_10
-#define BACKROUND_COLOUR_LOGO       PALETTE_INDEX_245
+#define BACKROUND_COLOUR_LOGO PALETTE_INDEX_245
-#define BORDER_COLOUR_PUBLISHER     PALETTE_INDEX_129
+#define BORDER_COLOUR_PUBLISHER PALETTE_INDEX_129
 
-#define PALETTE_G1_IDX_DEVELOPER    23217
+#define PALETTE_G1_IDX_DEVELOPER 23217
-#define PALETTE_G1_IDX_LOGO         23224
+#define PALETTE_G1_IDX_LOGO 23224
 
 uint8_t gIntroState;
 
 // Used mainly for timing but also for Y coordinate and fading.
 static int32_t _introStateCounter;
 
-static void *_soundChannel = nullptr;
+static void* _soundChannel = nullptr;
 static bool _chainLiftFinished;
 
 static void screen_intro_process_mouse_input();
 static void screen_intro_process_keyboard_input();
 static void screen_intro_skip_part();
-static void screen_intro_draw_logo(rct_drawpixelinfo *dpi);
+static void screen_intro_draw_logo(rct_drawpixelinfo* dpi);
 
 // rct2: 0x0068E966
 void intro_update()
@@ -40,180 +41,202 @@ void intro_update()
     screen_intro_process_mouse_input();
     screen_intro_process_keyboard_input();
 
-    switch (gIntroState) {
+    switch (gIntroState)
-    case INTRO_STATE_DISCLAIMER_1:
+    {
-    case INTRO_STATE_DISCLAIMER_2:
+        case INTRO_STATE_DISCLAIMER_1:
-        // Originally used for the disclaimer text
+        case INTRO_STATE_DISCLAIMER_2:
-        gIntroState = INTRO_STATE_PUBLISHER_BEGIN;
+            // Originally used for the disclaimer text
-    case INTRO_STATE_PUBLISHER_BEGIN:
+            gIntroState = INTRO_STATE_PUBLISHER_BEGIN;
-        load_palette();
+        case INTRO_STATE_PUBLISHER_BEGIN:
+            load_palette();
 
-        // Set the Y for the Infogrames logo
+            // Set the Y for the Infogrames logo
-        _introStateCounter = -580;
+            _introStateCounter = -580;
 
-        // Play the chain lift sound
+            // Play the chain lift sound
-        _soundChannel = Mixer_Play_Effect(SOUND_LIFT_7, MIXER_LOOP_INFINITE, MIXER_VOLUME_MAX, 0.5f, 1, true);
+            _soundChannel = Mixer_Play_Effect(SOUND_LIFT_7, MIXER_LOOP_INFINITE, MIXER_VOLUME_MAX, 0.5f, 1, true);
-        _chainLiftFinished = false;
+            _chainLiftFinished = false;
-        gIntroState++;
+            gIntroState++;
-        break;
+            break;
-    case INTRO_STATE_PUBLISHER_SCROLL:
+        case INTRO_STATE_PUBLISHER_SCROLL:
-        // Move the Infogrames logo down
+            // Move the Infogrames logo down
-        _introStateCounter += 5;
+            _introStateCounter += 5;
 
-        // Check if logo is off the screen...ish
+            // Check if logo is off the screen...ish
-        if (_introStateCounter > context_get_height() - 120) {
+            if (_introStateCounter > context_get_height() - 120)
+            {
+                _introStateCounter = -116;
+                gIntroState++;
+            }
+
+            break;
+        case INTRO_STATE_DEVELOPER_BEGIN:
+            // Set the Y for the Chris Sawyer logo
             _introStateCounter = -116;
+
             gIntroState++;
-        }
+            break;
+        case INTRO_STATE_DEVELOPER_SCROLL:
+            _introStateCounter += 5;
 
-        break;
+            // Check if logo is almost scrolled to the bottom
-    case INTRO_STATE_DEVELOPER_BEGIN:
+            if (!_chainLiftFinished && _introStateCounter >= context_get_height() + 40 - 421)
-        // Set the Y for the Chris Sawyer logo
+            {
-        _introStateCounter = -116;
+                _chainLiftFinished = true;
 
-        gIntroState++;
+                // Stop the chain lift sound
-        break;
+                if (_soundChannel != nullptr)
-    case INTRO_STATE_DEVELOPER_SCROLL:
+                {
-        _introStateCounter += 5;
+                    Mixer_Stop_Channel(_soundChannel);
+                    _soundChannel = nullptr;
+                }
 
-        // Check if logo is almost scrolled to the bottom
+                // Play the track friction sound
-        if (!_chainLiftFinished && _introStateCounter >= context_get_height() + 40 - 421) {
+                _soundChannel
-            _chainLiftFinished = true;
+                    = Mixer_Play_Effect(SOUND_TRACK_FRICTION_3, MIXER_LOOP_INFINITE, MIXER_VOLUME_MAX, 0.25f, 0.75, true);
+            }
 
-            // Stop the chain lift sound
+            // Check if logo is off the screen...ish
-            if (_soundChannel != nullptr) {
+            if (_introStateCounter >= context_get_height() + 40)
+            {
+                // Stop the track friction sound
+                if (_soundChannel != nullptr)
+                {
+                    Mixer_Stop_Channel(_soundChannel);
+                    _soundChannel = nullptr;
+                }
+
+                // Play long peep scream sound
+                _soundChannel = Mixer_Play_Effect(SOUND_SCREAM_1, MIXER_LOOP_NONE, MIXER_VOLUME_MAX, 0.5f, 1, false);
+
+                gIntroState++;
+                _introStateCounter = 0;
+            }
+            break;
+        case INTRO_STATE_LOGO_FADE_IN:
+            // Fade in, add 4 / 256 to fading
+            _introStateCounter += 0x400;
+            if (_introStateCounter > 0xFF00)
+            {
+                gIntroState++;
+                _introStateCounter = 0;
+            }
+            break;
+        case INTRO_STATE_LOGO_WAIT:
+            // Wait 80 game ticks
+            _introStateCounter++;
+            if (_introStateCounter >= 80)
+            {
+                // Set fading to 256
+                _introStateCounter = 0xFF00;
+
+                gIntroState++;
+            }
+            break;
+        case INTRO_STATE_LOGO_FADE_OUT:
+            // Fade out, subtract 4 / 256 from fading
+            _introStateCounter -= 0x400;
+            if (_introStateCounter < 0)
+            {
+                gIntroState = INTRO_STATE_CLEAR;
+            }
+            break;
+        case INTRO_STATE_CLEAR:
+            // Stop any playing sound
+            if (_soundChannel != nullptr)
+            {
                 Mixer_Stop_Channel(_soundChannel);
                 _soundChannel = nullptr;
             }
 
-            // Play the track friction sound
+            // Move to next part
-            _soundChannel = Mixer_Play_Effect(SOUND_TRACK_FRICTION_3, MIXER_LOOP_INFINITE, MIXER_VOLUME_MAX, 0.25f, 0.75, true);
-        }
-
-        // Check if logo is off the screen...ish
-        if (_introStateCounter >= context_get_height() + 40) {
-            // Stop the track friction sound
-            if (_soundChannel != nullptr) {
-                Mixer_Stop_Channel(_soundChannel);
-                _soundChannel = nullptr;
-            }
-
-            // Play long peep scream sound
-            _soundChannel = Mixer_Play_Effect(SOUND_SCREAM_1, MIXER_LOOP_NONE, MIXER_VOLUME_MAX, 0.5f, 1, false);
-
             gIntroState++;
             _introStateCounter = 0;
-        }
+            break;
-        break;
+        case INTRO_STATE_FINISH:
-    case INTRO_STATE_LOGO_FADE_IN:
+            gIntroState = INTRO_STATE_NONE;
-        // Fade in, add 4 / 256 to fading
+            load_palette();
-        _introStateCounter += 0x400;
+            audio_start_title_music();
-        if (_introStateCounter > 0xFF00) {
+            break;
-            gIntroState++;
-            _introStateCounter = 0;
-        }
-        break;
-    case INTRO_STATE_LOGO_WAIT:
-        // Wait 80 game ticks
-        _introStateCounter++;
-        if (_introStateCounter >= 80) {
-            // Set fading to 256
-            _introStateCounter = 0xFF00;
-
-            gIntroState++;
-        }
-        break;
-    case INTRO_STATE_LOGO_FADE_OUT:
-        // Fade out, subtract 4 / 256 from fading
-        _introStateCounter -= 0x400;
-        if (_introStateCounter < 0) {
-            gIntroState = INTRO_STATE_CLEAR;
-        }
-        break;
-    case INTRO_STATE_CLEAR:
-        // Stop any playing sound
-        if (_soundChannel != nullptr) {
-            Mixer_Stop_Channel(_soundChannel);
-            _soundChannel = nullptr;
-        }
-
-        // Move to next part
-        gIntroState++;
-        _introStateCounter = 0;
-        break;
-    case INTRO_STATE_FINISH:
-        gIntroState = INTRO_STATE_NONE;
-        load_palette();
-        audio_start_title_music();
-        break;
     }
 }
 
-void intro_draw(rct_drawpixelinfo *dpi)
+void intro_draw(rct_drawpixelinfo* dpi)
 {
     int32_t screenWidth = context_get_width();
 
-    switch (gIntroState) {
+    switch (gIntroState)
-    case INTRO_STATE_DISCLAIMER_1:
+    {
-    case INTRO_STATE_DISCLAIMER_2:
+        case INTRO_STATE_DISCLAIMER_1:
-        break;
+        case INTRO_STATE_DISCLAIMER_2:
-    case INTRO_STATE_PUBLISHER_BEGIN:
+            break;
-        gfx_clear(dpi, BACKROUND_COLOUR_DARK);
+        case INTRO_STATE_PUBLISHER_BEGIN:
-        break;
+            gfx_clear(dpi, BACKROUND_COLOUR_DARK);
-    case INTRO_STATE_PUBLISHER_SCROLL:
+            break;
-        gfx_clear(dpi, BACKROUND_COLOUR_DARK);
+        case INTRO_STATE_PUBLISHER_SCROLL:
+            gfx_clear(dpi, BACKROUND_COLOUR_DARK);
 
-        // Draw a white rectangle for the logo background (gives a bit of white margin)
+            // Draw a white rectangle for the logo background (gives a bit of white margin)
-        gfx_fill_rect(dpi,
+            gfx_fill_rect(
-            (screenWidth / 2) - 320 + 50, _introStateCounter + 50,
+                dpi,
-            (screenWidth / 2) - 320 + 50 + 540, _introStateCounter + 50 + 425,
+                (screenWidth / 2) - 320 + 50,
-            BORDER_COLOUR_PUBLISHER);
+                _introStateCounter + 50,
+                (screenWidth / 2) - 320 + 50 + 540,
+                _introStateCounter + 50 + 425,
+                BORDER_COLOUR_PUBLISHER);
 
-        // Draw Infogrames logo
+            // Draw Infogrames logo
-        gfx_draw_sprite(dpi, SPR_INTRO_INFOGRAMES_00, (screenWidth / 2) - 320 + 69, _introStateCounter + 69, 0);
+            gfx_draw_sprite(dpi, SPR_INTRO_INFOGRAMES_00, (screenWidth / 2) - 320 + 69, _introStateCounter + 69, 0);
-        gfx_draw_sprite(dpi, SPR_INTRO_INFOGRAMES_10, (screenWidth / 2) - 320 + 319, _introStateCounter + 69, 0);
+            gfx_draw_sprite(dpi, SPR_INTRO_INFOGRAMES_10, (screenWidth / 2) - 320 + 319, _introStateCounter + 69, 0);
-        gfx_draw_sprite(dpi, SPR_INTRO_INFOGRAMES_01, (screenWidth / 2) - 320 + 69, _introStateCounter + 319, 0);
+            gfx_draw_sprite(dpi, SPR_INTRO_INFOGRAMES_01, (screenWidth / 2) - 320 + 69, _introStateCounter + 319, 0);
-        gfx_draw_sprite(dpi, SPR_INTRO_INFOGRAMES_11, (screenWidth / 2) - 320 + 319, _introStateCounter + 319, 0);
+            gfx_draw_sprite(dpi, SPR_INTRO_INFOGRAMES_11, (screenWidth / 2) - 320 + 319, _introStateCounter + 319, 0);
-        break;
+            break;
-    case INTRO_STATE_DEVELOPER_BEGIN:
+        case INTRO_STATE_DEVELOPER_BEGIN:
-        gfx_clear(dpi, BACKROUND_COLOUR_DARK);
+            gfx_clear(dpi, BACKROUND_COLOUR_DARK);
-        gfx_transpose_palette(PALETTE_G1_IDX_DEVELOPER, 255);
+            gfx_transpose_palette(PALETTE_G1_IDX_DEVELOPER, 255);
-        break;
+            break;
-    case INTRO_STATE_DEVELOPER_SCROLL:
+        case INTRO_STATE_DEVELOPER_SCROLL:
-        gfx_clear(dpi, BACKROUND_COLOUR_DARK);
+            gfx_clear(dpi, BACKROUND_COLOUR_DARK);
 
-        // Draw Chris Sawyer logo
+            // Draw Chris Sawyer logo
-        gfx_draw_sprite(dpi, SPR_INTRO_CHRIS_SAWYER_00, (screenWidth / 2) - 320 + 70, _introStateCounter, 0);
+            gfx_draw_sprite(dpi, SPR_INTRO_CHRIS_SAWYER_00, (screenWidth / 2) - 320 + 70, _introStateCounter, 0);
-        gfx_draw_sprite(dpi, SPR_INTRO_CHRIS_SAWYER_10, (screenWidth / 2) - 320 + 320, _introStateCounter, 0);
+            gfx_draw_sprite(dpi, SPR_INTRO_CHRIS_SAWYER_10, (screenWidth / 2) - 320 + 320, _introStateCounter, 0);
-        break;
+            break;
-    case INTRO_STATE_LOGO_FADE_IN:
+        case INTRO_STATE_LOGO_FADE_IN:
-        if (_introStateCounter <= 0xFF00) {
+            if (_introStateCounter <= 0xFF00)
-            gfx_transpose_palette(PALETTE_G1_IDX_LOGO, (_introStateCounter >> 8) & 0xFF);
+            {
-        } else {
+                gfx_transpose_palette(PALETTE_G1_IDX_LOGO, (_introStateCounter >> 8) & 0xFF);
-            gfx_transpose_palette(PALETTE_G1_IDX_LOGO, 255);
+            }
-        }
+            else
-        screen_intro_draw_logo(dpi);
+            {
-        break;
+                gfx_transpose_palette(PALETTE_G1_IDX_LOGO, 255);
-    case INTRO_STATE_LOGO_WAIT:
+            }
-        screen_intro_draw_logo(dpi);
+            screen_intro_draw_logo(dpi);
-        break;
+            break;
-    case INTRO_STATE_LOGO_FADE_OUT:
+        case INTRO_STATE_LOGO_WAIT:
-        if (_introStateCounter >= 0) {
+            screen_intro_draw_logo(dpi);
-            gfx_transpose_palette(PALETTE_G1_IDX_LOGO, (_introStateCounter >> 8) & 0xFF);
+            break;
-        } else {
+        case INTRO_STATE_LOGO_FADE_OUT:
-            gfx_transpose_palette(PALETTE_G1_IDX_LOGO, 0);
+            if (_introStateCounter >= 0)
-        }
+            {
-        screen_intro_draw_logo(dpi);
+                gfx_transpose_palette(PALETTE_G1_IDX_LOGO, (_introStateCounter >> 8) & 0xFF);
-        break;
+            }
-    case INTRO_STATE_CLEAR:
+            else
-        gfx_clear(dpi, BACKROUND_COLOUR_DARK);
+            {
-        break;
+                gfx_transpose_palette(PALETTE_G1_IDX_LOGO, 0);
+            }
+            screen_intro_draw_logo(dpi);
+            break;
+        case INTRO_STATE_CLEAR:
+            gfx_clear(dpi, BACKROUND_COLOUR_DARK);
+            break;
     }
 }
 
 static void screen_intro_process_mouse_input()
 {
-    if (context_get_cursor_state()->any == CURSOR_PRESSED) {
+    if (context_get_cursor_state()->any == CURSOR_PRESSED)
+    {
         screen_intro_skip_part();
     }
 }
@@ -224,9 +247,11 @@ static void screen_intro_process_mouse_input()
  */
 static void screen_intro_process_keyboard_input()
 {
-    const uint8_t * keys = context_get_keys_state();
+    const uint8_t* keys = context_get_keys_state();
-    for (int i = 0; i < 256; i++) {
+    for (int i = 0; i < 256; i++)
-        if (keys[i] != 0) {
+    {
+        if (keys[i] != 0)
+        {
             screen_intro_skip_part();
             break;
         }
@@ -235,19 +260,20 @@ static void screen_intro_process_keyboard_input()
 
 static void screen_intro_skip_part()
 {
-    switch (gIntroState) {
+    switch (gIntroState)
-    case INTRO_STATE_NONE:
+    {
-        break;
+        case INTRO_STATE_NONE:
-    case INTRO_STATE_DISCLAIMER_2:
+            break;
-        gIntroState = INTRO_STATE_PUBLISHER_BEGIN;
+        case INTRO_STATE_DISCLAIMER_2:
-        break;
+            gIntroState = INTRO_STATE_PUBLISHER_BEGIN;
-    default:
+            break;
-        gIntroState = INTRO_STATE_CLEAR;
+        default:
-        break;
+            gIntroState = INTRO_STATE_CLEAR;
+            break;
     }
 }
 
-static void screen_intro_draw_logo(rct_drawpixelinfo *dpi)
+static void screen_intro_draw_logo(rct_drawpixelinfo* dpi)
 {
     int32_t screenWidth = context_get_width();
     int32_t imageWidth = 640;
@@ -261,10 +287,10 @@ static void screen_intro_draw_logo(rct_drawpixelinfo *dpi)
     drawing_engine_invalidate_image(SPR_INTRO_LOGO_21);
 
     gfx_clear(dpi, BACKROUND_COLOUR_LOGO);
-    gfx_draw_sprite(dpi, SPR_INTRO_LOGO_00, imageX + 0,     0, 0);
+    gfx_draw_sprite(dpi, SPR_INTRO_LOGO_00, imageX + 0, 0, 0);
-    gfx_draw_sprite(dpi, SPR_INTRO_LOGO_10, imageX + 220,   0, 0);
+    gfx_draw_sprite(dpi, SPR_INTRO_LOGO_10, imageX + 220, 0, 0);
-    gfx_draw_sprite(dpi, SPR_INTRO_LOGO_20, imageX + 440,   0, 0);
+    gfx_draw_sprite(dpi, SPR_INTRO_LOGO_20, imageX + 440, 0, 0);
-    gfx_draw_sprite(dpi, SPR_INTRO_LOGO_01, imageX + 0,   240, 0);
+    gfx_draw_sprite(dpi, SPR_INTRO_LOGO_01, imageX + 0, 240, 0);
     gfx_draw_sprite(dpi, SPR_INTRO_LOGO_11, imageX + 220, 240, 0);
     gfx_draw_sprite(dpi, SPR_INTRO_LOGO_21, imageX + 440, 240, 0);
 }

src/openrct2/Intro.h

@@ -14,7 +14,8 @@
 
 struct rct_drawpixelinfo;
 
-enum INTRO_STATE {
+enum INTRO_STATE
+{
     INTRO_STATE_NONE,
     INTRO_STATE_PUBLISHER_BEGIN,
     INTRO_STATE_PUBLISHER_SCROLL,
@@ -25,13 +26,13 @@ enum INTRO_STATE {
     INTRO_STATE_LOGO_FADE_OUT,
     INTRO_STATE_DISCLAIMER_1,
     INTRO_STATE_DISCLAIMER_2,
-    INTRO_STATE_CLEAR               = 254,
+    INTRO_STATE_CLEAR = 254,
-    INTRO_STATE_FINISH              = 255,
+    INTRO_STATE_FINISH = 255,
 };
 
 extern uint8_t gIntroState;
 
 void intro_update();
-void intro_draw(rct_drawpixelinfo *dpi);
+void intro_draw(rct_drawpixelinfo* dpi);
 
 #endif

src/openrct2/OpenRCT2.h

@@ -59,8 +59,7 @@ extern uint8_t gScreenFlags;
 extern uint32_t gScreenAge;
 extern uint8_t gSavePromptMode;
 
-void openrct2_write_full_version_info(utf8 * buffer, size_t bufferSize);
+void openrct2_write_full_version_info(utf8* buffer, size_t bufferSize);
 void openrct2_finish();
 
-int32_t cmdline_run(const char * * argv, int32_t argc);
+int32_t cmdline_run(const char** argv, int32_t argc);
-

src/openrct2/ParkImporter.cpp

@@ -7,17 +7,19 @@
  * OpenRCT2 is licensed under the GNU General Public License version 3.
  *****************************************************************************/
 
-#include <memory>
+#include "ParkImporter.h"
+
 #include "Context.h"
 #include "core/Path.hpp"
 #include "core/String.hpp"
 #include "object/ObjectManager.h"
 #include "object/ObjectRepository.h"
-#include "ParkImporter.h"
+
+#include <memory>
 
 namespace ParkImporter
 {
-    std::unique_ptr<IParkImporter> Create(const std::string &hintPath)
+    std::unique_ptr<IParkImporter> Create(const std::string& hintPath)
     {
         std::unique_ptr<IParkImporter> parkImporter;
         std::string extension = Path::GetExtension(hintPath);
@@ -33,15 +35,13 @@ namespace ParkImporter
         return parkImporter;
     }
 
-    bool ExtensionIsRCT1(const std::string &extension)
+    bool ExtensionIsRCT1(const std::string& extension)
     {
-        return String::Equals(extension, ".sc4", true) ||
+        return String::Equals(extension, ".sc4", true) || String::Equals(extension, ".sv4", true);
-            String::Equals(extension, ".sv4", true);
     }
 
-    bool ExtensionIsScenario(const std::string &extension)
+    bool ExtensionIsScenario(const std::string& extension)
     {
-        return String::Equals(extension, ".sc4", true) ||
+        return String::Equals(extension, ".sc4", true) || String::Equals(extension, ".sc6", true);
-            String::Equals(extension, ".sc6", true);
     }
-}
+} // namespace ParkImporter

src/openrct2/ParkImporter.h

@@ -10,7 +10,6 @@
 #pragma once
 
 #include "common.h"
-
 #include "object/Object.h"
 
 enum PARK_LOAD_ERROR
@@ -22,10 +21,11 @@ enum PARK_LOAD_ERROR
     PARK_LOAD_ERROR_UNKNOWN = 255
 };
 
+#include "core/String.hpp"
+
 #include <memory>
 #include <string>
 #include <vector>
-#include "core/String.hpp"
 
 interface IObjectManager;
 interface IObjectRepository;
@@ -51,13 +51,11 @@ interface IParkImporter
 public:
     virtual ~IParkImporter() = default;
 
-    virtual ParkLoadResult  Load(const utf8 * path) abstract;
+    virtual ParkLoadResult Load(const utf8* path) abstract;
-    virtual ParkLoadResult  LoadSavedGame(const utf8 * path, bool skipObjectCheck = false) abstract;
+    virtual ParkLoadResult LoadSavedGame(const utf8* path, bool skipObjectCheck = false) abstract;
-    virtual ParkLoadResult  LoadScenario(const utf8 * path, bool skipObjectCheck = false) abstract;
+    virtual ParkLoadResult LoadScenario(const utf8* path, bool skipObjectCheck = false) abstract;
-    virtual ParkLoadResult  LoadFromStream(IStream * stream,
+    virtual ParkLoadResult LoadFromStream(
-                                           bool isScenario,
+        IStream * stream, bool isScenario, bool skipObjectCheck = false, const utf8* path = String::Empty) abstract;
-                                           bool skipObjectCheck = false,
-                                           const utf8 * path = String::Empty) abstract;
 
     virtual void Import() abstract;
     virtual bool GetDetails(scenario_index_entry * dst) abstract;
@@ -65,13 +63,14 @@ public:
 
 namespace ParkImporter
 {
-    std::unique_ptr<IParkImporter> Create(const std::string &hintPath);
+    std::unique_ptr<IParkImporter> Create(const std::string& hintPath);
     std::unique_ptr<IParkImporter> CreateS4();
-    std::unique_ptr<IParkImporter> CreateS6(std::shared_ptr<IObjectRepository> objectRepository, std::shared_ptr<IObjectManager> objectManager);
+    std::unique_ptr<IParkImporter>
+        CreateS6(std::shared_ptr<IObjectRepository> objectRepository, std::shared_ptr<IObjectManager> objectManager);
 
-    bool ExtensionIsRCT1(const std::string &extension);
+    bool ExtensionIsRCT1(const std::string& extension);
-    bool ExtensionIsScenario(const std::string &extension);
+    bool ExtensionIsScenario(const std::string& extension);
-}
+} // namespace ParkImporter
 
 class ObjectLoadException : public std::exception
 {

src/openrct2/PlatformEnvironment.cpp

@@ -7,13 +7,14 @@
  * OpenRCT2 is licensed under the GNU General Public License version 3.
  *****************************************************************************/
 
+#include "PlatformEnvironment.h"
+
+#include "OpenRCT2.h"
 #include "config/Config.h"
 #include "core/Path.hpp"
 #include "core/String.hpp"
-#include "OpenRCT2.h"
-#include "platform/platform.h"
 #include "platform/Platform2.h"
-#include "PlatformEnvironment.h"
+#include "platform/platform.h"
 
 using namespace OpenRCT2;
 
@@ -39,18 +40,19 @@ public:
     std::string GetDirectoryPath(DIRBASE base, DIRID did) const override
     {
         auto basePath = GetDirectoryPath(base);
-        const utf8 * directoryName;
+        const utf8* directoryName;
-        switch (base) {
+        switch (base)
-        default:
+        {
-        case DIRBASE::RCT1:
+            default:
-        case DIRBASE::RCT2:
+            case DIRBASE::RCT1:
-            directoryName = DirectoryNamesRCT2[(size_t)did];
+            case DIRBASE::RCT2:
-            break;
+                directoryName = DirectoryNamesRCT2[(size_t)did];
-        case DIRBASE::OPENRCT2:
+                break;
-        case DIRBASE::USER:
+            case DIRBASE::OPENRCT2:
-        case DIRBASE::CONFIG:
+            case DIRBASE::USER:
-            directoryName = DirectoryNamesOpenRCT2[(size_t)did];
+            case DIRBASE::CONFIG:
-            break;
+                directoryName = DirectoryNamesOpenRCT2[(size_t)did];
+                break;
         }
 
         return Path::Combine(basePath, directoryName);
@@ -64,40 +66,40 @@ public:
         return Path::Combine(basePath, fileName);
     }
 
-    void SetBasePath(DIRBASE base, const std::string &path) override
+    void SetBasePath(DIRBASE base, const std::string& path) override
     {
         _basePath[(size_t)base] = path;
     }
 
 private:
-    static const char * DirectoryNamesRCT2[];
+    static const char* DirectoryNamesRCT2[];
-    static const char * DirectoryNamesOpenRCT2[];
+    static const char* DirectoryNamesOpenRCT2[];
-    static const char * FileNames[];
+    static const char* FileNames[];
 
     static DIRBASE GetDefaultBaseDirectory(PATHID pathid)
     {
         switch (pathid)
         {
-        case PATHID::CONFIG:
+            case PATHID::CONFIG:
-        case PATHID::CONFIG_KEYBOARD:
+            case PATHID::CONFIG_KEYBOARD:
-            return DIRBASE::CONFIG;
+                return DIRBASE::CONFIG;
-        case PATHID::CACHE_OBJECTS:
+            case PATHID::CACHE_OBJECTS:
-        case PATHID::CACHE_TRACKS:
+            case PATHID::CACHE_TRACKS:
-        case PATHID::CACHE_SCENARIOS:
+            case PATHID::CACHE_SCENARIOS:
-            return DIRBASE::CACHE;
+                return DIRBASE::CACHE;
-        case PATHID::MP_DAT:
+            case PATHID::MP_DAT:
-            return DIRBASE::RCT1;
+                return DIRBASE::RCT1;
-        case PATHID::SCORES_RCT2:
+            case PATHID::SCORES_RCT2:
-            return DIRBASE::RCT2;
+                return DIRBASE::RCT2;
-        case PATHID::CHANGELOG:
+            case PATHID::CHANGELOG:
-            return DIRBASE::DOCUMENTATION;
+                return DIRBASE::DOCUMENTATION;
-        case PATHID::NETWORK_GROUPS:
+            case PATHID::NETWORK_GROUPS:
-        case PATHID::NETWORK_SERVERS:
+            case PATHID::NETWORK_SERVERS:
-        case PATHID::NETWORK_USERS:
+            case PATHID::NETWORK_USERS:
-        case PATHID::SCORES:
+            case PATHID::SCORES:
-        case PATHID::SCORES_LEGACY:
+            case PATHID::SCORES_LEGACY:
-        default:
+            default:
-            return DIRBASE::USER;
+                return DIRBASE::USER;
         }
     }
 };

src/openrct2/PlatformEnvironment.h

@@ -9,58 +9,59 @@
 
 #pragma once
 
+#include "common.h"
+
 #include <memory>
 #include <string>
-#include "common.h"
 
 namespace OpenRCT2
 {
     enum class DIRBASE : int32_t
     {
-        RCT1,               // Base directory for original RollerCoaster Tycoon 1 content.
+        RCT1,          // Base directory for original RollerCoaster Tycoon 1 content.
-        RCT2,               // Base directory for original RollerCoaster Tycoon 2 content.
+        RCT2,          // Base directory for original RollerCoaster Tycoon 2 content.
-        OPENRCT2,           // Base directory for OpenRCT2 installation.
+        OPENRCT2,      // Base directory for OpenRCT2 installation.
-        USER,               // Base directory for OpenRCT2 user content.
+        USER,          // Base directory for OpenRCT2 user content.
-        CONFIG,             // Base directory for OpenRCT2 configuration.
+        CONFIG,        // Base directory for OpenRCT2 configuration.
-        CACHE,              // Base directory for OpenRCT2 cache files.
+        CACHE,         // Base directory for OpenRCT2 cache files.
-        DOCUMENTATION,      // Base directory for OpenRCT2 doc files.
+        DOCUMENTATION, // Base directory for OpenRCT2 doc files.
     };
     constexpr int32_t DIRBASE_COUNT = 7;
     using DIRBASE_VALUES = std::string[DIRBASE_COUNT];
 
     enum class DIRID
     {
-        DATA,               // Contains g1.dat, music etc.
+        DATA,        // Contains g1.dat, music etc.
-        LANDSCAPE,          // Contains scenario editor landscapes (SC6).
+        LANDSCAPE,   // Contains scenario editor landscapes (SC6).
-        LANGUAGE,           // Contains language packs.
+        LANGUAGE,    // Contains language packs.
-        LOG_CHAT,           // Contains chat logs.
+        LOG_CHAT,    // Contains chat logs.
-        LOG_SERVER,         // Contains server logs.
+        LOG_SERVER,  // Contains server logs.
-        NETWORK_KEY,        // Contains the user's public and private keys.
+        NETWORK_KEY, // Contains the user's public and private keys.
-        OBJECT,             // Contains objects.
+        OBJECT,      // Contains objects.
-        SAVE,               // Contains saved games (SV6).
+        SAVE,        // Contains saved games (SV6).
-        SCENARIO,           // Contains scenarios (SC6).
+        SCENARIO,    // Contains scenarios (SC6).
-        SCREENSHOT,         // Contains screenshots.
+        SCREENSHOT,  // Contains screenshots.
-        SEQUENCE,           // Contains title sequences.
+        SEQUENCE,    // Contains title sequences.
-        SHADER,             // Contains OpenGL shaders.
+        SHADER,      // Contains OpenGL shaders.
-        THEME,              // Contains interface themes.
+        THEME,       // Contains interface themes.
-        TRACK,              // Contains track designs.
+        TRACK,       // Contains track designs.
     };
 
     enum class PATHID
     {
-        CONFIG,             // Main configuration (config.ini).
+        CONFIG,          // Main configuration (config.ini).
-        CONFIG_KEYBOARD,    // Keyboard shortcuts. (hotkeys.cfg)
+        CONFIG_KEYBOARD, // Keyboard shortcuts. (hotkeys.cfg)
-        CACHE_OBJECTS,      // Object repository cache (objects.idx).
+        CACHE_OBJECTS,   // Object repository cache (objects.idx).
-        CACHE_TRACKS,       // Track repository cache (tracks.idx).
+        CACHE_TRACKS,    // Track repository cache (tracks.idx).
-        CACHE_SCENARIOS,    // Scenario repository cache (scenarios.idx).
+        CACHE_SCENARIOS, // Scenario repository cache (scenarios.idx).
-        MP_DAT,             // Mega Park data, Steam RCT1 only (\RCTdeluxe_install\Data\mp.dat)
+        MP_DAT,          // Mega Park data, Steam RCT1 only (\RCTdeluxe_install\Data\mp.dat)
-        NETWORK_GROUPS,     // Server groups with permissions (groups.json).
+        NETWORK_GROUPS,  // Server groups with permissions (groups.json).
-        NETWORK_SERVERS,    // Saved servers (servers.cfg).
+        NETWORK_SERVERS, // Saved servers (servers.cfg).
-        NETWORK_USERS,      // Users and their groups (users.json).
+        NETWORK_USERS,   // Users and their groups (users.json).
-        SCORES,             // Scenario scores (highscores.dat).
+        SCORES,          // Scenario scores (highscores.dat).
-        SCORES_LEGACY,      // Scenario scores, legacy (scores.dat).
+        SCORES_LEGACY,   // Scenario scores, legacy (scores.dat).
-        SCORES_RCT2,        // Scenario scores, rct2 (\Saved Games\scores.dat).
+        SCORES_RCT2,     // Scenario scores, rct2 (\Saved Games\scores.dat).
-        CHANGELOG,          // Notable changes to the game between versions, distributed with the game.
+        CHANGELOG,       // Notable changes to the game between versions, distributed with the game.
     };
 
     /**
@@ -73,7 +74,7 @@ namespace OpenRCT2
         virtual std::string GetDirectoryPath(DIRBASE base) const abstract;
         virtual std::string GetDirectoryPath(DIRBASE base, DIRID did) const abstract;
         virtual std::string GetFilePath(PATHID pathid) const abstract;
-        virtual void SetBasePath(DIRBASE base, const std::string &path) abstract;
+        virtual void SetBasePath(DIRBASE base, const std::string& path) abstract;
     };
 
     std::unique_ptr<IPlatformEnvironment> CreatePlatformEnvironment(DIRBASE_VALUES basePaths);

src/openrct2/Version.cpp

@@ -7,22 +7,22 @@
  * OpenRCT2 is licensed under the GNU General Public License version 3.
  *****************************************************************************/
 
-#include <string>
 #include "Version.h"
 
+#include <string>
+
 #ifdef OPENRCT2_BUILD_INFO_HEADER
 #include OPENRCT2_BUILD_INFO_HEADER
 #endif
 
-const char gVersionInfoFull[] =
+const char gVersionInfoFull[] = OPENRCT2_NAME ", "
-    OPENRCT2_NAME ", "
 #ifdef OPENRCT2_VERSION_TAG
     OPENRCT2_VERSION_TAG
 #else
-    "v" OPENRCT2_VERSION
+                                              "v" OPENRCT2_VERSION
 #endif
 #if defined(OPENRCT2_BRANCH) || defined(OPENRCT2_COMMIT_SHA1_SHORT) || !defined(NDEBUG)
-    " ("
+                                              " ("
 #if defined(OPENRCT2_BRANCH) && defined(OPENRCT2_COMMIT_SHA1_SHORT)
     OPENRCT2_COMMIT_SHA1_SHORT " on " OPENRCT2_BRANCH
 #elif defined(OPENRCT2_COMMIT_SHA1_SHORT)
@@ -31,11 +31,11 @@ const char gVersionInfoFull[] =
     OPENRCT2_BRANCH
 #endif
 #ifndef NDEBUG
-    ", DEBUG"
+                                              ", DEBUG"
 #endif
-    ")"
+                                              ")"
 #endif
 #ifdef OPENRCT2_BUILD_SERVER
-    " provided by " OPENRCT2_BUILD_SERVER
+                                              " provided by " OPENRCT2_BUILD_SERVER
 #endif
     ;

src/openrct2/Version.h

@@ -11,60 +11,60 @@
 
 #include "common.h"
 
-#define OPENRCT2_NAME               "OpenRCT2"
+#define OPENRCT2_NAME "OpenRCT2"
-#define OPENRCT2_VERSION            "0.2.0"
+#define OPENRCT2_VERSION "0.2.0"
 
 #if defined(__amd64__) || defined(_M_AMD64)
-    #define OPENRCT2_ARCHITECTURE       "x86-64"
+#define OPENRCT2_ARCHITECTURE "x86-64"
 #elif defined(__i386__) || defined(_M_IX86)
-    #define OPENRCT2_ARCHITECTURE       "x86"
+#define OPENRCT2_ARCHITECTURE "x86"
 #elif defined(__aarch64__)
-    #define OPENRCT2_ARCHITECTURE       "AArch64"
+#define OPENRCT2_ARCHITECTURE "AArch64"
 #elif defined(__arm__) || defined(_M_ARM)
-    #if defined(__ARM_ARCH_7A__)
+#if defined(__ARM_ARCH_7A__)
-        #define OPENRCT2_ARCHITECTURE   "arm-v7a"
+#define OPENRCT2_ARCHITECTURE "arm-v7a"
-    #else
+#else
-        #define OPENRCT2_ARCHITECTURE   "arm"
+#define OPENRCT2_ARCHITECTURE "arm"
-    #endif
+#endif
 #elif defined(__powerpc__) || defined(_M_PPC)
-    #define OPENRCT2_ARCHITECTURE       "PowerPC"
+#define OPENRCT2_ARCHITECTURE "PowerPC"
 #elif defined(__mips64)
-    #define OPENRCT2_ARCHITECTURE       "mips64"
+#define OPENRCT2_ARCHITECTURE "mips64"
 #elif defined(__mips__)
-    #define OPENRCT2_ARCHITECTURE       "mips"
+#define OPENRCT2_ARCHITECTURE "mips"
 #endif
 #ifdef __EMSCRIPTEN__
-    #define OPENRCT2_ARCHITECTURE       "Emscripten"
+#define OPENRCT2_ARCHITECTURE "Emscripten"
 #endif
 
 #ifndef OPENRCT2_ARCHITECTURE
-    #error "OPENRCT2_ARCHITECTURE is undefined. Please add identification."
+#error "OPENRCT2_ARCHITECTURE is undefined. Please add identification."
 #endif
 
 // Platform
 #ifdef _WIN32
-    #define OPENRCT2_PLATFORM       "Windows"
+#define OPENRCT2_PLATFORM "Windows"
 #endif
 #if defined(__linux__) && !defined(__ANDROID__)
-    #define OPENRCT2_PLATFORM       "Linux"
+#define OPENRCT2_PLATFORM "Linux"
 #endif
 #if (defined(__APPLE__) && defined(__MACH__))
-    #define OPENRCT2_PLATFORM       "macOS"
+#define OPENRCT2_PLATFORM "macOS"
 #endif
 #ifdef __FreeBSD__
-    #define OPENRCT2_PLATFORM       "FreeBSD"
+#define OPENRCT2_PLATFORM "FreeBSD"
 #endif
 #ifdef __ANDROID__
-    #define OPENRCT2_PLATFORM       "Android"
+#define OPENRCT2_PLATFORM "Android"
 #endif
 #ifdef __OpenBSD__
-    #define OPENRCT2_PLATFORM       "OpenBSD"
+#define OPENRCT2_PLATFORM "OpenBSD"
 #endif
 #ifdef __EMSCRIPTEN__
-    #define OPENRCT2_PLATFORM       "Emscripten"
+#define OPENRCT2_PLATFORM "Emscripten"
 #endif
 #ifndef OPENRCT2_PLATFORM
-    #error Unknown platform!
+#error Unknown platform!
 #endif
 
 #ifndef OPENRCT2_CUSTOM_INFO

src/openrct2/common.h

@@ -19,14 +19,14 @@
 #include <ctime>
 #endif
 
+#include "Diagnostic.h"
+
 #include <cassert>
 #include <cstdint>
 
-#include "Diagnostic.h"
+using utf8 = char;
-
+using utf8string = utf8*;
-using utf8             = char;
+using const_utf8string = const utf8*;
-using utf8string       = utf8 *;
-using const_utf8string = const utf8 *;
 #ifdef _WIN32
 using utf16 = wchar_t;
 using utf16string = utf16*;
@@ -41,20 +41,20 @@ using utf16string = utf16*;
 using codepoint_t = uint32_t;
 using colour_t = uint8_t;
 
-#define rol8(x, shift)      (((uint8_t)(x) << (shift)) | ((uint8_t)(x) >> (8 - (shift))))
+#define rol8(x, shift) (((uint8_t)(x) << (shift)) | ((uint8_t)(x) >> (8 - (shift))))
-#define ror8(x, shift)      (((uint8_t)(x) >> (shift)) | ((uint8_t)(x) << (8 - (shift))))
+#define ror8(x, shift) (((uint8_t)(x) >> (shift)) | ((uint8_t)(x) << (8 - (shift))))
-#define rol16(x, shift)     (((uint16_t)(x) << (shift)) | ((uint16_t)(x) >> (16 - (shift))))
+#define rol16(x, shift) (((uint16_t)(x) << (shift)) | ((uint16_t)(x) >> (16 - (shift))))
-#define ror16(x, shift)     (((uint16_t)(x) >> (shift)) | ((uint16_t)(x) << (16 - (shift))))
+#define ror16(x, shift) (((uint16_t)(x) >> (shift)) | ((uint16_t)(x) << (16 - (shift))))
-#define rol32(x, shift)     (((uint32_t)(x) << (shift)) | ((uint32_t)(x) >> (32 - (shift))))
+#define rol32(x, shift) (((uint32_t)(x) << (shift)) | ((uint32_t)(x) >> (32 - (shift))))
-#define ror32(x, shift)     (((uint32_t)(x) >> (shift)) | ((uint32_t)(x) << (32 - (shift))))
+#define ror32(x, shift) (((uint32_t)(x) >> (shift)) | ((uint32_t)(x) << (32 - (shift))))
-#define rol64(x, shift)     (((uint64_t)(x) << (shift)) | ((uint64_t)(x) >> (64 - (shift))))
+#define rol64(x, shift) (((uint64_t)(x) << (shift)) | ((uint64_t)(x) >> (64 - (shift))))
-#define ror64(x, shift)     (((uint64_t)(x) >> (shift)) | ((uint64_t)(x) << (64 - (shift))))
+#define ror64(x, shift) (((uint64_t)(x) >> (shift)) | ((uint64_t)(x) << (64 - (shift))))
 
 // Rounds an integer down to the given power of 2. y must be a power of 2.
-#define floor2(x, y)        ((x) & (~((y) - 1)))
+#define floor2(x, y) ((x) & (~((y)-1)))
 
 // Rounds an integer up to the given power of 2. y must be a power of 2.
-#define ceil2(x, y)         (((x) + (y) - 1) & (~((y) - 1)))
+#define ceil2(x, y) (((x) + (y)-1) & (~((y)-1)))
 
 // Gets the name of a symbol as a C string
 #define nameof(symbol) #symbol
@@ -70,7 +70,7 @@ using colour_t = uint8_t;
 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
 #define RCT2_ENDIANESS __ORDER_LITTLE_ENDIAN__
 #define LOBYTE(w) ((uint8_t)(w))
-#define HIBYTE(w) ((uint8_t)(((uint16_t)(w)>>8)&0xFF))
+#define HIBYTE(w) ((uint8_t)(((uint16_t)(w) >> 8) & 0xFF))
 #endif // __BYTE_ORDER__
 
 #ifndef RCT2_ENDIANESS
@@ -79,8 +79,10 @@ using colour_t = uint8_t;
 
 #endif // defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
 
-#if !((defined (_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200809L) || (defined(_XOPEN_SOURCE) && _XOPEN_SOURCE >= 700) || (defined(__APPLE__) && defined(__MACH__)) || defined(__ANDROID_API__) || defined(__FreeBSD__))
+#if !(                                                                                                                         \
-char *strndup(const char *src, size_t size);
+    (defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200809L) || (defined(_XOPEN_SOURCE) && _XOPEN_SOURCE >= 700)               \
+    || (defined(__APPLE__) && defined(__MACH__)) || defined(__ANDROID_API__) || defined(__FreeBSD__))
+char* strndup(const char* src, size_t size);
 #endif // !(POSIX_C_SOURCE >= 200809L || _XOPEN_SOURCE >= 700)
 
 // BSD and macOS have MAP_ANON instead of MAP_ANONYMOUS
@@ -88,7 +90,7 @@ char *strndup(const char *src, size_t size);
 #define MAP_ANONYMOUS MAP_ANON
 #endif
 
-#define OPENRCT2_MASTER_SERVER_URL  "https://servers.openrct2.io"
+#define OPENRCT2_MASTER_SERVER_URL "https://servers.openrct2.io"
 
 // Time (represented as number of 100-nanosecond intervals since 0001-01-01T00:00:00Z)
 using datetime64 = uint64_t;
@@ -112,36 +114,51 @@ using money64 = fixed64_1dp;
 
 // Construct a fixed point number. For example, to create the value 3.65 you
 // would write FIXED_2DP(3,65)
-#define FIXED_XDP(x, whole, fraction)   ((whole) * (10 * (x)) + (fraction))
+#define FIXED_XDP(x, whole, fraction) ((whole) * (10 * (x)) + (fraction))
-#define FIXED_1DP(whole, fraction)      FIXED_XDP(1, whole, fraction)
+#define FIXED_1DP(whole, fraction) FIXED_XDP(1, whole, fraction)
-#define FIXED_2DP(whole, fraction)      FIXED_XDP(10, whole, fraction)
+#define FIXED_2DP(whole, fraction) FIXED_XDP(10, whole, fraction)
 
 // Construct a money value in the format MONEY(10,70) to represent 10.70. Fractional part must be two digits.
-#define MONEY(whole, fraction)          ((whole) * 10 + ((fraction) / 10))
+#define MONEY(whole, fraction) ((whole)*10 + ((fraction) / 10))
 
-#define MONEY_FREE                      MONEY(0,00)
+#define MONEY_FREE MONEY(0, 00)
-#define MONEY16_UNDEFINED               (money16)(uint16_t)0xFFFF
+#define MONEY16_UNDEFINED (money16)(uint16_t) 0xFFFF
-#define MONEY32_UNDEFINED               ((money32)0x80000000)
+#define MONEY32_UNDEFINED ((money32)0x80000000)
 
 using BannerIndex = uint8_t;
 
 using EMPTY_ARGS_VOID_POINTER = void();
-using rct_string_id           = uint16_t;
+using rct_string_id = uint16_t;
 
-#define SafeFree(x) do { free(x); (x) = nullptr; } while (false)
+#define SafeFree(x)                                                                                                            \
+    do                                                                                                                         \
+    {                                                                                                                          \
+        free(x);                                                                                                               \
+        (x) = nullptr;                                                                                                         \
+    } while (false)
 
-#define SafeDelete(x) do { delete (x); (x) = nullptr; } while (false)
+#define SafeDelete(x)                                                                                                          \
-#define SafeDeleteArray(x) do { delete[] (x); (x) = nullptr; } while (false)
+    do                                                                                                                         \
+    {                                                                                                                          \
+        delete (x);                                                                                                            \
+        (x) = nullptr;                                                                                                         \
+    } while (false)
+#define SafeDeleteArray(x)                                                                                                     \
+    do                                                                                                                         \
+    {                                                                                                                          \
+        delete[](x);                                                                                                           \
+        (x) = nullptr;                                                                                                         \
+    } while (false)
 
 #ifndef interface
-    #define interface struct
+#define interface struct
 #endif
 #define abstract = 0
 
 #if defined(__GNUC__) && (defined(__x86_64__) || defined(__i386__))
-    #define OPENRCT2_X86
+#define OPENRCT2_X86
 #elif defined(_MSC_VER) && (_MSC_VER >= 1500) && (defined(_M_X64) || defined(_M_IX86)) // VS2008
-    #define OPENRCT2_X86
+#define OPENRCT2_X86
 #endif
 
 #if defined(__i386__) || defined(_M_IX86)
@@ -149,9 +166,9 @@ using rct_string_id           = uint16_t;
 #endif
 
 #if defined(__LP64__) || defined(_WIN64)
-    #define PLATFORM_64BIT
+#define PLATFORM_64BIT
 #else
-    #define PLATFORM_32BIT
+#define PLATFORM_32BIT
 #endif
 
 // C99's restrict keywords guarantees the pointer in question, for the whole of its lifetime,
@@ -159,74 +176,86 @@ using rct_string_id           = uint16_t;
 // aliasing the same memory area. Using it lets compiler generate better code. If your compiler
 // does not support it, feel free to drop it, at some performance hit.
 #ifdef _MSC_VER
-    #define RESTRICT __restrict
+#define RESTRICT __restrict
 #else
-    #define RESTRICT __restrict__
+#define RESTRICT __restrict__
 #endif
 
 #define assert_struct_size(x, y) static_assert(sizeof(x) == (y), "Improper struct size")
 
 #ifdef PLATFORM_X86
-    #ifndef FASTCALL
+#ifndef FASTCALL
-        #ifdef __GNUC__
+#ifdef __GNUC__
-            #define FASTCALL __attribute__((fastcall))
+#define FASTCALL __attribute__((fastcall))
-        #elif defined(_MSC_VER)
+#elif defined(_MSC_VER)
-            #define FASTCALL __fastcall
+#define FASTCALL __fastcall
-        #else
+#else
-            #pragma message "Not using fastcall calling convention, please check your compiler support"
+#pragma message "Not using fastcall calling convention, please check your compiler support"
-            #define FASTCALL
+#define FASTCALL
-        #endif
+#endif
-    #endif // FASTCALL
+#endif // FASTCALL
-#else // PLATFORM_X86
+#else  // PLATFORM_X86
-    #define FASTCALL
+#define FASTCALL
 #endif // PLATFORM_X86
 
 /**
  * x86 register structure, only used for easy interop to RCT2 code.
  */
 #pragma pack(push, 1)
-struct registers {
+struct registers
-    union {
+{
+    union
+    {
         int32_t eax;
         int16_t ax;
-        struct {
+        struct
+        {
             char al;
             char ah;
         };
     };
-    union {
+    union
+    {
         int32_t ebx;
         int16_t bx;
-        struct {
+        struct
+        {
             char bl;
             char bh;
         };
     };
-    union {
+    union
+    {
         int32_t ecx;
         int16_t cx;
-        struct {
+        struct
+        {
             char cl;
             char ch;
         };
     };
-    union {
+    union
+    {
         int32_t edx;
         int16_t dx;
-        struct {
+        struct
+        {
             char dl;
             char dh;
         };
     };
-    union {
+    union
+    {
         int32_t esi;
         int16_t si;
     };
-    union {
+    union
+    {
         int32_t edi;
         int16_t di;
     };
-    union {
+    union
+    {
         int32_t ebp;
         int16_t bp;
     };

src/openrct2/sprites.h

@@ -12,7 +12,8 @@
 
 #include "rct1/RCT1.h"
 
-enum {
+enum
+{
     SPR_NONE = -1,
 
     // Used for on-demand drawing of dynamic memory
@@ -27,8 +28,8 @@ enum {
     SPR_EDGE_ICE_BASE = 1831,
 
     SPR_TERRAIN_SELECTION_SQUARE_SIMPLE = 2624, // Used for showing peep spawn
-    SPR_TERRAIN_SELECTION_SQUARE = 2625, // Used to show land owned by park
+    SPR_TERRAIN_SELECTION_SQUARE = 2625,        // Used to show land owned by park
-    SPR_TERRAIN_SELECTION_DOTTED = 2644, // Used to show construction rights owned by park
+    SPR_TERRAIN_SELECTION_DOTTED = 2644,        // Used to show construction rights owned by park
 
     SPR_PALETTE_1_START = 3100,
     SPR_PALETTE_1_END = 3110,
@@ -313,7 +314,6 @@ enum {
     SPR_TAB_GUEST_INVENTORY = 5326,
     SPR_TAB_FINANCES_RESEARCH_0 = 5327,
 
-
     SPR_TAB_MUSIC_0 = 5335,
 
     SPR_TAB_SHOPS_AND_STALLS_0 = 5351,
@@ -802,20 +802,20 @@ enum {
 
     SPR_G2_MINIATURE_RAILWAY_QUARTER_TURN_3_TILES_SW_SE_PART_3 = SPR_G2_BEGIN + 93,
 
-    SPR_G2_MINIATURE_RAILWAY_BEGIN              = SPR_G2_BEGIN + 94,
+    SPR_G2_MINIATURE_RAILWAY_BEGIN = SPR_G2_BEGIN + 94,
-    SPR_G2_MINIATURE_RAILWAY_GRAVEL_SW_NE       = SPR_G2_MINIATURE_RAILWAY_BEGIN + 0,
+    SPR_G2_MINIATURE_RAILWAY_GRAVEL_SW_NE = SPR_G2_MINIATURE_RAILWAY_BEGIN + 0,
-    SPR_G2_MINIATURE_RAILWAY_GRAVEL_NW_SE       = SPR_G2_MINIATURE_RAILWAY_BEGIN + 1,
+    SPR_G2_MINIATURE_RAILWAY_GRAVEL_NW_SE = SPR_G2_MINIATURE_RAILWAY_BEGIN + 1,
-    SPR_G2_MINIATURE_RAILWAY_GROOVED_SW_NE      = SPR_G2_MINIATURE_RAILWAY_BEGIN + 2,
+    SPR_G2_MINIATURE_RAILWAY_GROOVED_SW_NE = SPR_G2_MINIATURE_RAILWAY_BEGIN + 2,
-    SPR_G2_MINIATURE_RAILWAY_GROOVED_NW_SE      = SPR_G2_MINIATURE_RAILWAY_BEGIN + 3,
+    SPR_G2_MINIATURE_RAILWAY_GROOVED_NW_SE = SPR_G2_MINIATURE_RAILWAY_BEGIN + 3,
-    SPR_G2_MINIATURE_RAILWAY_INSET_SW_NE        = SPR_G2_MINIATURE_RAILWAY_BEGIN + 4,
+    SPR_G2_MINIATURE_RAILWAY_INSET_SW_NE = SPR_G2_MINIATURE_RAILWAY_BEGIN + 4,
-    SPR_G2_MINIATURE_RAILWAY_INSET_NW_SE        = SPR_G2_MINIATURE_RAILWAY_BEGIN + 5,
+    SPR_G2_MINIATURE_RAILWAY_INSET_NW_SE = SPR_G2_MINIATURE_RAILWAY_BEGIN + 5,
-    SPR_G2_MINIATURE_RAILWAY_INSET_END_NE       = SPR_G2_MINIATURE_RAILWAY_BEGIN + 6,
+    SPR_G2_MINIATURE_RAILWAY_INSET_END_NE = SPR_G2_MINIATURE_RAILWAY_BEGIN + 6,
-    SPR_G2_MINIATURE_RAILWAY_INSET_END_SE       = SPR_G2_MINIATURE_RAILWAY_BEGIN + 7,
+    SPR_G2_MINIATURE_RAILWAY_INSET_END_SE = SPR_G2_MINIATURE_RAILWAY_BEGIN + 7,
-    SPR_G2_MINIATURE_RAILWAY_INSET_END_NW       = SPR_G2_MINIATURE_RAILWAY_BEGIN + 8,
+    SPR_G2_MINIATURE_RAILWAY_INSET_END_NW = SPR_G2_MINIATURE_RAILWAY_BEGIN + 8,
-    SPR_G2_MINIATURE_RAILWAY_INSET_END_SW       = SPR_G2_MINIATURE_RAILWAY_BEGIN + 9,
+    SPR_G2_MINIATURE_RAILWAY_INSET_END_SW = SPR_G2_MINIATURE_RAILWAY_BEGIN + 9,
-    SPR_G2_MINIATURE_RAILWAY_INSET_END_SW_NE    = SPR_G2_MINIATURE_RAILWAY_BEGIN + 10,
+    SPR_G2_MINIATURE_RAILWAY_INSET_END_SW_NE = SPR_G2_MINIATURE_RAILWAY_BEGIN + 10,
-    SPR_G2_MINIATURE_RAILWAY_INSET_END_NW_SE    = SPR_G2_MINIATURE_RAILWAY_BEGIN + 11,
+    SPR_G2_MINIATURE_RAILWAY_INSET_END_NW_SE = SPR_G2_MINIATURE_RAILWAY_BEGIN + 11,
-    SPR_G2_MINIATURE_RAILWAY_LAST               = SPR_G2_BEGIN + 105,
+    SPR_G2_MINIATURE_RAILWAY_LAST = SPR_G2_BEGIN + 105,
 
     SPR_G2_SEARCH = SPR_G2_BEGIN + 106,
 
@@ -837,7 +837,7 @@ enum {
     SPR_G2_WALL_TEXTURE_STONE_GREY = SPR_G2_BEGIN + 120,
     SPR_G2_WALL_TEXTURE_SKYSCRAPER_A = SPR_G2_BEGIN + 121,
     SPR_G2_WALL_TEXTURE_SKYSCRAPER_B = SPR_G2_BEGIN + 122,
-    
+
     SPR_G2_EYEDROPPER = SPR_G2_BEGIN + 123,
 
     SPR_G2_CHAR_BEGIN = SPR_G2_BEGIN + 124,