mirrors
/
OpenRCT2
mirror of https://github.com/OpenRCT2/OpenRCT2.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

Move cheats to struct in GameState_t

This commit is contained in:
Duncan 2024-03-03 21:44:15 +00:00 committed by GitHub
parent 4ccecd6e68
commit 4b6ba80a46
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
76 changed files with 561 additions and 487 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/openrct2-ui/input/Shortcuts.cpp
View File

@ -619,7 +619,8 @@ static void ShortcutDecreaseElementHeight()
static void ShortcutToggleClearanceChecks() static void ShortcutToggleClearanceChecks()
{ {
auto cheatSetAction = CheatSetAction(CheatType::DisableClearanceChecks, gCheatsDisableClearanceChecks ? 0 : 1); auto cheatSetAction = CheatSetAction(
CheatType::DisableClearanceChecks, GetGameState().Cheats.DisableClearanceChecks ? 0 : 1);
GameActions::Execute(&cheatSetAction); GameActions::Execute(&cheatSetAction);
} }

4
src/openrct2-ui/interface/ViewportInteraction.cpp
View File

@ -364,7 +364,7 @@ InteractionInfo ViewportInteractionGetItemRight(const ScreenCoordsXY& screenCoor
else else
{ {
// FIXME: Why does it *2 the value? // FIXME: Why does it *2 the value?
if (!gCheatsSandboxMode && !MapIsLocationOwned({ info.Loc, tileElement->GetBaseZ() * 2 })) if (!GetGameState().Cheats.SandboxMode && !MapIsLocationOwned({ info.Loc, tileElement->GetBaseZ() * 2 }))
{ {
info.SpriteType = ViewportInteractionItem::None; info.SpriteType = ViewportInteractionItem::None;
return info; return info;
@ -494,7 +494,7 @@ InteractionInfo ViewportInteractionGetItemRight(const ScreenCoordsXY& screenCoor
return info; return info;
} }
case ViewportInteractionItem::ParkEntrance: case ViewportInteractionItem::ParkEntrance:
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !gCheatsSandboxMode) if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !GetGameState().Cheats.SandboxMode)
break; break;
if (tileElement->GetType() != TileElementType::Entrance) if (tileElement->GetType() != TileElementType::Entrance)

118
src/openrct2-ui/windows/Cheats.cpp
View File

@ -474,44 +474,43 @@ public:
{ {
auto ft = Formatter::Common(); auto ft = Formatter::Common();
ft.Add<money64>(1000.00_GBP); ft.Add<money64>(1000.00_GBP);
SetCheckboxValue(WIDX_GUEST_IGNORE_RIDE_INTENSITY, gCheatsIgnoreRideIntensity); SetCheckboxValue(WIDX_GUEST_IGNORE_RIDE_INTENSITY, gameState.Cheats.IgnoreRideIntensity);
SetCheckboxValue(WIDX_DISABLE_VANDALISM, gCheatsDisableVandalism); SetCheckboxValue(WIDX_DISABLE_VANDALISM, gameState.Cheats.DisableVandalism);
SetCheckboxValue(WIDX_DISABLE_LITTERING, gCheatsDisableLittering); SetCheckboxValue(WIDX_DISABLE_LITTERING, gameState.Cheats.DisableLittering);
break; break;
} }
case WINDOW_CHEATS_PAGE_MISC: case WINDOW_CHEATS_PAGE_MISC:
widgets[WIDX_OPEN_CLOSE_PARK].text = (gameState.ParkFlags & PARK_FLAGS_PARK_OPEN) ? STR_CHEAT_CLOSE_PARK widgets[WIDX_OPEN_CLOSE_PARK].text = (gameState.ParkFlags & PARK_FLAGS_PARK_OPEN) ? STR_CHEAT_CLOSE_PARK
: STR_CHEAT_OPEN_PARK; : STR_CHEAT_OPEN_PARK;
SetCheckboxValue(WIDX_FORCE_PARK_RATING, ParkGetForcedRating() >= 0); SetCheckboxValue(WIDX_FORCE_PARK_RATING, ParkGetForcedRating() >= 0);
SetCheckboxValue(WIDX_FREEZE_WEATHER, gCheatsFreezeWeather); SetCheckboxValue(WIDX_FREEZE_WEATHER, gameState.Cheats.FreezeWeather);
SetCheckboxValue(WIDX_NEVERENDING_MARKETING, gCheatsNeverendingMarketing); SetCheckboxValue(WIDX_NEVERENDING_MARKETING, gameState.Cheats.NeverendingMarketing);
SetCheckboxValue(WIDX_DISABLE_PLANT_AGING, gCheatsDisablePlantAging); SetCheckboxValue(WIDX_DISABLE_PLANT_AGING, gameState.Cheats.DisablePlantAging);
SetCheckboxValue(WIDX_ALLOW_REGULAR_PATH_AS_QUEUE, gCheatsAllowRegularPathAsQueue); SetCheckboxValue(WIDX_ALLOW_REGULAR_PATH_AS_QUEUE, gameState.Cheats.AllowRegularPathAsQueue);
SetCheckboxValue(WIDX_ALLOW_SPECIAL_COLOUR_SCHEMES, gCheatsAllowSpecialColourSchemes); SetCheckboxValue(WIDX_ALLOW_SPECIAL_COLOUR_SCHEMES, gameState.Cheats.AllowSpecialColourSchemes);
break; break;
case WINDOW_CHEATS_PAGE_RIDES: case WINDOW_CHEATS_PAGE_RIDES:
SetCheckboxValue(WIDX_UNLOCK_OPERATING_LIMITS, gCheatsUnlockOperatingLimits); SetCheckboxValue(WIDX_UNLOCK_OPERATING_LIMITS, gameState.Cheats.UnlockOperatingLimits);
SetCheckboxValue(WIDX_DISABLE_BRAKES_FAILURE, gCheatsDisableBrakesFailure); SetCheckboxValue(WIDX_DISABLE_BRAKES_FAILURE, gameState.Cheats.DisableBrakesFailure);
SetCheckboxValue(WIDX_DISABLE_ALL_BREAKDOWNS, gCheatsDisableAllBreakdowns); SetCheckboxValue(WIDX_DISABLE_ALL_BREAKDOWNS, gameState.Cheats.DisableAllBreakdowns);
SetCheckboxValue(WIDX_BUILD_IN_PAUSE_MODE, gCheatsBuildInPauseMode); SetCheckboxValue(WIDX_BUILD_IN_PAUSE_MODE, gameState.Cheats.BuildInPauseMode);
SetCheckboxValue(WIDX_SHOW_ALL_OPERATING_MODES, gCheatsShowAllOperatingModes); SetCheckboxValue(WIDX_SHOW_ALL_OPERATING_MODES, gameState.Cheats.ShowAllOperatingModes);
SetCheckboxValue(WIDX_SHOW_VEHICLES_FROM_OTHER_TRACK_TYPES, gCheatsShowVehiclesFromOtherTrackTypes); SetCheckboxValue(WIDX_SHOW_VEHICLES_FROM_OTHER_TRACK_TYPES, gameState.Cheats.ShowVehiclesFromOtherTrackTypes);
SetCheckboxValue(WIDX_DISABLE_TRAIN_LENGTH_LIMITS, gCheatsDisableTrainLengthLimit); SetCheckboxValue(WIDX_DISABLE_TRAIN_LENGTH_LIMITS, gameState.Cheats.DisableTrainLengthLimit);
SetCheckboxValue(WIDX_ENABLE_CHAIN_LIFT_ON_ALL_TRACK, gCheatsEnableChainLiftOnAllTrack); SetCheckboxValue(WIDX_ENABLE_CHAIN_LIFT_ON_ALL_TRACK, gameState.Cheats.EnableChainLiftOnAllTrack);
SetCheckboxValue(WIDX_ENABLE_ARBITRARY_RIDE_TYPE_CHANGES, gCheatsAllowArbitraryRideTypeChanges); SetCheckboxValue(WIDX_ENABLE_ARBITRARY_RIDE_TYPE_CHANGES, gameState.Cheats.AllowArbitraryRideTypeChanges);
SetCheckboxValue(WIDX_DISABLE_RIDE_VALUE_AGING, gCheatsDisableRideValueAging); SetCheckboxValue(WIDX_DISABLE_RIDE_VALUE_AGING, gameState.Cheats.DisableRideValueAging);
SetCheckboxValue(WIDX_IGNORE_RESEARCH_STATUS, gCheatsIgnoreResearchStatus); SetCheckboxValue(WIDX_IGNORE_RESEARCH_STATUS, gameState.Cheats.IgnoreResearchStatus);
SetCheckboxValue(WIDX_ENABLE_ALL_DRAWABLE_TRACK_PIECES, gCheatsEnableAllDrawableTrackPieces); SetCheckboxValue(WIDX_ENABLE_ALL_DRAWABLE_TRACK_PIECES, gameState.Cheats.EnableAllDrawableTrackPieces);
SetCheckboxValue(WIDX_ALLOW_TRACK_PLACE_INVALID_HEIGHTS, gCheatsAllowTrackPlaceInvalidHeights); SetCheckboxValue(WIDX_ALLOW_TRACK_PLACE_INVALID_HEIGHTS, gameState.Cheats.AllowTrackPlaceInvalidHeights);
SetCheckboxValue(WIDX_MAKE_DESTRUCTIBLE, gCheatsMakeAllDestructible); SetCheckboxValue(WIDX_MAKE_DESTRUCTIBLE, gameState.Cheats.MakeAllDestructible);
break; break;
} }
// Current weather // Current weather
window_cheats_misc_widgets[WIDX_WEATHER].text = WeatherTypes[EnumValue( window_cheats_misc_widgets[WIDX_WEATHER].text = WeatherTypes[EnumValue(gameState.ClimateCurrent.Weather)];
OpenRCT2::GetGameState().ClimateCurrent.Weather)];
// Staff speed // Staff speed
window_cheats_misc_widgets[WIDX_STAFF_SPEED].text = _staffSpeedNames[EnumValue(gCheatsSelectedStaffSpeed)]; window_cheats_misc_widgets[WIDX_STAFF_SPEED].text = _staffSpeedNames[EnumValue(gameState.Cheats.SelectedStaffSpeed)];
if (gScreenFlags & SCREEN_FLAGS_EDITOR) if (gScreenFlags & SCREEN_FLAGS_EDITOR)
{ {
@ -802,6 +801,7 @@ private:
void OnMouseDownMisc(WidgetIndex widgetIndex) void OnMouseDownMisc(WidgetIndex widgetIndex)
{ {
auto* widget = &widgets[widgetIndex]; auto* widget = &widgets[widgetIndex];
auto& gameState = GetGameState();
switch (widgetIndex) switch (widgetIndex)
{ {
case WIDX_INCREASE_PARK_RATING: case WIDX_INCREASE_PARK_RATING:
@ -834,7 +834,7 @@ private:
{ windowPos.x + dropdownWidget->left, windowPos.y + dropdownWidget->top }, dropdownWidget->height() + 1, { windowPos.x + dropdownWidget->left, windowPos.y + dropdownWidget->top }, dropdownWidget->height() + 1,
colours[1], 0, Dropdown::Flag::StayOpen, std::size(WeatherTypes), dropdownWidget->width() - 3); colours[1], 0, Dropdown::Flag::StayOpen, std::size(WeatherTypes), dropdownWidget->width() - 3);
auto currentWeather = OpenRCT2::GetGameState().ClimateCurrent.Weather; auto currentWeather = gameState.ClimateCurrent.Weather;
Dropdown::SetChecked(EnumValue(currentWeather), true); Dropdown::SetChecked(EnumValue(currentWeather), true);
} }
break; break;
@ -853,17 +853,18 @@ private:
WindowDropdownShowTextCustomWidth( WindowDropdownShowTextCustomWidth(
{ windowPos.x + dropdownWidget->left, windowPos.y + dropdownWidget->top }, dropdownWidget->height() + 1, { windowPos.x + dropdownWidget->left, windowPos.y + dropdownWidget->top }, dropdownWidget->height() + 1,
colours[1], 0, Dropdown::Flag::StayOpen, 3, dropdownWidget->width() - 3); colours[1], 0, Dropdown::Flag::StayOpen, 3, dropdownWidget->width() - 3);
Dropdown::SetChecked(EnumValue(gCheatsSelectedStaffSpeed), true); Dropdown::SetChecked(EnumValue(gameState.Cheats.SelectedStaffSpeed), true);
} }
} }
} }
void OnMouseUpMisc(WidgetIndex widgetIndex) void OnMouseUpMisc(WidgetIndex widgetIndex)
{ {
auto& gameState = GetGameState();
switch (widgetIndex) switch (widgetIndex)
{ {
case WIDX_FREEZE_WEATHER: case WIDX_FREEZE_WEATHER:
CheatsSet(CheatType::FreezeWeather, !gCheatsFreezeWeather); CheatsSet(CheatType::FreezeWeather, !gameState.Cheats.FreezeWeather);
break; break;
case WIDX_OPEN_CLOSE_PARK: case WIDX_OPEN_CLOSE_PARK:
CheatsSet(CheatType::OpenClosePark); CheatsSet(CheatType::OpenClosePark);
@ -890,7 +891,7 @@ private:
CheatsSet(CheatType::RemoveLitter); CheatsSet(CheatType::RemoveLitter);
break; break;
case WIDX_DISABLE_PLANT_AGING: case WIDX_DISABLE_PLANT_AGING:
CheatsSet(CheatType::DisablePlantAging, !gCheatsDisablePlantAging); CheatsSet(CheatType::DisablePlantAging, !gameState.Cheats.DisablePlantAging);
break; break;
case WIDX_WIN_SCENARIO: case WIDX_WIN_SCENARIO:
CheatsSet(CheatType::WinScenario); CheatsSet(CheatType::WinScenario);
@ -902,7 +903,7 @@ private:
CheatsSet(CheatType::OwnAllLand); CheatsSet(CheatType::OwnAllLand);
break; break;
case WIDX_NEVERENDING_MARKETING: case WIDX_NEVERENDING_MARKETING:
CheatsSet(CheatType::NeverEndingMarketing, !gCheatsNeverendingMarketing); CheatsSet(CheatType::NeverEndingMarketing, !gameState.Cheats.NeverendingMarketing);
break; break;
case WIDX_FORCE_PARK_RATING: case WIDX_FORCE_PARK_RATING:
if (ParkGetForcedRating() >= 0) if (ParkGetForcedRating() >= 0)
@ -915,10 +916,10 @@ private:
} }
break; break;
case WIDX_ALLOW_REGULAR_PATH_AS_QUEUE: case WIDX_ALLOW_REGULAR_PATH_AS_QUEUE:
CheatsSet(CheatType::AllowRegularPathAsQueue, !gCheatsAllowRegularPathAsQueue); CheatsSet(CheatType::AllowRegularPathAsQueue, !gameState.Cheats.AllowRegularPathAsQueue);
break; break;
case WIDX_ALLOW_SPECIAL_COLOUR_SCHEMES: case WIDX_ALLOW_SPECIAL_COLOUR_SCHEMES:
CheatsSet(CheatType::AllowSpecialColourSchemes, !gCheatsAllowSpecialColourSchemes); CheatsSet(CheatType::AllowSpecialColourSchemes, !gameState.Cheats.AllowSpecialColourSchemes);
break; break;
} }
} }
@ -937,20 +938,21 @@ private:
if (widgetIndex == WIDX_STAFF_SPEED_DROPDOWN_BUTTON) if (widgetIndex == WIDX_STAFF_SPEED_DROPDOWN_BUTTON)
{ {
int32_t speed = kCheatsStaffNormalSpeed; int32_t speed = kCheatsStaffNormalSpeed;
auto& gameState = GetGameState();
switch (dropdownIndex) switch (dropdownIndex)
{ {
case 0: case 0:
gCheatsSelectedStaffSpeed = StaffSpeedCheat::None; gameState.Cheats.SelectedStaffSpeed = StaffSpeedCheat::None;
speed = kCheatsStaffNormalSpeed; speed = kCheatsStaffNormalSpeed;
break; break;
case 1: case 1:
gCheatsSelectedStaffSpeed = StaffSpeedCheat::Frozen; gameState.Cheats.SelectedStaffSpeed = StaffSpeedCheat::Frozen;
speed = kCheatsStaffFreezeSpeed; speed = kCheatsStaffFreezeSpeed;
break; break;
case 2: case 2:
gCheatsSelectedStaffSpeed = StaffSpeedCheat::Fast; gameState.Cheats.SelectedStaffSpeed = StaffSpeedCheat::Fast;
speed = kCheatsStaffFastSpeed; speed = kCheatsStaffFastSpeed;
} }
CheatsSet(CheatType::SetStaffSpeed, speed); CheatsSet(CheatType::SetStaffSpeed, speed);
@ -959,6 +961,7 @@ private:
void OnMouseUpGuests(WidgetIndex widgetIndex) void OnMouseUpGuests(WidgetIndex widgetIndex)
{ {
auto& gameState = GetGameState();
switch (widgetIndex) switch (widgetIndex)
{ {
case WIDX_GUEST_HAPPINESS_MAX: case WIDX_GUEST_HAPPINESS_MAX:
@ -1028,41 +1031,42 @@ private:
CheatsSet(CheatType::GiveAllGuests, OBJECT_UMBRELLA); CheatsSet(CheatType::GiveAllGuests, OBJECT_UMBRELLA);
break; break;
case WIDX_GUEST_IGNORE_RIDE_INTENSITY: case WIDX_GUEST_IGNORE_RIDE_INTENSITY:
CheatsSet(CheatType::IgnoreRideIntensity, !gCheatsIgnoreRideIntensity); CheatsSet(CheatType::IgnoreRideIntensity, !gameState.Cheats.IgnoreRideIntensity);
break; break;
case WIDX_DISABLE_VANDALISM: case WIDX_DISABLE_VANDALISM:
CheatsSet(CheatType::DisableVandalism, !gCheatsDisableVandalism); CheatsSet(CheatType::DisableVandalism, !gameState.Cheats.DisableVandalism);
break; break;
case WIDX_DISABLE_LITTERING: case WIDX_DISABLE_LITTERING:
CheatsSet(CheatType::DisableLittering, !gCheatsDisableLittering); CheatsSet(CheatType::DisableLittering, !gameState.Cheats.DisableLittering);
break; break;
} }
} }
void OnMouseUpRides(WidgetIndex widgetIndex) void OnMouseUpRides(WidgetIndex widgetIndex)
{ {
auto& gameState = GetGameState();
switch (widgetIndex) switch (widgetIndex)
{ {
case WIDX_RENEW_RIDES: case WIDX_RENEW_RIDES:
CheatsSet(CheatType::RenewRides); CheatsSet(CheatType::RenewRides);
break; break;
case WIDX_MAKE_DESTRUCTIBLE: case WIDX_MAKE_DESTRUCTIBLE:
CheatsSet(CheatType::MakeDestructible, !gCheatsMakeAllDestructible); CheatsSet(CheatType::MakeDestructible, !gameState.Cheats.MakeAllDestructible);
break; break;
case WIDX_FIX_ALL: case WIDX_FIX_ALL:
CheatsSet(CheatType::FixRides); CheatsSet(CheatType::FixRides);
break; break;
case WIDX_UNLOCK_OPERATING_LIMITS: case WIDX_UNLOCK_OPERATING_LIMITS:
CheatsSet(CheatType::FastLiftHill, !gCheatsUnlockOperatingLimits); CheatsSet(CheatType::FastLiftHill, !gameState.Cheats.UnlockOperatingLimits);
break; break;
case WIDX_DISABLE_BRAKES_FAILURE: case WIDX_DISABLE_BRAKES_FAILURE:
CheatsSet(CheatType::DisableBrakesFailure, !gCheatsDisableBrakesFailure); CheatsSet(CheatType::DisableBrakesFailure, !gameState.Cheats.DisableBrakesFailure);
break; break;
case WIDX_DISABLE_ALL_BREAKDOWNS: case WIDX_DISABLE_ALL_BREAKDOWNS:
CheatsSet(CheatType::DisableAllBreakdowns, !gCheatsDisableAllBreakdowns); CheatsSet(CheatType::DisableAllBreakdowns, !gameState.Cheats.DisableAllBreakdowns);
break; break;
case WIDX_BUILD_IN_PAUSE_MODE: case WIDX_BUILD_IN_PAUSE_MODE:
CheatsSet(CheatType::BuildInPauseMode, !gCheatsBuildInPauseMode); CheatsSet(CheatType::BuildInPauseMode, !gameState.Cheats.BuildInPauseMode);
break; break;
case WIDX_RESET_CRASH_STATUS: case WIDX_RESET_CRASH_STATUS:
CheatsSet(CheatType::ResetCrashStatus); CheatsSet(CheatType::ResetCrashStatus);
@ -1072,59 +1076,59 @@ private:
break; break;
case WIDX_SHOW_ALL_OPERATING_MODES: case WIDX_SHOW_ALL_OPERATING_MODES:
{ {
if (!gCheatsShowAllOperatingModes) if (!gameState.Cheats.ShowAllOperatingModes)
{ {
ContextShowError(STR_WARNING_IN_CAPS, STR_THIS_FEATURE_IS_CURRENTLY_UNSTABLE, {}); ContextShowError(STR_WARNING_IN_CAPS, STR_THIS_FEATURE_IS_CURRENTLY_UNSTABLE, {});
} }
CheatsSet(CheatType::ShowAllOperatingModes, !gCheatsShowAllOperatingModes); CheatsSet(CheatType::ShowAllOperatingModes, !gameState.Cheats.ShowAllOperatingModes);
} }
break; break;
case WIDX_SHOW_VEHICLES_FROM_OTHER_TRACK_TYPES: case WIDX_SHOW_VEHICLES_FROM_OTHER_TRACK_TYPES:
{ {
if (!gCheatsShowVehiclesFromOtherTrackTypes) if (!gameState.Cheats.ShowVehiclesFromOtherTrackTypes)
{ {
ContextShowError(STR_WARNING_IN_CAPS, STR_THIS_FEATURE_IS_CURRENTLY_UNSTABLE, {}); ContextShowError(STR_WARNING_IN_CAPS, STR_THIS_FEATURE_IS_CURRENTLY_UNSTABLE, {});
} }
CheatsSet(CheatType::ShowVehiclesFromOtherTrackTypes, !gCheatsShowVehiclesFromOtherTrackTypes); CheatsSet(CheatType::ShowVehiclesFromOtherTrackTypes, !gameState.Cheats.ShowVehiclesFromOtherTrackTypes);
} }
break; break;
case WIDX_DISABLE_TRAIN_LENGTH_LIMITS: case WIDX_DISABLE_TRAIN_LENGTH_LIMITS:
{ {
if (!gCheatsDisableTrainLengthLimit) if (!gameState.Cheats.DisableTrainLengthLimit)
{ {
ContextShowError(STR_WARNING_IN_CAPS, STR_THIS_FEATURE_IS_CURRENTLY_UNSTABLE, {}); ContextShowError(STR_WARNING_IN_CAPS, STR_THIS_FEATURE_IS_CURRENTLY_UNSTABLE, {});
} }
CheatsSet(CheatType::DisableTrainLengthLimit, !gCheatsDisableTrainLengthLimit); CheatsSet(CheatType::DisableTrainLengthLimit, !gameState.Cheats.DisableTrainLengthLimit);
} }
break; break;
case WIDX_ENABLE_CHAIN_LIFT_ON_ALL_TRACK: case WIDX_ENABLE_CHAIN_LIFT_ON_ALL_TRACK:
CheatsSet(CheatType::EnableChainLiftOnAllTrack, !gCheatsEnableChainLiftOnAllTrack); CheatsSet(CheatType::EnableChainLiftOnAllTrack, !gameState.Cheats.EnableChainLiftOnAllTrack);
break; break;
case WIDX_ENABLE_ARBITRARY_RIDE_TYPE_CHANGES: case WIDX_ENABLE_ARBITRARY_RIDE_TYPE_CHANGES:
{ {
if (!gCheatsAllowArbitraryRideTypeChanges) if (!gameState.Cheats.AllowArbitraryRideTypeChanges)
{ {
ContextShowError(STR_WARNING_IN_CAPS, STR_THIS_FEATURE_IS_CURRENTLY_UNSTABLE, {}); ContextShowError(STR_WARNING_IN_CAPS, STR_THIS_FEATURE_IS_CURRENTLY_UNSTABLE, {});
} }
CheatsSet(CheatType::AllowArbitraryRideTypeChanges, !gCheatsAllowArbitraryRideTypeChanges); CheatsSet(CheatType::AllowArbitraryRideTypeChanges, !gameState.Cheats.AllowArbitraryRideTypeChanges);
} }
break; break;
case WIDX_DISABLE_RIDE_VALUE_AGING: case WIDX_DISABLE_RIDE_VALUE_AGING:
CheatsSet(CheatType::DisableRideValueAging, !gCheatsDisableRideValueAging); CheatsSet(CheatType::DisableRideValueAging, !gameState.Cheats.DisableRideValueAging);
break; break;
case WIDX_IGNORE_RESEARCH_STATUS: case WIDX_IGNORE_RESEARCH_STATUS:
CheatsSet(CheatType::IgnoreResearchStatus, !gCheatsIgnoreResearchStatus); CheatsSet(CheatType::IgnoreResearchStatus, !gameState.Cheats.IgnoreResearchStatus);
break; break;
case WIDX_ENABLE_ALL_DRAWABLE_TRACK_PIECES: case WIDX_ENABLE_ALL_DRAWABLE_TRACK_PIECES:
CheatsSet(CheatType::EnableAllDrawableTrackPieces, !gCheatsEnableAllDrawableTrackPieces); CheatsSet(CheatType::EnableAllDrawableTrackPieces, !gameState.Cheats.EnableAllDrawableTrackPieces);
break; break;
case WIDX_ALLOW_TRACK_PLACE_INVALID_HEIGHTS: case WIDX_ALLOW_TRACK_PLACE_INVALID_HEIGHTS:
{ {
if (!gCheatsAllowTrackPlaceInvalidHeights) if (!gameState.Cheats.AllowTrackPlaceInvalidHeights)
{ {
ContextShowError(STR_WARNING_IN_CAPS, STR_THIS_FEATURE_IS_CURRENTLY_UNSTABLE, {}); ContextShowError(STR_WARNING_IN_CAPS, STR_THIS_FEATURE_IS_CURRENTLY_UNSTABLE, {});
} }
CheatsSet(CheatType::AllowTrackPlaceInvalidHeights, !gCheatsAllowTrackPlaceInvalidHeights); CheatsSet(CheatType::AllowTrackPlaceInvalidHeights, !gameState.Cheats.AllowTrackPlaceInvalidHeights);
} }
break; break;
} }

4
src/openrct2-ui/windows/Dropdown.cpp
View File

@ -13,6 +13,7 @@
#include <openrct2-ui/interface/Dropdown.h> #include <openrct2-ui/interface/Dropdown.h>
#include <openrct2-ui/interface/Widget.h> #include <openrct2-ui/interface/Widget.h>
#include <openrct2/Context.h> #include <openrct2/Context.h>
#include <openrct2/GameState.h>
#include <openrct2/Input.h> #include <openrct2/Input.h>
#include <openrct2/core/BitSet.hpp> #include <openrct2/core/BitSet.hpp>
#include <openrct2/drawing/Drawing.h> #include <openrct2/drawing/Drawing.h>
@ -525,7 +526,8 @@ void WindowDropdownShowColour(WindowBase* w, Widget* widget, uint8_t dropdownCol
{ {
int32_t defaultIndex = -1; int32_t defaultIndex = -1;
auto numColours = (gCheatsAllowSpecialColourSchemes) ? static_cast<uint8_t>(COLOUR_COUNT) : COLOUR_NUM_NORMAL; auto numColours = (GetGameState().Cheats.AllowSpecialColourSchemes) ? static_cast<uint8_t>(COLOUR_COUNT)
: COLOUR_NUM_NORMAL;
// Set items // Set items
for (uint64_t i = 0; i < numColours; i++) for (uint64_t i = 0; i < numColours; i++)
{ {

11
src/openrct2-ui/windows/Footpath.cpp
View File

@ -638,7 +638,7 @@ private:
uint32_t numPathTypes = 0; uint32_t numPathTypes = 0;
// If the game is in sandbox mode, also show paths that are normally restricted to the scenario editor // If the game is in sandbox mode, also show paths that are normally restricted to the scenario editor
bool showEditorPaths = ((gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) || gCheatsSandboxMode); bool showEditorPaths = ((gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) || GetGameState().Cheats.SandboxMode);
_dropdownEntries.clear(); _dropdownEntries.clear();
std::optional<size_t> defaultIndex; std::optional<size_t> defaultIndex;
@ -656,12 +656,15 @@ private:
} }
// If regular paths can be used as queue, only hide the path if we’re _not_ looking at a queue, // If regular paths can be used as queue, only hide the path if we’re _not_ looking at a queue,
// but the path surface is one. // but the path surface is one.
if (gCheatsAllowRegularPathAsQueue && !showQueues && ((pathType->Flags & FOOTPATH_ENTRY_FLAG_IS_QUEUE) != 0)) if (GetGameState().Cheats.AllowRegularPathAsQueue && !showQueues
&& ((pathType->Flags & FOOTPATH_ENTRY_FLAG_IS_QUEUE) != 0))
{ {
continue; continue;
} }
// If the cheat is disabled, hide queues from the regular path view and vice versa. // If the cheat is disabled, hide queues from the regular path view and vice versa.
else if (!gCheatsAllowRegularPathAsQueue && showQueues != ((pathType->Flags & FOOTPATH_ENTRY_FLAG_IS_QUEUE) != 0)) else if (
!GetGameState().Cheats.AllowRegularPathAsQueue
&& showQueues != ((pathType->Flags & FOOTPATH_ENTRY_FLAG_IS_QUEUE) != 0))
{ {
continue; continue;
} }
@ -1393,7 +1396,7 @@ public:
void KeyboardShortcutDemolishCurrent() void KeyboardShortcutDemolishCurrent()
{ {
if (IsWidgetDisabled(WIDX_REMOVE) || widgets[WIDX_REMOVE].type == WindowWidgetType::Empty if (IsWidgetDisabled(WIDX_REMOVE) || widgets[WIDX_REMOVE].type == WindowWidgetType::Empty
|| (!gCheatsBuildInPauseMode && GameIsPaused())) || (!GetGameState().Cheats.BuildInPauseMode && GameIsPaused()))
{ {
return; return;
} }

10
src/openrct2-ui/windows/Map.cpp
View File

@ -607,7 +607,7 @@ public:
auto result = GameActions::Execute(&gameAction); auto result = GameActions::Execute(&gameAction);
if (result.Error == GameActions::Status::Ok) if (result.Error == GameActions::Status::Ok)
{ {
OpenRCT2::Audio::Play3D(OpenRCT2::Audio::SoundId::PlaceItem, result.Position); Audio::Play3D(Audio::SoundId::PlaceItem, result.Position);
} }
} }
} }
@ -657,7 +657,7 @@ public:
auto result = GameActions::Execute(&gameAction); auto result = GameActions::Execute(&gameAction);
if (result.Error == GameActions::Status::Ok) if (result.Error == GameActions::Status::Ok)
{ {
OpenRCT2::Audio::Play3D(OpenRCT2::Audio::SoundId::PlaceItem, result.Position); Audio::Play3D(Audio::SoundId::PlaceItem, result.Position);
} }
} }
@ -875,7 +875,7 @@ public:
widgets[i].type = WindowWidgetType::Empty; widgets[i].type = WindowWidgetType::Empty;
} }
if ((gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) || gCheatsSandboxMode) if ((gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) || GetGameState().Cheats.SandboxMode)
{ {
// scenario editor: build park entrance selected, show rotate button // scenario editor: build park entrance selected, show rotate button
if ((InputTestFlag(INPUT_FLAG_TOOL_ACTIVE)) && gCurrentToolWidget.window_classification == WindowClass::Map if ((InputTestFlag(INPUT_FLAG_TOOL_ACTIVE)) && gCurrentToolWidget.window_classification == WindowClass::Map
@ -946,7 +946,7 @@ public:
GfxDrawSprite(dpi, ImageId(SPR_6410, COLOUR_BRIGHT_RED, COLOUR_LIGHT_BROWN), screenCoords); GfxDrawSprite(dpi, ImageId(SPR_6410, COLOUR_BRIGHT_RED, COLOUR_LIGHT_BROWN), screenCoords);
} }
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !gCheatsSandboxMode) if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !GetGameState().Cheats.SandboxMode)
{ {
// Render the map legend // Render the map legend
if (selected_tab == PAGE_RIDES) if (selected_tab == PAGE_RIDES)
@ -1461,7 +1461,7 @@ private:
{ {
widgets[WIDX_MAP].right = width - 4; widgets[WIDX_MAP].right = width - 4;
if ((gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) || gCheatsSandboxMode) if ((gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) || GetGameState().Cheats.SandboxMode)
widgets[WIDX_MAP].bottom = height - 1 - 72; widgets[WIDX_MAP].bottom = height - 1 - 72;
else if (selected_tab == PAGE_RIDES) else if (selected_tab == PAGE_RIDES)
widgets[WIDX_MAP].bottom = height - 1 - (4 * LIST_ROW_HEIGHT + 4); widgets[WIDX_MAP].bottom = height - 1 - (4 * LIST_ROW_HEIGHT + 4);

4
src/openrct2-ui/windows/NewRide.cpp
View File

@ -615,7 +615,7 @@ private:
auto currentRideEntry = GetRideEntryByIndex(rideEntryIndex); auto currentRideEntry = GetRideEntryByIndex(rideEntryIndex);
// Skip if vehicle type is not invented yet // Skip if vehicle type is not invented yet
if (!RideEntryIsInvented(rideEntryIndex) && !gCheatsIgnoreResearchStatus) if (!RideEntryIsInvented(rideEntryIndex) && !GetGameState().Cheats.IgnoreResearchStatus)
{ {
continue; continue;
} }
@ -677,7 +677,7 @@ private:
for (auto rideEntryIndex : rideEntries) for (auto rideEntryIndex : rideEntries)
{ {
// Skip if vehicle type is not invented yet // Skip if vehicle type is not invented yet
if (!RideEntryIsInvented(rideEntryIndex) && !gCheatsIgnoreResearchStatus) if (!RideEntryIsInvented(rideEntryIndex) && !GetGameState().Cheats.IgnoreResearchStatus)
continue; continue;
// Ride entries // Ride entries

63
src/openrct2-ui/windows/Ride.cpp
View File

@ -1603,7 +1603,7 @@ private:
} }
} }
} }
if (gCheatsAllowArbitraryRideTypeChanges) if (GetGameState().Cheats.AllowArbitraryRideTypeChanges)
{ {
minHeight += 15; minHeight += 15;
} }
@ -1904,7 +1904,7 @@ private:
int32_t rideTypeIterator, rideTypeIteratorMax; int32_t rideTypeIterator, rideTypeIteratorMax;
const auto& rtd = ride.GetRideTypeDescriptor(); const auto& rtd = ride.GetRideTypeDescriptor();
if (gCheatsShowVehiclesFromOtherTrackTypes if (GetGameState().Cheats.ShowVehiclesFromOtherTrackTypes
&& !( && !(
rtd.HasFlag(RIDE_TYPE_FLAG_FLAT_RIDE) || rtd.HasFlag(RIDE_TYPE_FLAG_IS_MAZE) rtd.HasFlag(RIDE_TYPE_FLAG_FLAT_RIDE) || rtd.HasFlag(RIDE_TYPE_FLAG_IS_MAZE)
|| ride.type == RIDE_TYPE_MINI_GOLF)) || ride.type == RIDE_TYPE_MINI_GOLF))
@ -1945,7 +1945,7 @@ private:
continue; continue;
// Skip if vehicle type has not been invented yet // Skip if vehicle type has not been invented yet
if (!RideEntryIsInvented(rideEntryIndex) && !gCheatsIgnoreResearchStatus) if (!RideEntryIsInvented(rideEntryIndex) && !GetGameState().Cheats.IgnoreResearchStatus)
continue; continue;
auto name = currentRideEntry->naming.Name; auto name = currentRideEntry->naming.Name;
@ -2233,7 +2233,7 @@ private:
disabled_widgets &= ~((1uLL << WIDX_DEMOLISH) | (1uLL << WIDX_CONSTRUCTION)); disabled_widgets &= ~((1uLL << WIDX_DEMOLISH) | (1uLL << WIDX_CONSTRUCTION));
if (ride->lifecycle_flags & (RIDE_LIFECYCLE_INDESTRUCTIBLE | RIDE_LIFECYCLE_INDESTRUCTIBLE_TRACK) if (ride->lifecycle_flags & (RIDE_LIFECYCLE_INDESTRUCTIBLE | RIDE_LIFECYCLE_INDESTRUCTIBLE_TRACK)
&& !gCheatsMakeAllDestructible) && !GetGameState().Cheats.MakeAllDestructible)
disabled_widgets |= (1uLL << WIDX_DEMOLISH); disabled_widgets |= (1uLL << WIDX_DEMOLISH);
auto ft = Formatter::Common(); auto ft = Formatter::Common();
@ -2271,7 +2271,7 @@ private:
AnchorBorderWidgets(); AnchorBorderWidgets();
const int32_t offset = gCheatsAllowArbitraryRideTypeChanges ? 15 : 0; const int32_t offset = GetGameState().Cheats.AllowArbitraryRideTypeChanges ? 15 : 0;
// Anchor main page specific widgets // Anchor main page specific widgets
widgets[WIDX_VIEWPORT].right = width - 26; widgets[WIDX_VIEWPORT].right = width - 26;
widgets[WIDX_VIEWPORT].bottom = height - (14 + offset); widgets[WIDX_VIEWPORT].bottom = height - (14 + offset);
@ -2289,7 +2289,7 @@ private:
widgets[WIDX_RIDE_TYPE_DROPDOWN].top = height - 16; widgets[WIDX_RIDE_TYPE_DROPDOWN].top = height - 16;
widgets[WIDX_RIDE_TYPE_DROPDOWN].bottom = height - 5; widgets[WIDX_RIDE_TYPE_DROPDOWN].bottom = height - 5;
if (!gCheatsAllowArbitraryRideTypeChanges) if (!GetGameState().Cheats.AllowArbitraryRideTypeChanges)
{ {
widgets[WIDX_RIDE_TYPE].type = WindowWidgetType::Empty; widgets[WIDX_RIDE_TYPE].type = WindowWidgetType::Empty;
widgets[WIDX_RIDE_TYPE_DROPDOWN].type = WindowWidgetType::Empty; widgets[WIDX_RIDE_TYPE_DROPDOWN].type = WindowWidgetType::Empty;
@ -2698,7 +2698,7 @@ private:
widgets[WIDX_VEHICLE_TYPE].text = rideEntry->naming.Name; widgets[WIDX_VEHICLE_TYPE].text = rideEntry->naming.Name;
// Trains // Trains
if (rideEntry->cars_per_flat_ride > 1 || gCheatsDisableTrainLengthLimit) if (rideEntry->cars_per_flat_ride > 1 || GetGameState().Cheats.DisableTrainLengthLimit)
{ {
widgets[WIDX_VEHICLE_TRAINS].type = WindowWidgetType::Spinner; widgets[WIDX_VEHICLE_TRAINS].type = WindowWidgetType::Spinner;
widgets[WIDX_VEHICLE_TRAINS_INCREASE].type = WindowWidgetType::Button; widgets[WIDX_VEHICLE_TRAINS_INCREASE].type = WindowWidgetType::Button;
@ -2712,7 +2712,7 @@ private:
} }
// Cars per train // Cars per train
if (rideEntry->zero_cars + 1 < rideEntry->max_cars_in_train || gCheatsDisableTrainLengthLimit) if (rideEntry->zero_cars + 1 < rideEntry->max_cars_in_train || GetGameState().Cheats.DisableTrainLengthLimit)
{ {
widgets[WIDX_VEHICLE_CARS_PER_TRAIN].type = WindowWidgetType::Spinner; widgets[WIDX_VEHICLE_CARS_PER_TRAIN].type = WindowWidgetType::Spinner;
widgets[WIDX_VEHICLE_CARS_PER_TRAIN_INCREASE].type = WindowWidgetType::Button; widgets[WIDX_VEHICLE_CARS_PER_TRAIN_INCREASE].type = WindowWidgetType::Button;
@ -2726,7 +2726,8 @@ private:
} }
if (ride->GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_ALLOW_REVERSED_TRAINS) if (ride->GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_ALLOW_REVERSED_TRAINS)
|| (gCheatsDisableTrainLengthLimit && !ride->GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_FLAT_RIDE))) || (GetGameState().Cheats.DisableTrainLengthLimit
&& !ride->GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_FLAT_RIDE)))
{ {
widgets[WIDX_VEHICLE_REVERSED_TRAINS_CHECKBOX].type = WindowWidgetType::Checkbox; widgets[WIDX_VEHICLE_REVERSED_TRAINS_CHECKBOX].type = WindowWidgetType::Checkbox;
if (ride->HasLifecycleFlag(RIDE_LIFECYCLE_REVERSED_TRAINS)) if (ride->HasLifecycleFlag(RIDE_LIFECYCLE_REVERSED_TRAINS))
@ -2954,9 +2955,9 @@ private:
const auto& operatingSettings = ride->GetRideTypeDescriptor().OperatingSettings; const auto& operatingSettings = ride->GetRideTypeDescriptor().OperatingSettings;
uint8_t maxValue = operatingSettings.MaxValue; uint8_t maxValue = operatingSettings.MaxValue;
uint8_t minValue = gCheatsUnlockOperatingLimits ? 0 : operatingSettings.MinValue; uint8_t minValue = GetGameState().Cheats.UnlockOperatingLimits ? 0 : operatingSettings.MinValue;
if (gCheatsUnlockOperatingLimits) if (GetGameState().Cheats.UnlockOperatingLimits)
{ {
maxValue = OpenRCT2::Limits::CheatsMaxOperatingLimit; maxValue = OpenRCT2::Limits::CheatsMaxOperatingLimit;
} }
@ -2975,8 +2976,8 @@ private:
const auto& operatingSettings = ride->GetRideTypeDescriptor().OperatingSettings; const auto& operatingSettings = ride->GetRideTypeDescriptor().OperatingSettings;
uint8_t maxValue = operatingSettings.MaxValue; uint8_t maxValue = operatingSettings.MaxValue;
uint8_t minValue = gCheatsUnlockOperatingLimits ? 0 : operatingSettings.MinValue; uint8_t minValue = GetGameState().Cheats.UnlockOperatingLimits ? 0 : operatingSettings.MinValue;
if (gCheatsUnlockOperatingLimits) if (GetGameState().Cheats.UnlockOperatingLimits)
{ {
maxValue = OpenRCT2::Limits::CheatsMaxOperatingLimit; maxValue = OpenRCT2::Limits::CheatsMaxOperatingLimit;
} }
@ -3113,17 +3114,19 @@ private:
ModeTweakDecrease(); ModeTweakDecrease();
break; break;
case WIDX_LIFT_HILL_SPEED_INCREASE: case WIDX_LIFT_HILL_SPEED_INCREASE:
upperBound = gCheatsUnlockOperatingLimits ? OpenRCT2::Limits::CheatsMaxOperatingLimit upperBound = GetGameState().Cheats.UnlockOperatingLimits ? OpenRCT2::Limits::CheatsMaxOperatingLimit
: ride->GetRideTypeDescriptor().LiftData.maximum_speed; : ride->GetRideTypeDescriptor().LiftData.maximum_speed;
lowerBound = gCheatsUnlockOperatingLimits ? 0 : ride->GetRideTypeDescriptor().LiftData.minimum_speed; lowerBound = GetGameState().Cheats.UnlockOperatingLimits ? 0
: ride->GetRideTypeDescriptor().LiftData.minimum_speed;
SetOperatingSetting( SetOperatingSetting(
rideId, RideSetSetting::LiftHillSpeed, rideId, RideSetSetting::LiftHillSpeed,
std::clamp<int16_t>(ride->lift_hill_speed + 1, lowerBound, upperBound)); std::clamp<int16_t>(ride->lift_hill_speed + 1, lowerBound, upperBound));
break; break;
case WIDX_LIFT_HILL_SPEED_DECREASE: case WIDX_LIFT_HILL_SPEED_DECREASE:
upperBound = gCheatsUnlockOperatingLimits ? OpenRCT2::Limits::CheatsMaxOperatingLimit upperBound = GetGameState().Cheats.UnlockOperatingLimits ? OpenRCT2::Limits::CheatsMaxOperatingLimit
: ride->GetRideTypeDescriptor().LiftData.maximum_speed; : ride->GetRideTypeDescriptor().LiftData.maximum_speed;
lowerBound = gCheatsUnlockOperatingLimits ? 0 : ride->GetRideTypeDescriptor().LiftData.minimum_speed; lowerBound = GetGameState().Cheats.UnlockOperatingLimits ? 0
: ride->GetRideTypeDescriptor().LiftData.minimum_speed;
SetOperatingSetting( SetOperatingSetting(
rideId, RideSetSetting::LiftHillSpeed, rideId, RideSetSetting::LiftHillSpeed,
std::clamp<int16_t>(ride->lift_hill_speed - 1, lowerBound, upperBound)); std::clamp<int16_t>(ride->lift_hill_speed - 1, lowerBound, upperBound));
@ -3169,15 +3172,15 @@ private:
LoadDropdown(&widgets[widgetIndex]); LoadDropdown(&widgets[widgetIndex]);
break; break;
case WIDX_OPERATE_NUMBER_OF_CIRCUITS_INCREASE: case WIDX_OPERATE_NUMBER_OF_CIRCUITS_INCREASE:
upperBound = gCheatsUnlockOperatingLimits ? OpenRCT2::Limits::CheatsMaxOperatingLimit upperBound = GetGameState().Cheats.UnlockOperatingLimits ? OpenRCT2::Limits::CheatsMaxOperatingLimit
: OpenRCT2::Limits::MaxCircuitsPerRide; : OpenRCT2::Limits::MaxCircuitsPerRide;
lowerBound = 1; lowerBound = 1;
SetOperatingSetting( SetOperatingSetting(
rideId, RideSetSetting::NumCircuits, std::clamp<int16_t>(ride->num_circuits + 1, lowerBound, upperBound)); rideId, RideSetSetting::NumCircuits, std::clamp<int16_t>(ride->num_circuits + 1, lowerBound, upperBound));
break; break;
case WIDX_OPERATE_NUMBER_OF_CIRCUITS_DECREASE: case WIDX_OPERATE_NUMBER_OF_CIRCUITS_DECREASE:
upperBound = gCheatsUnlockOperatingLimits ? OpenRCT2::Limits::CheatsMaxOperatingLimit upperBound = GetGameState().Cheats.UnlockOperatingLimits ? OpenRCT2::Limits::CheatsMaxOperatingLimit
: OpenRCT2::Limits::MaxCircuitsPerRide; : OpenRCT2::Limits::MaxCircuitsPerRide;
lowerBound = 1; lowerBound = 1;
SetOperatingSetting( SetOperatingSetting(
rideId, RideSetSetting::NumCircuits, std::clamp<int16_t>(ride->num_circuits - 1, lowerBound, upperBound)); rideId, RideSetSetting::NumCircuits, std::clamp<int16_t>(ride->num_circuits - 1, lowerBound, upperBound));
@ -3219,9 +3222,9 @@ private:
} }
const auto& operatingSettings = ride.GetRideTypeDescriptor().OperatingSettings; const auto& operatingSettings = ride.GetRideTypeDescriptor().OperatingSettings;
int16_t maxValue = gCheatsUnlockOperatingLimits ? OpenRCT2::Limits::CheatsMaxOperatingLimit int16_t maxValue = GetGameState().Cheats.UnlockOperatingLimits ? OpenRCT2::Limits::CheatsMaxOperatingLimit
: operatingSettings.MaxValue; : operatingSettings.MaxValue;
int16_t minValue = gCheatsUnlockOperatingLimits ? 0 : operatingSettings.MinValue; int16_t minValue = GetGameState().Cheats.UnlockOperatingLimits ? 0 : operatingSettings.MinValue;
const auto& title = widgets[WIDX_MODE_TWEAK_LABEL].text; const auto& title = widgets[WIDX_MODE_TWEAK_LABEL].text;
Formatter ft; Formatter ft;
@ -3300,9 +3303,9 @@ private:
if (widgetIndex == WIDX_MODE_TWEAK) if (widgetIndex == WIDX_MODE_TWEAK)
{ {
const auto& operatingSettings = ride->GetRideTypeDescriptor().OperatingSettings; const auto& operatingSettings = ride->GetRideTypeDescriptor().OperatingSettings;
uint32_t maxValue = gCheatsUnlockOperatingLimits ? OpenRCT2::Limits::CheatsMaxOperatingLimit uint32_t maxValue = GetGameState().Cheats.UnlockOperatingLimits ? OpenRCT2::Limits::CheatsMaxOperatingLimit
: operatingSettings.MaxValue; : operatingSettings.MaxValue;
uint32_t minValue = gCheatsUnlockOperatingLimits ? 0 : operatingSettings.MinValue; uint32_t minValue = GetGameState().Cheats.UnlockOperatingLimits ? 0 : operatingSettings.MinValue;
auto multiplier = ride->GetRideTypeDescriptor().OperatingSettings.OperatingSettingMultiplier; auto multiplier = ride->GetRideTypeDescriptor().OperatingSettings.OperatingSettingMultiplier;
try try
@ -4880,7 +4883,7 @@ private:
} }
} }
if (gCheatsUnlockOperatingLimits || musicObj->SupportsRideType(ride->type)) if (GetGameState().Cheats.UnlockOperatingLimits || musicObj->SupportsRideType(ride->type))
{ {
musicOrder.push_back(i); musicOrder.push_back(i);
} }

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

@ -404,7 +404,7 @@ public:
} }
} }
if (currentRide->GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_UP_INCLINE_REQUIRES_LIFT) if (currentRide->GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_UP_INCLINE_REQUIRES_LIFT)
&& !gCheatsEnableAllDrawableTrackPieces) && !GetGameState().Cheats.EnableAllDrawableTrackPieces)
{ {
// Disable lift hill toggle and banking if current track piece is uphill // Disable lift hill toggle and banking if current track piece is uphill
if (_previousTrackPitchEnd == TrackPitch::Up25 || _previousTrackPitchEnd == TrackPitch::Up60 if (_previousTrackPitchEnd == TrackPitch::Up25 || _previousTrackPitchEnd == TrackPitch::Up60
@ -714,7 +714,7 @@ public:
{ {
disabledWidgets |= (1uLL << WIDX_SLOPE_DOWN); disabledWidgets |= (1uLL << WIDX_SLOPE_DOWN);
} }
if ((_currentTrackLiftHill & CONSTRUCTION_LIFT_HILL_SELECTED) && !gCheatsEnableChainLiftOnAllTrack) if ((_currentTrackLiftHill & CONSTRUCTION_LIFT_HILL_SELECTED) && !GetGameState().Cheats.EnableChainLiftOnAllTrack)
{ {
if (_currentTrackPitchEnd != TrackPitch::None && !IsTrackEnabled(TRACK_LIFT_HILL_CURVE)) if (_currentTrackPitchEnd != TrackPitch::None && !IsTrackEnabled(TRACK_LIFT_HILL_CURVE))
{ {
@ -808,7 +808,7 @@ public:
{ {
if (_currentTrackPitchEnd == TrackPitch::None && _previousTrackRollEnd != TrackRoll::None if (_currentTrackPitchEnd == TrackPitch::None && _previousTrackRollEnd != TrackRoll::None
&& (!currentRide->GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_UP_INCLINE_REQUIRES_LIFT) && (!currentRide->GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_UP_INCLINE_REQUIRES_LIFT)
|| gCheatsEnableAllDrawableTrackPieces)) || GetGameState().Cheats.EnableAllDrawableTrackPieces))
{ {
disabledWidgets &= ~(1uLL << WIDX_SLOPE_UP); disabledWidgets &= ~(1uLL << WIDX_SLOPE_UP);
} }
@ -873,7 +873,7 @@ public:
} }
// If chain lift cheat is enabled then show the chain lift widget no matter what // If chain lift cheat is enabled then show the chain lift widget no matter what
if (gCheatsEnableChainLiftOnAllTrack) if (GetGameState().Cheats.EnableChainLiftOnAllTrack)
{ {
disabledWidgets &= ~(1uLL << WIDX_CHAIN_LIFT); disabledWidgets &= ~(1uLL << WIDX_CHAIN_LIFT);
} }
@ -1290,7 +1290,8 @@ public:
case WIDX_CHAIN_LIFT: case WIDX_CHAIN_LIFT:
RideConstructionInvalidateCurrentTrack(); RideConstructionInvalidateCurrentTrack();
_currentTrackLiftHill ^= CONSTRUCTION_LIFT_HILL_SELECTED; _currentTrackLiftHill ^= CONSTRUCTION_LIFT_HILL_SELECTED;
if ((_currentTrackLiftHill & CONSTRUCTION_LIFT_HILL_SELECTED) && !gCheatsEnableChainLiftOnAllTrack) if ((_currentTrackLiftHill & CONSTRUCTION_LIFT_HILL_SELECTED)
&& !GetGameState().Cheats.EnableChainLiftOnAllTrack)
_currentTrackAlternative &= ~RIDE_TYPE_ALTERNATIVE_TRACK_PIECES; _currentTrackAlternative &= ~RIDE_TYPE_ALTERNATIVE_TRACK_PIECES;
_currentTrackPrice = kMoney64Undefined; _currentTrackPrice = kMoney64Undefined;
WindowRideConstructionUpdateActiveElements(); WindowRideConstructionUpdateActiveElements();
@ -1369,7 +1370,7 @@ public:
case WIDX_O_TRACK: case WIDX_O_TRACK:
RideConstructionInvalidateCurrentTrack(); RideConstructionInvalidateCurrentTrack();
_currentTrackAlternative |= RIDE_TYPE_ALTERNATIVE_TRACK_PIECES; _currentTrackAlternative |= RIDE_TYPE_ALTERNATIVE_TRACK_PIECES;
if (!gCheatsEnableChainLiftOnAllTrack) if (!GetGameState().Cheats.EnableChainLiftOnAllTrack)
_currentTrackLiftHill &= ~CONSTRUCTION_LIFT_HILL_SELECTED; _currentTrackLiftHill &= ~CONSTRUCTION_LIFT_HILL_SELECTED;
_currentTrackPrice = kMoney64Undefined; _currentTrackPrice = kMoney64Undefined;
WindowRideConstructionUpdateActiveElements(); WindowRideConstructionUpdateActiveElements();
@ -1686,13 +1687,14 @@ public:
if (currentRide->GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_UP_INCLINE_REQUIRES_LIFT) if (currentRide->GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_UP_INCLINE_REQUIRES_LIFT)
&& (_currentTrackPitchEnd == TrackPitch::Up25 || _currentTrackPitchEnd == TrackPitch::Up60) && (_currentTrackPitchEnd == TrackPitch::Up25 || _currentTrackPitchEnd == TrackPitch::Up60)
&& !gCheatsEnableAllDrawableTrackPieces) && !GetGameState().Cheats.EnableAllDrawableTrackPieces)
{ {
_currentTrackLiftHill |= CONSTRUCTION_LIFT_HILL_SELECTED; _currentTrackLiftHill |= CONSTRUCTION_LIFT_HILL_SELECTED;
} }
if ((IsTrackEnabled(TRACK_LIFT_HILL) && (_currentTrackCurve & RideConstructionSpecialPieceSelected) == 0) if ((IsTrackEnabled(TRACK_LIFT_HILL) && (_currentTrackCurve & RideConstructionSpecialPieceSelected) == 0)
|| (gCheatsEnableChainLiftOnAllTrack && currentRide->GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_HAS_TRACK))) || (GetGameState().Cheats.EnableChainLiftOnAllTrack
&& currentRide->GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_HAS_TRACK)))
{ {
widgets[WIDX_CHAIN_LIFT].type = WindowWidgetType::FlatBtn; widgets[WIDX_CHAIN_LIFT].type = WindowWidgetType::FlatBtn;
} }
@ -2190,7 +2192,7 @@ private:
} }
auto trackPlaceAction = TrackPlaceAction( auto trackPlaceAction = TrackPlaceAction(
rideIndex, trackType, currentRide->type, { trackPos, static_cast<uint8_t>(trackDirection) }, (properties)&0xFF, rideIndex, trackType, currentRide->type, { trackPos, static_cast<uint8_t>(trackDirection) }, properties & 0xFF,
(properties >> 8) & 0x0F, (properties >> 12) & 0x0F, liftHillAndAlternativeState, false); (properties >> 8) & 0x0F, (properties >> 12) & 0x0F, liftHillAndAlternativeState, false);
if (_rideConstructionState == RideConstructionState::Back) if (_rideConstructionState == RideConstructionState::Back)
{ {
@ -2414,7 +2416,7 @@ private:
{ {
_currentTrackPitchEnd = slope; _currentTrackPitchEnd = slope;
_currentTrackPrice = kMoney64Undefined; _currentTrackPrice = kMoney64Undefined;
if (_rideConstructionState == RideConstructionState::Front && !gCheatsEnableChainLiftOnAllTrack) if (_rideConstructionState == RideConstructionState::Front && !GetGameState().Cheats.EnableChainLiftOnAllTrack)
{ {
switch (slope) switch (slope)
{ {
@ -3487,7 +3489,7 @@ void RideConstructionTooldownConstruct(const ScreenCoordsXY& screenCoords)
z -= bx; z -= bx;
// FIX not sure exactly why it starts trial and error place from a lower Z, but it causes issues with disable clearance // FIX not sure exactly why it starts trial and error place from a lower Z, but it causes issues with disable clearance
if (!gCheatsDisableClearanceChecks && z > kMinimumLandZ) if (!GetGameState().Cheats.DisableClearanceChecks && z > kMinimumLandZ)
{ {
z -= LAND_HEIGHT_STEP; z -= LAND_HEIGHT_STEP;
} }

2
src/openrct2-ui/windows/Scenery.cpp
View File

@ -661,7 +661,7 @@ public:
widgets[WIDX_SCENERY_ROTATE_OBJECTS_BUTTON].type = WindowWidgetType::FlatBtn; widgets[WIDX_SCENERY_ROTATE_OBJECTS_BUTTON].type = WindowWidgetType::FlatBtn;
} }
if ((gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) || gCheatsSandboxMode) if ((gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) || GetGameState().Cheats.SandboxMode)
{ {
widgets[WIDX_RESTRICT_SCENERY].type = WindowWidgetType::Button; widgets[WIDX_RESTRICT_SCENERY].type = WindowWidgetType::Button;
if (IsSceneryItemRestricted(tabSelectedScenery)) if (IsSceneryItemRestricted(tabSelectedScenery))

16
src/openrct2-ui/windows/TopToolbar.cpp
View File

@ -1615,7 +1615,7 @@ private:
void Sub6E1F34UpdateScreenCoordsAndButtonsPressed(bool canRaiseItem, ScreenCoordsXY& screenPos) void Sub6E1F34UpdateScreenCoordsAndButtonsPressed(bool canRaiseItem, ScreenCoordsXY& screenPos)
{ {
if (!canRaiseItem && !gCheatsDisableSupportLimits) if (!canRaiseItem && !GetGameState().Cheats.DisableSupportLimits)
{ {
gSceneryCtrlPressed = false; gSceneryCtrlPressed = false;
gSceneryShiftPressed = false; gSceneryShiftPressed = false;
@ -3230,7 +3230,7 @@ public:
GfxDrawSprite(dpi, ImageId(SPR_G2_SANDBOX), screenPos); GfxDrawSprite(dpi, ImageId(SPR_G2_SANDBOX), screenPos);
// Draw an overlay if clearance checks are disabled // Draw an overlay if clearance checks are disabled
if (gCheatsDisableClearanceChecks) if (GetGameState().Cheats.DisableClearanceChecks)
{ {
auto colour = static_cast<colour_t>(EnumValue(COLOUR_DARK_ORANGE) | EnumValue(COLOUR_FLAG_OUTLINE)); auto colour = static_cast<colour_t>(EnumValue(COLOUR_DARK_ORANGE) | EnumValue(COLOUR_FLAG_OUTLINE));
DrawTextBasic( DrawTextBasic(
@ -3746,15 +3746,15 @@ void TopToolbar::InitCheatsMenu(Widget& widget)
Dropdown::SetDisabled(DDIDX_ENABLE_SANDBOX_MODE, true); Dropdown::SetDisabled(DDIDX_ENABLE_SANDBOX_MODE, true);
} }
if (gCheatsSandboxMode) if (GetGameState().Cheats.SandboxMode)
{ {
Dropdown::SetChecked(DDIDX_ENABLE_SANDBOX_MODE, true); Dropdown::SetChecked(DDIDX_ENABLE_SANDBOX_MODE, true);
} }
if (gCheatsDisableClearanceChecks) if (GetGameState().Cheats.DisableClearanceChecks)
{ {
Dropdown::SetChecked(DDIDX_DISABLE_CLEARANCE_CHECKS, true); Dropdown::SetChecked(DDIDX_DISABLE_CLEARANCE_CHECKS, true);
} }
if (gCheatsDisableSupportLimits) if (GetGameState().Cheats.DisableSupportLimits)
{ {
Dropdown::SetChecked(DDIDX_DISABLE_SUPPORT_LIMITS, true); Dropdown::SetChecked(DDIDX_DISABLE_SUPPORT_LIMITS, true);
} }
@ -3786,13 +3786,13 @@ void TopToolbar::CheatsMenuDropdown(int16_t dropdownIndex)
ContextOpenWindow(WindowClass::EditorObjectiveOptions); ContextOpenWindow(WindowClass::EditorObjectiveOptions);
break; break;
case DDIDX_ENABLE_SANDBOX_MODE: case DDIDX_ENABLE_SANDBOX_MODE:
CheatsSet(CheatType::SandboxMode, !gCheatsSandboxMode); CheatsSet(CheatType::SandboxMode, !GetGameState().Cheats.SandboxMode);
break; break;
case DDIDX_DISABLE_CLEARANCE_CHECKS: case DDIDX_DISABLE_CLEARANCE_CHECKS:
CheatsSet(CheatType::DisableClearanceChecks, !gCheatsDisableClearanceChecks); CheatsSet(CheatType::DisableClearanceChecks, !GetGameState().Cheats.DisableClearanceChecks);
break; break;
case DDIDX_DISABLE_SUPPORT_LIMITS: case DDIDX_DISABLE_SUPPORT_LIMITS:
CheatsSet(CheatType::DisableSupportLimits, !gCheatsDisableSupportLimits); CheatsSet(CheatType::DisableSupportLimits, !GetGameState().Cheats.DisableSupportLimits);
break; break;
} }
} }

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

@ -174,7 +174,7 @@ public:
mapZ = GetBaseZ(mapCoords); mapZ = GetBaseZ(mapCoords);
CoordsXYZD trackLoc = { mapCoords, mapZ, _currentTrackPieceDirection }; CoordsXYZD trackLoc = { mapCoords, mapZ, _currentTrackPieceDirection };
if (GameIsNotPaused() || gCheatsBuildInPauseMode) if (GameIsNotPaused() || GetGameState().Cheats.BuildInPauseMode)
{ {
ClearProvisional(); ClearProvisional();
auto res = FindValidTrackDesignPlaceHeight(trackLoc, GAME_COMMAND_FLAG_NO_SPEND | GAME_COMMAND_FLAG_GHOST); auto res = FindValidTrackDesignPlaceHeight(trackLoc, GAME_COMMAND_FLAG_NO_SPEND | GAME_COMMAND_FLAG_GHOST);

187
src/openrct2/Cheats.cpp
View File

@ -30,61 +30,36 @@ using namespace OpenRCT2;
// TODO: Refactor this. Cheat variables should contain the cheat type // TODO: Refactor this. Cheat variables should contain the cheat type
// and a serialisation method. // and a serialisation method.
bool gCheatsSandboxMode = false;
bool gCheatsDisableClearanceChecks = false;
bool gCheatsDisableSupportLimits = false;
bool gCheatsShowAllOperatingModes = false;
bool gCheatsShowVehiclesFromOtherTrackTypes = false;
bool gCheatsUnlockOperatingLimits = false;
bool gCheatsDisableBrakesFailure = false;
bool gCheatsDisableAllBreakdowns = false;
bool gCheatsBuildInPauseMode = false;
bool gCheatsIgnoreRideIntensity = false;
bool gCheatsDisableVandalism = false;
bool gCheatsDisableLittering = false;
bool gCheatsNeverendingMarketing = false;
bool gCheatsFreezeWeather = false;
bool gCheatsDisableTrainLengthLimit = false;
bool gCheatsDisablePlantAging = false;
bool gCheatsEnableChainLiftOnAllTrack = false;
bool gCheatsAllowArbitraryRideTypeChanges = false;
bool gCheatsDisableRideValueAging = false;
bool gCheatsIgnoreResearchStatus = false;
bool gCheatsEnableAllDrawableTrackPieces = false;
bool gCheatsAllowTrackPlaceInvalidHeights = false;
bool gCheatsAllowRegularPathAsQueue = false;
bool gCheatsAllowSpecialColourSchemes = false;
bool gCheatsMakeAllDestructible = false;
StaffSpeedCheat gCheatsSelectedStaffSpeed = StaffSpeedCheat::None;
void CheatsReset() void CheatsReset()
{ {
gCheatsSandboxMode = false; auto& gameState = GetGameState();
gCheatsDisableClearanceChecks = false; gameState.Cheats.SandboxMode = false;
gCheatsDisableSupportLimits = false; gameState.Cheats.DisableClearanceChecks = false;
gCheatsShowAllOperatingModes = false; gameState.Cheats.DisableSupportLimits = false;
gCheatsShowVehiclesFromOtherTrackTypes = false; gameState.Cheats.ShowAllOperatingModes = false;
gCheatsDisableTrainLengthLimit = false; gameState.Cheats.ShowVehiclesFromOtherTrackTypes = false;
gCheatsEnableChainLiftOnAllTrack = false; gameState.Cheats.DisableTrainLengthLimit = false;
gCheatsUnlockOperatingLimits = false; gameState.Cheats.EnableChainLiftOnAllTrack = false;
gCheatsDisableBrakesFailure = false; gameState.Cheats.UnlockOperatingLimits = false;
gCheatsDisableAllBreakdowns = false; gameState.Cheats.DisableBrakesFailure = false;
gCheatsBuildInPauseMode = false; gameState.Cheats.DisableAllBreakdowns = false;
gCheatsIgnoreRideIntensity = false; gameState.Cheats.BuildInPauseMode = false;
gCheatsDisableVandalism = false; gameState.Cheats.IgnoreRideIntensity = false;
gCheatsDisableLittering = false; gameState.Cheats.DisableVandalism = false;
gCheatsNeverendingMarketing = false; gameState.Cheats.DisableLittering = false;
gCheatsFreezeWeather = false; gameState.Cheats.NeverendingMarketing = false;
gCheatsDisablePlantAging = false; gameState.Cheats.FreezeWeather = false;
gCheatsAllowArbitraryRideTypeChanges = false; gameState.Cheats.DisablePlantAging = false;
gCheatsDisableRideValueAging = false; gameState.Cheats.AllowArbitraryRideTypeChanges = false;
gCheatsIgnoreResearchStatus = false; gameState.Cheats.DisableRideValueAging = false;
gCheatsEnableAllDrawableTrackPieces = false; gameState.Cheats.IgnoreResearchStatus = false;
gCheatsAllowTrackPlaceInvalidHeights = false; gameState.Cheats.EnableAllDrawableTrackPieces = false;
gCheatsAllowRegularPathAsQueue = false; gameState.Cheats.AllowTrackPlaceInvalidHeights = false;
gCheatsAllowSpecialColourSchemes = false; gameState.Cheats.AllowRegularPathAsQueue = false;
gCheatsMakeAllDestructible = false; gameState.Cheats.AllowSpecialColourSchemes = false;
gCheatsSelectedStaffSpeed = StaffSpeedCheat::None; gameState.Cheats.MakeAllDestructible = false;
gameState.Cheats.SelectedStaffSpeed = StaffSpeedCheat::None;
} }
void CheatsSet(CheatType cheatType, int64_t param1 /* = 0*/, int64_t param2 /* = 0*/) void CheatsSet(CheatType cheatType, int64_t param1 /* = 0*/, int64_t param2 /* = 0*/)
@ -102,6 +77,7 @@ template<typename T> static void CheatEntrySerialise(DataSerialiser& ds, CheatTy
void CheatsSerialise(DataSerialiser& ds) void CheatsSerialise(DataSerialiser& ds)
{ {
uint16_t count = 0; uint16_t count = 0;
auto& gameState = GetGameState();
if (ds.IsSaving()) if (ds.IsSaving())
{ {
@ -111,32 +87,35 @@ void CheatsSerialise(DataSerialiser& ds)
uint64_t countOffset = stream.GetPosition(); uint64_t countOffset = stream.GetPosition();
ds << count; ds << count;
CheatEntrySerialise(ds, CheatType::SandboxMode, gCheatsSandboxMode, count); CheatEntrySerialise(ds, CheatType::SandboxMode, gameState.Cheats.SandboxMode, count);
CheatEntrySerialise(ds, CheatType::DisableClearanceChecks, gCheatsDisableClearanceChecks, count); CheatEntrySerialise(ds, CheatType::DisableClearanceChecks, gameState.Cheats.DisableClearanceChecks, count);
CheatEntrySerialise(ds, CheatType::DisableSupportLimits, gCheatsDisableSupportLimits, count); CheatEntrySerialise(ds, CheatType::DisableSupportLimits, gameState.Cheats.DisableSupportLimits, count);
CheatEntrySerialise(ds, CheatType::ShowAllOperatingModes, gCheatsShowAllOperatingModes, count); CheatEntrySerialise(ds, CheatType::ShowAllOperatingModes, gameState.Cheats.ShowAllOperatingModes, count);
CheatEntrySerialise(ds, CheatType::ShowVehiclesFromOtherTrackTypes, gCheatsShowVehiclesFromOtherTrackTypes, count); CheatEntrySerialise(
CheatEntrySerialise(ds, CheatType::FastLiftHill, gCheatsUnlockOperatingLimits, count); ds, CheatType::ShowVehiclesFromOtherTrackTypes, gameState.Cheats.ShowVehiclesFromOtherTrackTypes, count);
CheatEntrySerialise(ds, CheatType::DisableBrakesFailure, gCheatsDisableBrakesFailure, count); CheatEntrySerialise(ds, CheatType::FastLiftHill, gameState.Cheats.UnlockOperatingLimits, count);
CheatEntrySerialise(ds, CheatType::DisableAllBreakdowns, gCheatsDisableAllBreakdowns, count); CheatEntrySerialise(ds, CheatType::DisableBrakesFailure, gameState.Cheats.DisableBrakesFailure, count);
CheatEntrySerialise(ds, CheatType::BuildInPauseMode, gCheatsBuildInPauseMode, count); CheatEntrySerialise(ds, CheatType::DisableAllBreakdowns, gameState.Cheats.DisableAllBreakdowns, count);
CheatEntrySerialise(ds, CheatType::IgnoreRideIntensity, gCheatsIgnoreRideIntensity, count); CheatEntrySerialise(ds, CheatType::BuildInPauseMode, gameState.Cheats.BuildInPauseMode, count);
CheatEntrySerialise(ds, CheatType::DisableVandalism, gCheatsDisableVandalism, count); CheatEntrySerialise(ds, CheatType::IgnoreRideIntensity, gameState.Cheats.IgnoreRideIntensity, count);
CheatEntrySerialise(ds, CheatType::DisableLittering, gCheatsDisableLittering, count); CheatEntrySerialise(ds, CheatType::DisableVandalism, gameState.Cheats.DisableVandalism, count);
CheatEntrySerialise(ds, CheatType::NeverEndingMarketing, gCheatsNeverendingMarketing, count); CheatEntrySerialise(ds, CheatType::DisableLittering, gameState.Cheats.DisableLittering, count);
CheatEntrySerialise(ds, CheatType::FreezeWeather, gCheatsFreezeWeather, count); CheatEntrySerialise(ds, CheatType::NeverEndingMarketing, gameState.Cheats.NeverendingMarketing, count);
CheatEntrySerialise(ds, CheatType::DisableTrainLengthLimit, gCheatsDisableTrainLengthLimit, count); CheatEntrySerialise(ds, CheatType::FreezeWeather, gameState.Cheats.FreezeWeather, count);
CheatEntrySerialise(ds, CheatType::DisablePlantAging, gCheatsDisablePlantAging, count); CheatEntrySerialise(ds, CheatType::DisableTrainLengthLimit, gameState.Cheats.DisableTrainLengthLimit, count);
CheatEntrySerialise(ds, CheatType::EnableChainLiftOnAllTrack, gCheatsEnableChainLiftOnAllTrack, count); CheatEntrySerialise(ds, CheatType::DisablePlantAging, gameState.Cheats.DisablePlantAging, count);
CheatEntrySerialise(ds, CheatType::AllowArbitraryRideTypeChanges, gCheatsAllowArbitraryRideTypeChanges, count); CheatEntrySerialise(ds, CheatType::EnableChainLiftOnAllTrack, gameState.Cheats.EnableChainLiftOnAllTrack, count);
CheatEntrySerialise(ds, CheatType::DisableRideValueAging, gCheatsDisableRideValueAging, count); CheatEntrySerialise(
CheatEntrySerialise(ds, CheatType::IgnoreResearchStatus, gCheatsIgnoreResearchStatus, count); ds, CheatType::AllowArbitraryRideTypeChanges, gameState.Cheats.AllowArbitraryRideTypeChanges, count);
CheatEntrySerialise(ds, CheatType::EnableAllDrawableTrackPieces, gCheatsEnableAllDrawableTrackPieces, count); CheatEntrySerialise(ds, CheatType::DisableRideValueAging, gameState.Cheats.DisableRideValueAging, count);
CheatEntrySerialise(ds, CheatType::AllowTrackPlaceInvalidHeights, gCheatsAllowTrackPlaceInvalidHeights, count); CheatEntrySerialise(ds, CheatType::IgnoreResearchStatus, gameState.Cheats.IgnoreResearchStatus, count);
CheatEntrySerialise(ds, CheatType::AllowRegularPathAsQueue, gCheatsAllowRegularPathAsQueue, count); CheatEntrySerialise(ds, CheatType::EnableAllDrawableTrackPieces, gameState.Cheats.EnableAllDrawableTrackPieces, count);
CheatEntrySerialise(ds, CheatType::AllowSpecialColourSchemes, gCheatsAllowSpecialColourSchemes, count); CheatEntrySerialise(
CheatEntrySerialise(ds, CheatType::MakeDestructible, gCheatsMakeAllDestructible, count); ds, CheatType::AllowTrackPlaceInvalidHeights, gameState.Cheats.AllowTrackPlaceInvalidHeights, count);
CheatEntrySerialise(ds, CheatType::SetStaffSpeed, gCheatsSelectedStaffSpeed, count); CheatEntrySerialise(ds, CheatType::AllowRegularPathAsQueue, gameState.Cheats.AllowRegularPathAsQueue, count);
CheatEntrySerialise(ds, CheatType::AllowSpecialColourSchemes, gameState.Cheats.AllowSpecialColourSchemes, count);
CheatEntrySerialise(ds, CheatType::MakeDestructible, gameState.Cheats.MakeAllDestructible, count);
CheatEntrySerialise(ds, CheatType::SetStaffSpeed, gameState.Cheats.SelectedStaffSpeed, count);
// Remember current position and update count. // Remember current position and update count.
uint64_t endOffset = stream.GetPosition(); uint64_t endOffset = stream.GetPosition();
@ -161,85 +140,85 @@ void CheatsSerialise(DataSerialiser& ds)
switch (static_cast<CheatType>(type)) switch (static_cast<CheatType>(type))
{ {
case CheatType::SandboxMode: case CheatType::SandboxMode:
ds << gCheatsSandboxMode; ds << gameState.Cheats.SandboxMode;
break; break;
case CheatType::DisableClearanceChecks: case CheatType::DisableClearanceChecks:
ds << gCheatsDisableClearanceChecks; ds << gameState.Cheats.DisableClearanceChecks;
break; break;
case CheatType::DisableSupportLimits: case CheatType::DisableSupportLimits:
ds << gCheatsDisableSupportLimits; ds << gameState.Cheats.DisableSupportLimits;
break; break;
case CheatType::ShowAllOperatingModes: case CheatType::ShowAllOperatingModes:
ds << gCheatsShowAllOperatingModes; ds << gameState.Cheats.ShowAllOperatingModes;
break; break;
case CheatType::ShowVehiclesFromOtherTrackTypes: case CheatType::ShowVehiclesFromOtherTrackTypes:
ds << gCheatsShowVehiclesFromOtherTrackTypes; ds << gameState.Cheats.ShowVehiclesFromOtherTrackTypes;
break; break;
case CheatType::FastLiftHill: case CheatType::FastLiftHill:
ds << gCheatsUnlockOperatingLimits; ds << gameState.Cheats.UnlockOperatingLimits;
break; break;
case CheatType::DisableBrakesFailure: case CheatType::DisableBrakesFailure:
ds << gCheatsDisableBrakesFailure; ds << gameState.Cheats.DisableBrakesFailure;
break; break;
case CheatType::DisableAllBreakdowns: case CheatType::DisableAllBreakdowns:
ds << gCheatsDisableAllBreakdowns; ds << gameState.Cheats.DisableAllBreakdowns;
break; break;
case CheatType::BuildInPauseMode: case CheatType::BuildInPauseMode:
ds << gCheatsBuildInPauseMode; ds << gameState.Cheats.BuildInPauseMode;
break; break;
case CheatType::IgnoreRideIntensity: case CheatType::IgnoreRideIntensity:
ds << gCheatsIgnoreRideIntensity; ds << gameState.Cheats.IgnoreRideIntensity;
break; break;
case CheatType::DisableVandalism: case CheatType::DisableVandalism:
ds << gCheatsDisableVandalism; ds << gameState.Cheats.DisableVandalism;
break; break;
case CheatType::DisableLittering: case CheatType::DisableLittering:
ds << gCheatsDisableLittering; ds << gameState.Cheats.DisableLittering;
break; break;
case CheatType::NeverEndingMarketing: case CheatType::NeverEndingMarketing:
ds << gCheatsNeverendingMarketing; ds << gameState.Cheats.NeverendingMarketing;
break; break;
case CheatType::FreezeWeather: case CheatType::FreezeWeather:
ds << gCheatsFreezeWeather; ds << gameState.Cheats.FreezeWeather;
break; break;
case CheatType::DisableTrainLengthLimit: case CheatType::DisableTrainLengthLimit:
ds << gCheatsDisableTrainLengthLimit; ds << gameState.Cheats.DisableTrainLengthLimit;
break; break;
case CheatType::DisablePlantAging: case CheatType::DisablePlantAging:
ds << gCheatsDisablePlantAging; ds << gameState.Cheats.DisablePlantAging;
break; break;
case CheatType::EnableChainLiftOnAllTrack: case CheatType::EnableChainLiftOnAllTrack:
ds << gCheatsEnableChainLiftOnAllTrack; ds << gameState.Cheats.EnableChainLiftOnAllTrack;
break; break;
case CheatType::AllowArbitraryRideTypeChanges: case CheatType::AllowArbitraryRideTypeChanges:
ds << gCheatsAllowArbitraryRideTypeChanges; ds << gameState.Cheats.AllowArbitraryRideTypeChanges;
break; break;
case CheatType::DisableRideValueAging: case CheatType::DisableRideValueAging:
ds << gCheatsDisableRideValueAging; ds << gameState.Cheats.DisableRideValueAging;
break; break;
case CheatType::IgnoreResearchStatus: case CheatType::IgnoreResearchStatus:
ds << gCheatsIgnoreResearchStatus; ds << gameState.Cheats.IgnoreResearchStatus;
break; break;
case CheatType::EnableAllDrawableTrackPieces: case CheatType::EnableAllDrawableTrackPieces:
ds << gCheatsEnableAllDrawableTrackPieces; ds << gameState.Cheats.EnableAllDrawableTrackPieces;
break; break;
case CheatType::AllowTrackPlaceInvalidHeights: case CheatType::AllowTrackPlaceInvalidHeights:
ds << gCheatsAllowTrackPlaceInvalidHeights; ds << gameState.Cheats.AllowTrackPlaceInvalidHeights;
break; break;
case CheatType::NoCapOnQueueLengthDummy: case CheatType::NoCapOnQueueLengthDummy:
ds << dummyBool; ds << dummyBool;
break; break;
case CheatType::AllowRegularPathAsQueue: case CheatType::AllowRegularPathAsQueue:
ds << gCheatsAllowRegularPathAsQueue; ds << gameState.Cheats.AllowRegularPathAsQueue;
break; break;
case CheatType::AllowSpecialColourSchemes: case CheatType::AllowSpecialColourSchemes:
ds << gCheatsAllowSpecialColourSchemes; ds << gameState.Cheats.AllowSpecialColourSchemes;
break; break;
case CheatType::MakeDestructible: case CheatType::MakeDestructible:
ds << gCheatsMakeAllDestructible; ds << gameState.Cheats.MakeAllDestructible;
break; break;
case CheatType::SetStaffSpeed: case CheatType::SetStaffSpeed:
ds << gCheatsSelectedStaffSpeed; ds << gameState.Cheats.SelectedStaffSpeed;
break; break;
default: default:
break; break;

55
src/openrct2/Cheats.h
View File

@ -18,32 +18,35 @@ enum class StaffSpeedCheat
Fast, Fast,
}; };
extern bool gCheatsSandboxMode; struct CheatsState
extern bool gCheatsDisableClearanceChecks; {
extern bool gCheatsDisableSupportLimits; bool SandboxMode;
extern bool gCheatsShowAllOperatingModes; bool DisableClearanceChecks;
extern bool gCheatsShowVehiclesFromOtherTrackTypes; bool DisableSupportLimits;
extern bool gCheatsUnlockOperatingLimits; bool ShowAllOperatingModes;
extern bool gCheatsDisableBrakesFailure; bool ShowVehiclesFromOtherTrackTypes;
extern bool gCheatsDisableAllBreakdowns; bool UnlockOperatingLimits;
extern bool gCheatsBuildInPauseMode; bool DisableBrakesFailure;
extern bool gCheatsIgnoreRideIntensity; bool DisableAllBreakdowns;
extern bool gCheatsDisableVandalism; bool BuildInPauseMode;
extern bool gCheatsDisableLittering; bool IgnoreRideIntensity;
extern bool gCheatsNeverendingMarketing; bool DisableVandalism;
extern bool gCheatsFreezeWeather; bool DisableLittering;
extern bool gCheatsDisableTrainLengthLimit; bool NeverendingMarketing;
extern bool gCheatsDisablePlantAging; bool FreezeWeather;
extern bool gCheatsDisableRideValueAging; bool DisableTrainLengthLimit;
extern bool gCheatsEnableChainLiftOnAllTrack; bool DisablePlantAging;
extern bool gCheatsAllowArbitraryRideTypeChanges; bool DisableRideValueAging;
extern bool gCheatsIgnoreResearchStatus; bool EnableChainLiftOnAllTrack;
extern bool gCheatsEnableAllDrawableTrackPieces; bool AllowArbitraryRideTypeChanges;
extern bool gCheatsAllowTrackPlaceInvalidHeights; bool IgnoreResearchStatus;
extern bool gCheatsAllowRegularPathAsQueue; bool EnableAllDrawableTrackPieces;
extern bool gCheatsAllowSpecialColourSchemes; bool AllowTrackPlaceInvalidHeights;
extern bool gCheatsMakeAllDestructible; bool AllowRegularPathAsQueue;
extern StaffSpeedCheat gCheatsSelectedStaffSpeed; bool AllowSpecialColourSchemes;
bool MakeAllDestructible;
StaffSpeedCheat SelectedStaffSpeed;
};
enum class CheatType : int32_t enum class CheatType : int32_t
{ {

3
src/openrct2/GameState.h
View File

@ -9,6 +9,7 @@
#pragma once #pragma once
#include "Cheats.h"
#include "Date.h" #include "Date.h"
#include "Editor.h" #include "Editor.h"
#include "Limits.h" #include "Limits.h"
@ -128,6 +129,8 @@ namespace OpenRCT2
* In a difficult guest generation scenario, no guests will be generated if over this value. * In a difficult guest generation scenario, no guests will be generated if over this value.
*/ */
uint32_t SuggestedGuestMaximum; uint32_t SuggestedGuestMaximum;
CheatsState Cheats;
}; };
GameState_t& GetGameState(); GameState_t& GetGameState();

50
src/openrct2/actions/CheatSetAction.cpp
View File

@ -98,50 +98,50 @@ GameActions::Result CheatSetAction::Execute() const
switch (static_cast<CheatType>(_cheatType.id)) switch (static_cast<CheatType>(_cheatType.id))
{ {
case CheatType::SandboxMode: case CheatType::SandboxMode:
gCheatsSandboxMode = _param1 != 0; GetGameState().Cheats.SandboxMode = _param1 != 0;
WindowInvalidateByClass(WindowClass::Map); WindowInvalidateByClass(WindowClass::Map);
WindowInvalidateByClass(WindowClass::Footpath); WindowInvalidateByClass(WindowClass::Footpath);
break; break;
case CheatType::DisableClearanceChecks: case CheatType::DisableClearanceChecks:
gCheatsDisableClearanceChecks = _param1 != 0; GetGameState().Cheats.DisableClearanceChecks = _param1 != 0;
// Required to update the clearance checks overlay on the Cheats button. // Required to update the clearance checks overlay on the Cheats button.
WindowInvalidateByClass(WindowClass::TopToolbar); WindowInvalidateByClass(WindowClass::TopToolbar);
break; break;
case CheatType::DisableSupportLimits: case CheatType::DisableSupportLimits:
gCheatsDisableSupportLimits = _param1 != 0; GetGameState().Cheats.DisableSupportLimits = _param1 != 0;
break; break;
case CheatType::ShowAllOperatingModes: case CheatType::ShowAllOperatingModes:
gCheatsShowAllOperatingModes = _param1 != 0; GetGameState().Cheats.ShowAllOperatingModes = _param1 != 0;
break; break;
case CheatType::ShowVehiclesFromOtherTrackTypes: case CheatType::ShowVehiclesFromOtherTrackTypes:
gCheatsShowVehiclesFromOtherTrackTypes = _param1 != 0; GetGameState().Cheats.ShowVehiclesFromOtherTrackTypes = _param1 != 0;
break; break;
case CheatType::FastLiftHill: case CheatType::FastLiftHill:
gCheatsUnlockOperatingLimits = _param1 != 0; GetGameState().Cheats.UnlockOperatingLimits = _param1 != 0;
break; break;
case CheatType::DisableBrakesFailure: case CheatType::DisableBrakesFailure:
gCheatsDisableBrakesFailure = _param1 != 0; GetGameState().Cheats.DisableBrakesFailure = _param1 != 0;
break; break;
case CheatType::DisableAllBreakdowns: case CheatType::DisableAllBreakdowns:
gCheatsDisableAllBreakdowns = _param1 != 0; GetGameState().Cheats.DisableAllBreakdowns = _param1 != 0;
break; break;
case CheatType::DisableTrainLengthLimit: case CheatType::DisableTrainLengthLimit:
gCheatsDisableTrainLengthLimit = _param1 != 0; GetGameState().Cheats.DisableTrainLengthLimit = _param1 != 0;
break; break;
case CheatType::EnableChainLiftOnAllTrack: case CheatType::EnableChainLiftOnAllTrack:
gCheatsEnableChainLiftOnAllTrack = _param1 != 0; GetGameState().Cheats.EnableChainLiftOnAllTrack = _param1 != 0;
break; break;
case CheatType::BuildInPauseMode: case CheatType::BuildInPauseMode:
gCheatsBuildInPauseMode = _param1 != 0; GetGameState().Cheats.BuildInPauseMode = _param1 != 0;
break; break;
case CheatType::IgnoreRideIntensity: case CheatType::IgnoreRideIntensity:
gCheatsIgnoreRideIntensity = _param1 != 0; GetGameState().Cheats.IgnoreRideIntensity = _param1 != 0;
break; break;
case CheatType::DisableVandalism: case CheatType::DisableVandalism:
gCheatsDisableVandalism = _param1 != 0; GetGameState().Cheats.DisableVandalism = _param1 != 0;
break; break;
case CheatType::DisableLittering: case CheatType::DisableLittering:
gCheatsDisableLittering = _param1 != 0; GetGameState().Cheats.DisableLittering = _param1 != 0;
break; break;
case CheatType::NoMoney: case CheatType::NoMoney:
SetScenarioNoMoney(_param1 != 0); SetScenarioNoMoney(_param1 != 0);
@ -180,7 +180,7 @@ GameActions::Result CheatSetAction::Execute() const
RemoveLitter(); RemoveLitter();
break; break;
case CheatType::DisablePlantAging: case CheatType::DisablePlantAging:
gCheatsDisablePlantAging = _param1 != 0; GetGameState().Cheats.DisablePlantAging = _param1 != 0;
break; break;
case CheatType::SetStaffSpeed: case CheatType::SetStaffSpeed:
SetStaffSpeed(_param1); SetStaffSpeed(_param1);
@ -189,7 +189,7 @@ GameActions::Result CheatSetAction::Execute() const
RenewRides(); RenewRides();
break; break;
case CheatType::MakeDestructible: case CheatType::MakeDestructible:
gCheatsMakeAllDestructible = _param1 != 0; GetGameState().Cheats.MakeAllDestructible = _param1 != 0;
WindowInvalidateByClass(WindowClass::Ride); WindowInvalidateByClass(WindowClass::Ride);
break; break;
case CheatType::FixRides: case CheatType::FixRides:
@ -209,10 +209,10 @@ GameActions::Result CheatSetAction::Execute() const
ClimateForceWeather(WeatherType{ static_cast<uint8_t>(_param1) }); ClimateForceWeather(WeatherType{ static_cast<uint8_t>(_param1) });
break; break;
case CheatType::FreezeWeather: case CheatType::FreezeWeather:
gCheatsFreezeWeather = _param1 != 0; GetGameState().Cheats.FreezeWeather = _param1 != 0;
break; break;
case CheatType::NeverEndingMarketing: case CheatType::NeverEndingMarketing:
gCheatsNeverendingMarketing = _param1 != 0; GetGameState().Cheats.NeverendingMarketing = _param1 != 0;
break; break;
case CheatType::OpenClosePark: case CheatType::OpenClosePark:
ParkSetOpen(!ParkIsOpen()); ParkSetOpen(!ParkIsOpen());
@ -224,20 +224,20 @@ GameActions::Result CheatSetAction::Execute() const
ParkSetForcedRating(_param1); ParkSetForcedRating(_param1);
break; break;
case CheatType::AllowArbitraryRideTypeChanges: case CheatType::AllowArbitraryRideTypeChanges:
gCheatsAllowArbitraryRideTypeChanges = _param1 != 0; GetGameState().Cheats.AllowArbitraryRideTypeChanges = _param1 != 0;
WindowInvalidateByClass(WindowClass::Ride); WindowInvalidateByClass(WindowClass::Ride);
break; break;
case CheatType::OwnAllLand: case CheatType::OwnAllLand:
OwnAllLand(); OwnAllLand();
break; break;
case CheatType::DisableRideValueAging: case CheatType::DisableRideValueAging:
gCheatsDisableRideValueAging = _param1 != 0; GetGameState().Cheats.DisableRideValueAging = _param1 != 0;
break; break;
case CheatType::IgnoreResearchStatus: case CheatType::IgnoreResearchStatus:
gCheatsIgnoreResearchStatus = _param1 != 0; GetGameState().Cheats.IgnoreResearchStatus = _param1 != 0;
break; break;
case CheatType::EnableAllDrawableTrackPieces: case CheatType::EnableAllDrawableTrackPieces:
gCheatsEnableAllDrawableTrackPieces = _param1 != 0; GetGameState().Cheats.EnableAllDrawableTrackPieces = _param1 != 0;
break; break;
case CheatType::CreateDucks: case CheatType::CreateDucks:
CreateDucks(_param1); CreateDucks(_param1);
@ -246,13 +246,13 @@ GameActions::Result CheatSetAction::Execute() const
Duck::RemoveAll(); Duck::RemoveAll();
break; break;
case CheatType::AllowTrackPlaceInvalidHeights: case CheatType::AllowTrackPlaceInvalidHeights:
gCheatsAllowTrackPlaceInvalidHeights = _param1 != 0; GetGameState().Cheats.AllowTrackPlaceInvalidHeights = _param1 != 0;
break; break;
case CheatType::AllowRegularPathAsQueue: case CheatType::AllowRegularPathAsQueue:
gCheatsAllowRegularPathAsQueue = _param1 != 0; GetGameState().Cheats.AllowRegularPathAsQueue = _param1 != 0;
break; break;
case CheatType::AllowSpecialColourSchemes: case CheatType::AllowSpecialColourSchemes:
gCheatsAllowSpecialColourSchemes = static_cast<bool>(_param1); GetGameState().Cheats.AllowSpecialColourSchemes = static_cast<bool>(_param1);
break; break;
case CheatType::RemoveParkFences: case CheatType::RemoveParkFences:
RemoveParkFences(); RemoveParkFences();

3
src/openrct2/actions/ClearAction.cpp
View File

@ -239,5 +239,6 @@ void ClearAction::ResetClearLargeSceneryFlag()
bool ClearAction::MapCanClearAt(const CoordsXY& location) bool ClearAction::MapCanClearAt(const CoordsXY& location)
{ {
return (gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) || gCheatsSandboxMode || MapIsLocationOwnedOrHasRights(location); return (gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) || GetGameState().Cheats.SandboxMode
|| MapIsLocationOwnedOrHasRights(location);
} }

4
src/openrct2/actions/FootpathAdditionPlaceAction.cpp
View File

@ -10,6 +10,7 @@
#include "FootpathAdditionPlaceAction.h" #include "FootpathAdditionPlaceAction.h"
#include "../Cheats.h" #include "../Cheats.h"
#include "../GameState.h"
#include "../OpenRCT2.h" #include "../OpenRCT2.h"
#include "../core/MemoryStream.h" #include "../core/MemoryStream.h"
#include "../interface/Window.h" #include "../interface/Window.h"
@ -57,7 +58,8 @@ GameActions::Result FootpathAdditionPlaceAction::Query() const
return GameActions::Result(GameActions::Status::InvalidParameters, STR_CANT_POSITION_THIS_HERE, STR_OFF_EDGE_OF_MAP); return GameActions::Result(GameActions::Status::InvalidParameters, STR_CANT_POSITION_THIS_HERE, STR_OFF_EDGE_OF_MAP);
} }
if (!((gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) || gCheatsSandboxMode) && !MapIsLocationOwned(_loc)) if (!((gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) || OpenRCT2::GetGameState().Cheats.SandboxMode)
&& !MapIsLocationOwned(_loc))
{ {
return GameActions::Result(GameActions::Status::Disallowed, STR_CANT_POSITION_THIS_HERE, STR_LAND_NOT_OWNED_BY_PARK); return GameActions::Result(GameActions::Status::Disallowed, STR_CANT_POSITION_THIS_HERE, STR_LAND_NOT_OWNED_BY_PARK);
} }

4
src/openrct2/actions/FootpathAdditionRemoveAction.cpp
View File

@ -10,6 +10,7 @@
#include "FootpathAdditionRemoveAction.h" #include "FootpathAdditionRemoveAction.h"
#include "../Cheats.h" #include "../Cheats.h"
#include "../GameState.h"
#include "../OpenRCT2.h" #include "../OpenRCT2.h"
#include "../core/MemoryStream.h" #include "../core/MemoryStream.h"
#include "../interface/Window.h" #include "../interface/Window.h"
@ -49,7 +50,8 @@ GameActions::Result FootpathAdditionRemoveAction::Query() const
return GameActions::Result(GameActions::Status::InvalidParameters, STR_CANT_REMOVE_THIS, STR_OFF_EDGE_OF_MAP); return GameActions::Result(GameActions::Status::InvalidParameters, STR_CANT_REMOVE_THIS, STR_OFF_EDGE_OF_MAP);
} }
if (!((gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) || gCheatsSandboxMode) && !MapIsLocationOwned(_loc)) if (!((gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) || OpenRCT2::GetGameState().Cheats.SandboxMode)
&& !MapIsLocationOwned(_loc))
{ {
return GameActions::Result(GameActions::Status::Disallowed, STR_CANT_REMOVE_THIS, STR_LAND_NOT_OWNED_BY_PARK); return GameActions::Result(GameActions::Status::Disallowed, STR_CANT_REMOVE_THIS, STR_LAND_NOT_OWNED_BY_PARK);
} }

7
src/openrct2/actions/FootpathLayoutPlaceAction.cpp
View File

@ -10,6 +10,7 @@
#include "FootpathLayoutPlaceAction.h" #include "FootpathLayoutPlaceAction.h"
#include "../Cheats.h" #include "../Cheats.h"
#include "../GameState.h"
#include "../OpenRCT2.h" #include "../OpenRCT2.h"
#include "../core/MemoryStream.h" #include "../core/MemoryStream.h"
#include "../interface/Window.h" #include "../interface/Window.h"
@ -23,6 +24,8 @@
#include "../world/Surface.h" #include "../world/Surface.h"
#include "../world/Wall.h" #include "../world/Wall.h"
using namespace OpenRCT2;
FootpathLayoutPlaceAction::FootpathLayoutPlaceAction( FootpathLayoutPlaceAction::FootpathLayoutPlaceAction(
const CoordsXYZ& loc, uint8_t slope, ObjectEntryIndex type, ObjectEntryIndex railingsType, uint8_t edges, const CoordsXYZ& loc, uint8_t slope, ObjectEntryIndex type, ObjectEntryIndex railingsType, uint8_t edges,
PathConstructFlags constructFlags) PathConstructFlags constructFlags)
@ -73,7 +76,7 @@ GameActions::Result FootpathLayoutPlaceAction::Query() const
GameActions::Status::InvalidParameters, STR_RIDE_CONSTRUCTION_CANT_CONSTRUCT_THIS_HERE, STR_OFF_EDGE_OF_MAP); GameActions::Status::InvalidParameters, STR_RIDE_CONSTRUCTION_CANT_CONSTRUCT_THIS_HERE, STR_OFF_EDGE_OF_MAP);
} }
if (!((gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) || gCheatsSandboxMode) && !MapIsLocationOwned(_loc)) if (!((gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) || GetGameState().Cheats.SandboxMode) && !MapIsLocationOwned(_loc))
{ {
return GameActions::Result( return GameActions::Result(
GameActions::Status::Disallowed, STR_RIDE_CONSTRUCTION_CANT_CONSTRUCT_THIS_HERE, STR_LAND_NOT_OWNED_BY_PARK); GameActions::Status::Disallowed, STR_RIDE_CONSTRUCTION_CANT_CONSTRUCT_THIS_HERE, STR_LAND_NOT_OWNED_BY_PARK);
@ -164,7 +167,7 @@ GameActions::Result FootpathLayoutPlaceAction::ElementInsertQuery(GameActions::R
const auto clearanceData = canBuild.GetData<ConstructClearResult>(); const auto clearanceData = canBuild.GetData<ConstructClearResult>();
gFootpathGroundFlags = clearanceData.GroundFlags; gFootpathGroundFlags = clearanceData.GroundFlags;
if (!gCheatsDisableClearanceChecks && (clearanceData.GroundFlags & ELEMENT_IS_UNDERWATER)) if (!GetGameState().Cheats.DisableClearanceChecks && (clearanceData.GroundFlags & ELEMENT_IS_UNDERWATER))
{ {
return GameActions::Result( return GameActions::Result(
GameActions::Status::Disallowed, STR_RIDE_CONSTRUCTION_CANT_CONSTRUCT_THIS_HERE, STR_CANT_BUILD_THIS_UNDERWATER); GameActions::Status::Disallowed, STR_RIDE_CONSTRUCTION_CANT_CONSTRUCT_THIS_HERE, STR_CANT_BUILD_THIS_UNDERWATER);

6
src/openrct2/actions/FootpathPlaceAction.cpp
View File

@ -78,7 +78,7 @@ GameActions::Result FootpathPlaceAction::Query() const
return GameActions::Result(GameActions::Status::InvalidParameters, STR_CANT_BUILD_FOOTPATH_HERE, STR_OFF_EDGE_OF_MAP); return GameActions::Result(GameActions::Status::InvalidParameters, STR_CANT_BUILD_FOOTPATH_HERE, STR_OFF_EDGE_OF_MAP);
} }
if (!((gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) || gCheatsSandboxMode) && !MapIsLocationOwned(_loc)) if (!((gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) || GetGameState().Cheats.SandboxMode) && !MapIsLocationOwned(_loc))
{ {
return GameActions::Result(GameActions::Status::Disallowed, STR_CANT_BUILD_FOOTPATH_HERE, STR_LAND_NOT_OWNED_BY_PARK); return GameActions::Result(GameActions::Status::Disallowed, STR_CANT_BUILD_FOOTPATH_HERE, STR_LAND_NOT_OWNED_BY_PARK);
} }
@ -132,7 +132,7 @@ GameActions::Result FootpathPlaceAction::Execute() const
if (!(GetFlags() & GAME_COMMAND_FLAG_GHOST)) if (!(GetFlags() & GAME_COMMAND_FLAG_GHOST))
{ {
if (_direction != INVALID_DIRECTION && !gCheatsDisableClearanceChecks) if (_direction != INVALID_DIRECTION && !GetGameState().Cheats.DisableClearanceChecks)
{ {
// It is possible, let's remove walls between the old and new piece of path // It is possible, let's remove walls between the old and new piece of path
auto zLow = _loc.z; auto zLow = _loc.z;
@ -314,7 +314,7 @@ GameActions::Result FootpathPlaceAction::ElementInsertQuery(GameActions::Result
const auto clearanceData = canBuild.GetData<ConstructClearResult>(); const auto clearanceData = canBuild.GetData<ConstructClearResult>();
gFootpathGroundFlags = clearanceData.GroundFlags; gFootpathGroundFlags = clearanceData.GroundFlags;
if (!gCheatsDisableClearanceChecks && (clearanceData.GroundFlags & ELEMENT_IS_UNDERWATER)) if (!GetGameState().Cheats.DisableClearanceChecks && (clearanceData.GroundFlags & ELEMENT_IS_UNDERWATER))
{ {
return GameActions::Result( return GameActions::Result(
GameActions::Status::Disallowed, STR_CANT_BUILD_FOOTPATH_HERE, STR_CANT_BUILD_THIS_UNDERWATER); GameActions::Status::Disallowed, STR_CANT_BUILD_FOOTPATH_HERE, STR_CANT_BUILD_THIS_UNDERWATER);

5
src/openrct2/actions/FootpathRemoveAction.cpp
View File

@ -10,6 +10,7 @@
#include "FootpathRemoveAction.h" #include "FootpathRemoveAction.h"
#include "../Cheats.h" #include "../Cheats.h"
#include "../GameState.h"
#include "../OpenRCT2.h" #include "../OpenRCT2.h"
#include "../core/MemoryStream.h" #include "../core/MemoryStream.h"
#include "../interface/Window.h" #include "../interface/Window.h"
@ -21,6 +22,8 @@
#include "../world/Wall.h" #include "../world/Wall.h"
#include "BannerRemoveAction.h" #include "BannerRemoveAction.h"
using namespace OpenRCT2;
FootpathRemoveAction::FootpathRemoveAction(const CoordsXYZ& location) FootpathRemoveAction::FootpathRemoveAction(const CoordsXYZ& location)
: _loc(location) : _loc(location)
{ {
@ -56,7 +59,7 @@ GameActions::Result FootpathRemoveAction::Query() const
GameActions::Status::InvalidParameters, STR_CANT_REMOVE_FOOTPATH_FROM_HERE, STR_OFF_EDGE_OF_MAP); GameActions::Status::InvalidParameters, STR_CANT_REMOVE_FOOTPATH_FROM_HERE, STR_OFF_EDGE_OF_MAP);
} }
if (!((gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) || gCheatsSandboxMode) && !MapIsLocationOwned(_loc)) if (!((gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) || GetGameState().Cheats.SandboxMode) && !MapIsLocationOwned(_loc))
{ {
return GameActions::Result( return GameActions::Result(
GameActions::Status::NotOwned, STR_CANT_REMOVE_FOOTPATH_FROM_HERE, STR_LAND_NOT_OWNED_BY_PARK); GameActions::Status::NotOwned, STR_CANT_REMOVE_FOOTPATH_FROM_HERE, STR_LAND_NOT_OWNED_BY_PARK);

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

@ -184,7 +184,7 @@ namespace GameActions
{ {
if (gGamePaused == 0) if (gGamePaused == 0)
return true; return true;
if (gCheatsBuildInPauseMode) if (GetGameState().Cheats.BuildInPauseMode)
return true; return true;
if (actionFlags & GameActions::Flags::AllowWhilePaused) if (actionFlags & GameActions::Flags::AllowWhilePaused)
return true; return true;

3
src/openrct2/actions/LandLowerAction.cpp
View File

@ -10,6 +10,7 @@
#include "LandLowerAction.h" #include "LandLowerAction.h"
#include "../Context.h" #include "../Context.h"
#include "../GameState.h"
#include "../OpenRCT2.h" #include "../OpenRCT2.h"
#include "../actions/LandSetHeightAction.h" #include "../actions/LandSetHeightAction.h"
#include "../audio/audio.h" #include "../audio/audio.h"
@ -93,7 +94,7 @@ GameActions::Result LandLowerAction::QueryExecute(bool isExecuting) const
if (surfaceElement == nullptr) if (surfaceElement == nullptr)
continue; continue;
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !gCheatsSandboxMode) if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !OpenRCT2::GetGameState().Cheats.SandboxMode)
{ {
if (!MapIsLocationInPark(CoordsXY{ x, y })) if (!MapIsLocationInPark(CoordsXY{ x, y }))
{ {

3
src/openrct2/actions/LandRaiseAction.cpp
View File

@ -11,6 +11,7 @@
#include "LandRaiseAction.h" #include "LandRaiseAction.h"
#include "../Context.h" #include "../Context.h"
#include "../GameState.h"
#include "../OpenRCT2.h" #include "../OpenRCT2.h"
#include "../actions/LandSetHeightAction.h" #include "../actions/LandSetHeightAction.h"
#include "../audio/audio.h" #include "../audio/audio.h"
@ -94,7 +95,7 @@ GameActions::Result LandRaiseAction::QueryExecute(bool isExecuting) const
if (surfaceElement == nullptr) if (surfaceElement == nullptr)
continue; continue;
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !gCheatsSandboxMode) if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !OpenRCT2::GetGameState().Cheats.SandboxMode)
{ {
if (!MapIsLocationInPark(CoordsXY{ x, y })) if (!MapIsLocationInPark(CoordsXY{ x, y }))
{ {

10
src/openrct2/actions/LandSetHeightAction.cpp
View File

@ -67,7 +67,7 @@ GameActions::Result LandSetHeightAction::Query() const
return GameActions::Result(GameActions::Status::Disallowed, STR_NONE, errorMessage); return GameActions::Result(GameActions::Status::Disallowed, STR_NONE, errorMessage);
} }
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !gCheatsSandboxMode) if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !GetGameState().Cheats.SandboxMode)
{ {
if (!MapIsLocationInPark(_coords)) if (!MapIsLocationInPark(_coords))
{ {
@ -76,7 +76,7 @@ GameActions::Result LandSetHeightAction::Query() const
} }
money64 sceneryRemovalCost = 0; money64 sceneryRemovalCost = 0;
if (!gCheatsDisableClearanceChecks) if (!GetGameState().Cheats.DisableClearanceChecks)
{ {
if (gameState.ParkFlags & PARK_FLAGS_FORBID_TREE_REMOVAL) if (gameState.ParkFlags & PARK_FLAGS_FORBID_TREE_REMOVAL)
{ {
@ -93,7 +93,7 @@ GameActions::Result LandSetHeightAction::Query() const
} }
// Check for ride support limits // Check for ride support limits
if (!gCheatsDisableSupportLimits) if (!GetGameState().Cheats.DisableSupportLimits)
{ {
errorMessage = CheckRideSupports(); errorMessage = CheckRideSupports();
if (errorMessage != STR_NONE) if (errorMessage != STR_NONE)
@ -124,7 +124,7 @@ GameActions::Result LandSetHeightAction::Query() const
return res; return res;
} }
if (!gCheatsDisableClearanceChecks) if (!GetGameState().Cheats.DisableClearanceChecks)
{ {
uint8_t zCorner = _height; uint8_t zCorner = _height;
if (_style & TILE_ELEMENT_SURFACE_RAISED_CORNERS_MASK) if (_style & TILE_ELEMENT_SURFACE_RAISED_CORNERS_MASK)
@ -157,7 +157,7 @@ GameActions::Result LandSetHeightAction::Execute() const
auto surfaceHeight = TileElementHeight(_coords); auto surfaceHeight = TileElementHeight(_coords);
FootpathRemoveLitter({ _coords, surfaceHeight }); FootpathRemoveLitter({ _coords, surfaceHeight });
if (!gCheatsDisableClearanceChecks) if (!GetGameState().Cheats.DisableClearanceChecks)
{ {
WallRemoveAt({ _coords, _height * 8 - 16, _height * 8 + 32 }); WallRemoveAt({ _coords, _height * 8 - 16, _height * 8 + 32 });
cost += GetSmallSceneryRemovalCost(); cost += GetSmallSceneryRemovalCost();

3
src/openrct2/actions/LandSetRightsAction.cpp
View File

@ -10,6 +10,7 @@
#include "LandSetRightsAction.h" #include "LandSetRightsAction.h"
#include "../Context.h" #include "../Context.h"
#include "../GameState.h"
#include "../OpenRCT2.h" #include "../OpenRCT2.h"
#include "../actions/LandSetHeightAction.h" #include "../actions/LandSetHeightAction.h"
#include "../audio/audio.h" #include "../audio/audio.h"
@ -82,7 +83,7 @@ GameActions::Result LandSetRightsAction::QueryExecute(bool isExecuting) const
res.Position = centre; res.Position = centre;
res.Expenditure = ExpenditureType::LandPurchase; res.Expenditure = ExpenditureType::LandPurchase;
if (!(gScreenFlags & SCREEN_FLAGS_EDITOR) && !gCheatsSandboxMode) if (!(gScreenFlags & SCREEN_FLAGS_EDITOR) && !GetGameState().Cheats.SandboxMode)
{ {
return GameActions::Result(GameActions::Status::NotInEditorMode, STR_NONE, STR_LAND_NOT_FOR_SALE); return GameActions::Result(GameActions::Status::NotInEditorMode, STR_NONE, STR_LAND_NOT_FOR_SALE);
} }

14
src/openrct2/actions/LargeSceneryPlaceAction.cpp
View File

@ -9,6 +9,7 @@
#include "LargeSceneryPlaceAction.h" #include "LargeSceneryPlaceAction.h"
#include "../GameState.h"
#include "../OpenRCT2.h" #include "../OpenRCT2.h"
#include "../management/Finance.h" #include "../management/Finance.h"
#include "../object/LargeSceneryEntry.h" #include "../object/LargeSceneryEntry.h"
@ -21,6 +22,8 @@
#include "../world/MapAnimation.h" #include "../world/MapAnimation.h"
#include "../world/Surface.h" #include "../world/Surface.h"
using namespace OpenRCT2;
LargeSceneryPlaceAction::LargeSceneryPlaceAction( LargeSceneryPlaceAction::LargeSceneryPlaceAction(
const CoordsXYZD& loc, ObjectEntryIndex sceneryType, uint8_t primaryColour, uint8_t secondaryColour, uint8_t tertiaryColour) const CoordsXYZD& loc, ObjectEntryIndex sceneryType, uint8_t primaryColour, uint8_t secondaryColour, uint8_t tertiaryColour)
: _loc(loc) : _loc(loc)
@ -81,7 +84,7 @@ GameActions::Result LargeSceneryPlaceAction::Query() const
return GameActions::Result(GameActions::Status::InvalidParameters, STR_CANT_POSITION_THIS_HERE, STR_NONE); return GameActions::Result(GameActions::Status::InvalidParameters, STR_CANT_POSITION_THIS_HERE, STR_NONE);
} }
auto* sceneryEntry = OpenRCT2::ObjectManager::GetObjectEntry<LargeSceneryEntry>(_sceneryType); auto* sceneryEntry = ObjectManager::GetObjectEntry<LargeSceneryEntry>(_sceneryType);
if (sceneryEntry == nullptr) if (sceneryEntry == nullptr)
{ {
LOG_ERROR("Invalid game command for scenery placement, sceneryType = %u", _sceneryType); LOG_ERROR("Invalid game command for scenery placement, sceneryType = %u", _sceneryType);
@ -134,7 +137,7 @@ GameActions::Result LargeSceneryPlaceAction::Query() const
const auto clearanceData = canBuild.GetData<ConstructClearResult>(); const auto clearanceData = canBuild.GetData<ConstructClearResult>();
int32_t tempSceneryGroundFlags = clearanceData.GroundFlags & (ELEMENT_IS_ABOVE_GROUND | ELEMENT_IS_UNDERGROUND); int32_t tempSceneryGroundFlags = clearanceData.GroundFlags & (ELEMENT_IS_ABOVE_GROUND | ELEMENT_IS_UNDERGROUND);
if (!gCheatsDisableClearanceChecks) if (!GetGameState().Cheats.DisableClearanceChecks)
{ {
if ((clearanceData.GroundFlags & ELEMENT_IS_UNDERWATER) || (clearanceData.GroundFlags & ELEMENT_IS_UNDERGROUND)) if ((clearanceData.GroundFlags & ELEMENT_IS_UNDERWATER) || (clearanceData.GroundFlags & ELEMENT_IS_UNDERGROUND))
{ {
@ -156,7 +159,8 @@ GameActions::Result LargeSceneryPlaceAction::Query() const
return GameActions::Result(GameActions::Status::Disallowed, STR_CANT_POSITION_THIS_HERE, STR_OFF_EDGE_OF_MAP); return GameActions::Result(GameActions::Status::Disallowed, STR_CANT_POSITION_THIS_HERE, STR_OFF_EDGE_OF_MAP);
} }
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !MapIsLocationOwned({ curTile, zLow }) && !gCheatsSandboxMode) if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !MapIsLocationOwned({ curTile, zLow })
&& !GetGameState().Cheats.SandboxMode)
{ {
return GameActions::Result( return GameActions::Result(
GameActions::Status::Disallowed, STR_CANT_POSITION_THIS_HERE, STR_LAND_NOT_OWNED_BY_PARK); GameActions::Status::Disallowed, STR_CANT_POSITION_THIS_HERE, STR_LAND_NOT_OWNED_BY_PARK);
@ -194,7 +198,7 @@ GameActions::Result LargeSceneryPlaceAction::Execute() const
money64 supportsCost = 0; money64 supportsCost = 0;
auto* sceneryEntry = OpenRCT2::ObjectManager::GetObjectEntry<LargeSceneryEntry>(_sceneryType); auto* sceneryEntry = ObjectManager::GetObjectEntry<LargeSceneryEntry>(_sceneryType);
if (sceneryEntry == nullptr) if (sceneryEntry == nullptr)
{ {
LOG_ERROR("Invalid game command for scenery placement, sceneryType = %u", _sceneryType); LOG_ERROR("Invalid game command for scenery placement, sceneryType = %u", _sceneryType);
@ -279,7 +283,7 @@ GameActions::Result LargeSceneryPlaceAction::Execute() const
if (!(GetFlags() & GAME_COMMAND_FLAG_GHOST)) if (!(GetFlags() & GAME_COMMAND_FLAG_GHOST))
{ {
FootpathRemoveLitter({ curTile, zLow }); FootpathRemoveLitter({ curTile, zLow });
if (!gCheatsDisableClearanceChecks) if (!GetGameState().Cheats.DisableClearanceChecks)
{ {
WallRemoveAt({ curTile, zLow, zHigh }); WallRemoveAt({ curTile, zLow, zHigh });
} }

4
src/openrct2/actions/LargeSceneryRemoveAction.cpp
View File

@ -92,7 +92,7 @@ GameActions::Result LargeSceneryRemoveAction::Query() const
auto currentTile = CoordsXYZ{ firstTile.x, firstTile.y, firstTile.z } + currentTileRotatedOffset; auto currentTile = CoordsXYZ{ firstTile.x, firstTile.y, firstTile.z } + currentTileRotatedOffset;
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !gCheatsSandboxMode) if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !GetGameState().Cheats.SandboxMode)
{ {
if (GetGameState().ParkFlags & PARK_FLAGS_FORBID_TREE_REMOVAL) if (GetGameState().ParkFlags & PARK_FLAGS_FORBID_TREE_REMOVAL)
{ {
@ -175,7 +175,7 @@ GameActions::Result LargeSceneryRemoveAction::Execute() const
auto currentTile = CoordsXYZ{ firstTile.x, firstTile.y, firstTile.z } + rotatedCurrentTile; auto currentTile = CoordsXYZ{ firstTile.x, firstTile.y, firstTile.z } + rotatedCurrentTile;
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !gCheatsSandboxMode) if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !GetGameState().Cheats.SandboxMode)
{ {
if (!MapIsLocationOwned({ currentTile.x, currentTile.y, currentTile.z })) if (!MapIsLocationOwned({ currentTile.x, currentTile.y, currentTile.z }))
{ {

3
src/openrct2/actions/LargeScenerySetColourAction.cpp
View File

@ -9,6 +9,7 @@
#include "LargeScenerySetColourAction.h" #include "LargeScenerySetColourAction.h"
#include "../GameState.h"
#include "../OpenRCT2.h" #include "../OpenRCT2.h"
#include "../management/Finance.h" #include "../management/Finance.h"
#include "../object/LargeSceneryEntry.h" #include "../object/LargeSceneryEntry.h"
@ -127,7 +128,7 @@ GameActions::Result LargeScenerySetColourAction::QueryExecute(bool isExecuting)
auto rotatedTileCoords = CoordsXYZ{ CoordsXY{ tile->x_offset, tile->y_offset }.Rotate(_loc.direction), tile->z_offset }; auto rotatedTileCoords = CoordsXYZ{ CoordsXY{ tile->x_offset, tile->y_offset }.Rotate(_loc.direction), tile->z_offset };
auto currentTile = CoordsXYZ{ baseTile.x, baseTile.y, baseTile.z } + rotatedTileCoords; auto currentTile = CoordsXYZ{ baseTile.x, baseTile.y, baseTile.z } + rotatedTileCoords;
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !gCheatsSandboxMode) if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !OpenRCT2::GetGameState().Cheats.SandboxMode)
{ {
if (!MapIsLocationOwned(currentTile)) if (!MapIsLocationOwned(currentTile))
{ {

5
src/openrct2/actions/MazePlaceTrackAction.cpp
View File

@ -8,6 +8,7 @@
*****************************************************************************/ *****************************************************************************/
#include "MazePlaceTrackAction.h" #include "MazePlaceTrackAction.h"
#include "../GameState.h"
#include "../management/Finance.h" #include "../management/Finance.h"
#include "../ride/RideData.h" #include "../ride/RideData.h"
#include "../ride/TrackData.h" #include "../ride/TrackData.h"
@ -56,7 +57,7 @@ GameActions::Result MazePlaceTrackAction::Query() const
res.ErrorMessage = STR_OFF_EDGE_OF_MAP; res.ErrorMessage = STR_OFF_EDGE_OF_MAP;
return res; return res;
} }
if (!MapIsLocationOwned(_loc) && !gCheatsSandboxMode) if (!MapIsLocationOwned(_loc) && !OpenRCT2::GetGameState().Cheats.SandboxMode)
{ {
res.Error = GameActions::Status::NotOwned; res.Error = GameActions::Status::NotOwned;
res.ErrorMessage = STR_LAND_NOT_OWNED_BY_PARK; res.ErrorMessage = STR_LAND_NOT_OWNED_BY_PARK;
@ -81,7 +82,7 @@ GameActions::Result MazePlaceTrackAction::Query() const
auto clearanceHeight = _loc.z + MAZE_CLEARANCE_HEIGHT; auto clearanceHeight = _loc.z + MAZE_CLEARANCE_HEIGHT;
auto heightDifference = baseHeight - surfaceElement->GetBaseZ(); auto heightDifference = baseHeight - surfaceElement->GetBaseZ();
if (heightDifference >= 0 && !gCheatsDisableSupportLimits) if (heightDifference >= 0 && !OpenRCT2::GetGameState().Cheats.DisableSupportLimits)
{ {
heightDifference /= COORDS_Z_PER_TINY_Z; heightDifference /= COORDS_Z_PER_TINY_Z;

5
src/openrct2/actions/MazeSetTrackAction.cpp
View File

@ -10,6 +10,7 @@
#include "MazeSetTrackAction.h" #include "MazeSetTrackAction.h"
#include "../Cheats.h" #include "../Cheats.h"
#include "../GameState.h"
#include "../core/MemoryStream.h" #include "../core/MemoryStream.h"
#include "../interface/Window.h" #include "../interface/Window.h"
#include "../localisation/Localisation.h" #include "../localisation/Localisation.h"
@ -94,7 +95,7 @@ GameActions::Result MazeSetTrackAction::Query() const
res.ErrorMessage = STR_OFF_EDGE_OF_MAP; res.ErrorMessage = STR_OFF_EDGE_OF_MAP;
return res; return res;
} }
if (!MapIsLocationOwned(_loc) && !gCheatsSandboxMode) if (!MapIsLocationOwned(_loc) && !OpenRCT2::GetGameState().Cheats.SandboxMode)
{ {
res.Error = GameActions::Status::NotOwned; res.Error = GameActions::Status::NotOwned;
res.ErrorMessage = STR_LAND_NOT_OWNED_BY_PARK; res.ErrorMessage = STR_LAND_NOT_OWNED_BY_PARK;
@ -119,7 +120,7 @@ GameActions::Result MazeSetTrackAction::Query() const
auto clearanceHeight = _loc.z + 32; auto clearanceHeight = _loc.z + 32;
auto heightDifference = baseHeight - surfaceElement->GetBaseZ(); auto heightDifference = baseHeight - surfaceElement->GetBaseZ();
if (heightDifference >= 0 && !gCheatsDisableSupportLimits) if (heightDifference >= 0 && !OpenRCT2::GetGameState().Cheats.DisableSupportLimits)
{ {
heightDifference /= COORDS_Z_PER_TINY_Z; heightDifference /= COORDS_Z_PER_TINY_Z;

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

@ -51,7 +51,7 @@ void ParkEntrancePlaceAction::Serialise(DataSerialiser& stream)
GameActions::Result ParkEntrancePlaceAction::Query() const GameActions::Result ParkEntrancePlaceAction::Query() const
{ {
if (!(gScreenFlags & SCREEN_FLAGS_EDITOR) && !gCheatsSandboxMode) if (!(gScreenFlags & SCREEN_FLAGS_EDITOR) && !GetGameState().Cheats.SandboxMode)
{ {
return GameActions::Result(GameActions::Status::NotInEditorMode, STR_CANT_BUILD_THIS_HERE, STR_NONE); return GameActions::Result(GameActions::Status::NotInEditorMode, STR_CANT_BUILD_THIS_HERE, STR_NONE);
} }

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

@ -41,7 +41,7 @@ void ParkEntranceRemoveAction::Serialise(DataSerialiser& stream)
GameActions::Result ParkEntranceRemoveAction::Query() const GameActions::Result ParkEntranceRemoveAction::Query() const
{ {
if (!(gScreenFlags & SCREEN_FLAGS_EDITOR) && !gCheatsSandboxMode) if (!(gScreenFlags & SCREEN_FLAGS_EDITOR) && !GetGameState().Cheats.SandboxMode)
{ {
return GameActions::Result(GameActions::Status::NotInEditorMode, STR_CANT_REMOVE_THIS, STR_NONE); return GameActions::Result(GameActions::Status::NotInEditorMode, STR_CANT_REMOVE_THIS, STR_NONE);
} }

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

@ -43,7 +43,7 @@ void PeepSpawnPlaceAction::Serialise(DataSerialiser& stream)
GameActions::Result PeepSpawnPlaceAction::Query() const GameActions::Result PeepSpawnPlaceAction::Query() const
{ {
if (!(gScreenFlags & SCREEN_FLAGS_EDITOR) && !gCheatsSandboxMode) if (!(gScreenFlags & SCREEN_FLAGS_EDITOR) && !OpenRCT2::GetGameState().Cheats.SandboxMode)
{ {
return GameActions::Result(GameActions::Status::NotInEditorMode, STR_ERR_CANT_PLACE_PEEP_SPAWN_HERE, STR_NONE); return GameActions::Result(GameActions::Status::NotInEditorMode, STR_ERR_CANT_PLACE_PEEP_SPAWN_HERE, STR_NONE);
} }

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

@ -161,7 +161,7 @@ GameActions::Result RideCreateAction::Execute() const
ride->vehicle_change_timeout = 0; ride->vehicle_change_timeout = 0;
ride->num_stations = 0; ride->num_stations = 0;
ride->NumTrains = 1; ride->NumTrains = 1;
if (gCheatsDisableTrainLengthLimit) if (GetGameState().Cheats.DisableTrainLengthLimit)
{ {
// Reduce amount of proposed trains to prevent 32 trains from always spawning when limits are disabled // Reduce amount of proposed trains to prevent 32 trains from always spawning when limits are disabled
if (rideEntry->cars_per_flat_ride == NoFlatRideCars) if (rideEntry->cars_per_flat_ride == NoFlatRideCars)

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

@ -66,7 +66,7 @@ GameActions::Result RideDemolishAction::Query() const
if ((ride->lifecycle_flags & (RIDE_LIFECYCLE_INDESTRUCTIBLE | RIDE_LIFECYCLE_INDESTRUCTIBLE_TRACK) if ((ride->lifecycle_flags & (RIDE_LIFECYCLE_INDESTRUCTIBLE | RIDE_LIFECYCLE_INDESTRUCTIBLE_TRACK)
&& _modifyType == RIDE_MODIFY_DEMOLISH) && _modifyType == RIDE_MODIFY_DEMOLISH)
&& !gCheatsMakeAllDestructible) && !GetGameState().Cheats.MakeAllDestructible)
{ {
return GameActions::Result( return GameActions::Result(
GameActions::Status::NoClearance, STR_CANT_DEMOLISH_RIDE, GameActions::Status::NoClearance, STR_CANT_DEMOLISH_RIDE,

11
src/openrct2/actions/RideEntranceExitPlaceAction.cpp
View File

@ -9,6 +9,7 @@
#include "RideEntranceExitPlaceAction.h" #include "RideEntranceExitPlaceAction.h"
#include "../GameState.h"
#include "../actions/RideEntranceExitRemoveAction.h" #include "../actions/RideEntranceExitRemoveAction.h"
#include "../management/Finance.h" #include "../management/Finance.h"
#include "../ride/Ride.h" #include "../ride/Ride.h"
@ -16,6 +17,8 @@
#include "../world/ConstructionClearance.h" #include "../world/ConstructionClearance.h"
#include "../world/MapAnimation.h" #include "../world/MapAnimation.h"
using namespace OpenRCT2;
RideEntranceExitPlaceAction::RideEntranceExitPlaceAction( RideEntranceExitPlaceAction::RideEntranceExitPlaceAction(
const CoordsXY& loc, Direction direction, RideId rideIndex, StationIndex stationNum, bool isExit) const CoordsXY& loc, Direction direction, RideId rideIndex, StationIndex stationNum, bool isExit)
: _loc(loc) : _loc(loc)
@ -59,7 +62,7 @@ GameActions::Result RideEntranceExitPlaceAction::Query() const
return GameActions::Result(GameActions::Status::InvalidParameters, errorTitle, STR_NONE); return GameActions::Result(GameActions::Status::InvalidParameters, errorTitle, STR_NONE);
} }
if (_stationNum.ToUnderlying() >= OpenRCT2::Limits::MaxStationsPerRide) if (_stationNum.ToUnderlying() >= Limits::MaxStationsPerRide)
{ {
LOG_WARNING("Invalid station number for ride. stationNum: %u", _stationNum.ToUnderlying()); LOG_WARNING("Invalid station number for ride. stationNum: %u", _stationNum.ToUnderlying());
return GameActions::Result(GameActions::Status::InvalidParameters, errorTitle, STR_NONE); return GameActions::Result(GameActions::Status::InvalidParameters, errorTitle, STR_NONE);
@ -96,7 +99,7 @@ GameActions::Result RideEntranceExitPlaceAction::Query() const
{ {
return GameActions::Result(GameActions::Status::InvalidParameters, errorTitle, STR_OFF_EDGE_OF_MAP); return GameActions::Result(GameActions::Status::InvalidParameters, errorTitle, STR_OFF_EDGE_OF_MAP);
} }
if (!gCheatsSandboxMode && !MapIsLocationOwned({ _loc, z })) if (!GetGameState().Cheats.SandboxMode && !MapIsLocationOwned({ _loc, z }))
{ {
return GameActions::Result(GameActions::Status::NotOwned, errorTitle, STR_LAND_NOT_OWNED_BY_PARK); return GameActions::Result(GameActions::Status::NotOwned, errorTitle, STR_LAND_NOT_OWNED_BY_PARK);
} }
@ -167,7 +170,7 @@ GameActions::Result RideEntranceExitPlaceAction::Execute() const
auto z = station.GetBaseZ(); auto z = station.GetBaseZ();
if (!(GetFlags() & GAME_COMMAND_FLAG_ALLOW_DURING_PAUSED) && !(GetFlags() & GAME_COMMAND_FLAG_GHOST) if (!(GetFlags() & GAME_COMMAND_FLAG_ALLOW_DURING_PAUSED) && !(GetFlags() & GAME_COMMAND_FLAG_GHOST)
&& !gCheatsDisableClearanceChecks) && !GetGameState().Cheats.DisableClearanceChecks)
{ {
FootpathRemoveLitter({ _loc, z }); FootpathRemoveLitter({ _loc, z });
WallRemoveAtZ({ _loc, z }); WallRemoveAtZ({ _loc, z });
@ -230,7 +233,7 @@ GameActions::Result RideEntranceExitPlaceAction::TrackPlaceQuery(const CoordsXYZ
const auto errorTitle = isExit ? STR_CANT_BUILD_MOVE_EXIT_FOR_THIS_RIDE_ATTRACTION const auto errorTitle = isExit ? STR_CANT_BUILD_MOVE_EXIT_FOR_THIS_RIDE_ATTRACTION
: STR_CANT_BUILD_MOVE_ENTRANCE_FOR_THIS_RIDE_ATTRACTION; : STR_CANT_BUILD_MOVE_ENTRANCE_FOR_THIS_RIDE_ATTRACTION;
if (!gCheatsSandboxMode && !MapIsLocationOwned(loc)) if (!GetGameState().Cheats.SandboxMode && !MapIsLocationOwned(loc))
{ {
return GameActions::Result(GameActions::Status::NotOwned, errorTitle, STR_LAND_NOT_OWNED_BY_PARK); return GameActions::Result(GameActions::Status::NotOwned, errorTitle, STR_LAND_NOT_OWNED_BY_PARK);
} }

17
src/openrct2/actions/RideSetSettingAction.cpp
View File

@ -10,10 +10,13 @@
#include "RideSetSettingAction.h" #include "RideSetSettingAction.h"
#include "../Context.h" #include "../Context.h"
#include "../GameState.h"
#include "../object/ObjectManager.h" #include "../object/ObjectManager.h"
#include "../ride/Ride.h" #include "../ride/Ride.h"
#include "../ride/RideData.h" #include "../ride/RideData.h"
using namespace OpenRCT2;
RideSetSettingAction::RideSetSettingAction(RideId rideIndex, RideSetSetting setting, uint8_t value) RideSetSettingAction::RideSetSettingAction(RideId rideIndex, RideSetSetting setting, uint8_t value)
: _rideIndex(rideIndex) : _rideIndex(rideIndex)
, _setting(setting) , _setting(setting)
@ -64,7 +67,7 @@ GameActions::Result RideSetSettingAction::Query() const
GameActions::Status::Disallowed, STR_CANT_CHANGE_OPERATING_MODE, STR_MUST_BE_CLOSED_FIRST); GameActions::Status::Disallowed, STR_CANT_CHANGE_OPERATING_MODE, STR_MUST_BE_CLOSED_FIRST);
} }
if (!RideIsModeValid(*ride) && !gCheatsShowAllOperatingModes) if (!RideIsModeValid(*ride) && !GetGameState().Cheats.ShowAllOperatingModes)
{ {
LOG_WARNING("Invalid ride mode: %u", _value); LOG_WARNING("Invalid ride mode: %u", _value);
return GameActions::Result(GameActions::Status::InvalidParameters, STR_CANT_CHANGE_OPERATING_MODE, STR_NONE); return GameActions::Result(GameActions::Status::InvalidParameters, STR_CANT_CHANGE_OPERATING_MODE, STR_NONE);
@ -105,7 +108,7 @@ GameActions::Result RideSetSettingAction::Query() const
break; break;
case RideSetSetting::MusicType: case RideSetSetting::MusicType:
{ {
auto& objManager = OpenRCT2::GetContext()->GetObjectManager(); auto& objManager = GetContext()->GetObjectManager();
auto musicObj = objManager.GetLoadedObject(ObjectType::Music, _value); auto musicObj = objManager.GetLoadedObject(ObjectType::Music, _value);
if (musicObj == nullptr) if (musicObj == nullptr)
{ {
@ -136,7 +139,7 @@ GameActions::Result RideSetSettingAction::Query() const
} }
break; break;
case RideSetSetting::RideType: case RideSetSetting::RideType:
if (!gCheatsAllowArbitraryRideTypeChanges) if (!GetGameState().Cheats.AllowArbitraryRideTypeChanges)
{ {
LOG_WARNING("Arbitrary ride type changes not allowed."); LOG_WARNING("Arbitrary ride type changes not allowed.");
return GameActions::Result(GameActions::Status::Disallowed, STR_CANT_CHANGE_OPERATING_MODE, STR_NONE); return GameActions::Result(GameActions::Status::Disallowed, STR_CANT_CHANGE_OPERATING_MODE, STR_NONE);
@ -247,15 +250,15 @@ bool RideSetSettingAction::RideIsModeValid(const Ride& ride) const
bool RideSetSettingAction::RideIsValidLiftHillSpeed(const Ride& ride) const bool RideSetSettingAction::RideIsValidLiftHillSpeed(const Ride& ride) const
{ {
int32_t minSpeed = gCheatsUnlockOperatingLimits ? 0 : ride.GetRideTypeDescriptor().LiftData.minimum_speed; int32_t minSpeed = GetGameState().Cheats.UnlockOperatingLimits ? 0 : ride.GetRideTypeDescriptor().LiftData.minimum_speed;
int32_t maxSpeed = gCheatsUnlockOperatingLimits ? 255 : ride.GetRideTypeDescriptor().LiftData.maximum_speed; int32_t maxSpeed = GetGameState().Cheats.UnlockOperatingLimits ? 255 : ride.GetRideTypeDescriptor().LiftData.maximum_speed;
return _value >= minSpeed && _value <= maxSpeed; return _value >= minSpeed && _value <= maxSpeed;
} }
bool RideSetSettingAction::RideIsValidNumCircuits() const bool RideSetSettingAction::RideIsValidNumCircuits() const
{ {
int32_t minNumCircuits = 1; int32_t minNumCircuits = 1;
int32_t maxNumCircuits = gCheatsUnlockOperatingLimits ? 255 : OpenRCT2::Limits::MaxCircuitsPerRide; int32_t maxNumCircuits = GetGameState().Cheats.UnlockOperatingLimits ? 255 : Limits::MaxCircuitsPerRide;
return _value >= minNumCircuits && _value <= maxNumCircuits; return _value >= minNumCircuits && _value <= maxNumCircuits;
} }
@ -264,7 +267,7 @@ bool RideSetSettingAction::RideIsValidOperationOption(const Ride& ride) const
const auto& operatingSettings = ride.GetRideTypeDescriptor().OperatingSettings; const auto& operatingSettings = ride.GetRideTypeDescriptor().OperatingSettings;
uint8_t minValue = operatingSettings.MinValue; uint8_t minValue = operatingSettings.MinValue;
uint8_t maxValue = operatingSettings.MaxValue; uint8_t maxValue = operatingSettings.MaxValue;
if (gCheatsUnlockOperatingLimits) if (GetGameState().Cheats.UnlockOperatingLimits)
{ {
minValue = 0; minValue = 0;
maxValue = 255; maxValue = 255;

13
src/openrct2/actions/RideSetVehicleAction.cpp
View File

@ -11,6 +11,7 @@
#include "../Cheats.h" #include "../Cheats.h"
#include "../Context.h" #include "../Context.h"
#include "../GameState.h"
#include "../core/MemoryStream.h" #include "../core/MemoryStream.h"
#include "../drawing/Drawing.h" #include "../drawing/Drawing.h"
#include "../interface/Window.h" #include "../interface/Window.h"
@ -25,6 +26,8 @@
#include "../util/Util.h" #include "../util/Util.h"
#include "../world/Park.h" #include "../world/Park.h"
using namespace OpenRCT2;
constexpr static StringId SetVehicleTypeErrorTitle[] = { constexpr static StringId SetVehicleTypeErrorTitle[] = {
STR_RIDE_SET_VEHICLE_SET_NUM_TRAINS_FAIL, STR_RIDE_SET_VEHICLE_SET_NUM_TRAINS_FAIL,
STR_RIDE_SET_VEHICLE_SET_NUM_CARS_PER_TRAIN_FAIL, STR_RIDE_SET_VEHICLE_SET_NUM_CARS_PER_TRAIN_FAIL,
@ -156,7 +159,7 @@ GameActions::Result RideSetVehicleAction::Execute() const
} }
uint8_t clampValue = _value; uint8_t clampValue = _value;
static_assert(sizeof(clampValue) == sizeof(ride->proposed_num_cars_per_train)); static_assert(sizeof(clampValue) == sizeof(ride->proposed_num_cars_per_train));
if (!gCheatsDisableTrainLengthLimit) if (!GetGameState().Cheats.DisableTrainLengthLimit)
{ {
clampValue = std::clamp(clampValue, rideEntry->min_cars_in_train, rideEntry->max_cars_in_train); clampValue = std::clamp(clampValue, rideEntry->min_cars_in_train, rideEntry->max_cars_in_train);
} }
@ -179,7 +182,7 @@ GameActions::Result RideSetVehicleAction::Execute() const
} }
RideSetVehicleColoursToRandomPreset(*ride, _colour); RideSetVehicleColoursToRandomPreset(*ride, _colour);
if (!gCheatsDisableTrainLengthLimit) if (!GetGameState().Cheats.DisableTrainLengthLimit)
{ {
ride->proposed_num_cars_per_train = std::clamp( ride->proposed_num_cars_per_train = std::clamp(
ride->proposed_num_cars_per_train, rideEntry->min_cars_in_train, rideEntry->max_cars_in_train); ride->proposed_num_cars_per_train, rideEntry->min_cars_in_train, rideEntry->max_cars_in_train);
@ -226,7 +229,7 @@ bool RideSetVehicleAction::RideIsVehicleTypeValid(const Ride& ride) const
{ {
const auto& rtd = ride.GetRideTypeDescriptor(); const auto& rtd = ride.GetRideTypeDescriptor();
if (gCheatsShowVehiclesFromOtherTrackTypes if (GetGameState().Cheats.ShowVehiclesFromOtherTrackTypes
&& !( && !(
ride.GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_FLAT_RIDE) || rtd.HasFlag(RIDE_TYPE_FLAG_IS_MAZE) ride.GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_FLAT_RIDE) || rtd.HasFlag(RIDE_TYPE_FLAG_IS_MAZE)
|| ride.type == RIDE_TYPE_MINI_GOLF)) || ride.type == RIDE_TYPE_MINI_GOLF))
@ -255,13 +258,13 @@ bool RideSetVehicleAction::RideIsVehicleTypeValid(const Ride& ride) const
continue; continue;
} }
auto& objManager = OpenRCT2::GetContext()->GetObjectManager(); auto& objManager = GetContext()->GetObjectManager();
auto& rideEntries = objManager.GetAllRideEntries(rideTypeIterator); auto& rideEntries = objManager.GetAllRideEntries(rideTypeIterator);
for (auto rideEntryIndex : rideEntries) for (auto rideEntryIndex : rideEntries)
{ {
if (rideEntryIndex == _value) if (rideEntryIndex == _value)
{ {
if (!RideEntryIsInvented(rideEntryIndex) && !gCheatsIgnoreResearchStatus) if (!RideEntryIsInvented(rideEntryIndex) && !GetGameState().Cheats.IgnoreResearchStatus)
{ {
return false; return false;
} }

23
src/openrct2/actions/SmallSceneryPlaceAction.cpp
View File

@ -10,6 +10,7 @@
#include "SmallSceneryPlaceAction.h" #include "SmallSceneryPlaceAction.h"
#include "../Cheats.h" #include "../Cheats.h"
#include "../GameState.h"
#include "../OpenRCT2.h" #include "../OpenRCT2.h"
#include "../common.h" #include "../common.h"
#include "../core/MemoryStream.h" #include "../core/MemoryStream.h"
@ -30,6 +31,8 @@
#include "GameAction.h" #include "GameAction.h"
#include "SmallSceneryRemoveAction.h" #include "SmallSceneryRemoveAction.h"
using namespace OpenRCT2;
SmallSceneryPlaceAction::SmallSceneryPlaceAction( SmallSceneryPlaceAction::SmallSceneryPlaceAction(
const CoordsXYZD& loc, uint8_t quadrant, ObjectEntryIndex sceneryType, uint8_t primaryColour, uint8_t secondaryColour, const CoordsXYZD& loc, uint8_t quadrant, ObjectEntryIndex sceneryType, uint8_t primaryColour, uint8_t secondaryColour,
uint8_t tertiaryColour) uint8_t tertiaryColour)
@ -115,7 +118,7 @@ GameActions::Result SmallSceneryPlaceAction::Query() const
return GameActions::Result(GameActions::Status::InvalidParameters, STR_CANT_POSITION_THIS_HERE, STR_NONE); return GameActions::Result(GameActions::Status::InvalidParameters, STR_CANT_POSITION_THIS_HERE, STR_NONE);
} }
auto* sceneryEntry = OpenRCT2::ObjectManager::GetObjectEntry<SmallSceneryEntry>(_sceneryType); auto* sceneryEntry = ObjectManager::GetObjectEntry<SmallSceneryEntry>(_sceneryType);
if (sceneryEntry == nullptr) if (sceneryEntry == nullptr)
{ {
return GameActions::Result( return GameActions::Result(
@ -163,7 +166,7 @@ GameActions::Result SmallSceneryPlaceAction::Query() const
targetHeight = surfaceHeight; targetHeight = surfaceHeight;
} }
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !gCheatsSandboxMode if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !GetGameState().Cheats.SandboxMode
&& !MapIsLocationOwned({ _loc.x, _loc.y, targetHeight })) && !MapIsLocationOwned({ _loc.x, _loc.y, targetHeight }))
{ {
return GameActions::Result(GameActions::Status::NotOwned, STR_CANT_POSITION_THIS_HERE, STR_LAND_NOT_OWNED_BY_PARK); return GameActions::Result(GameActions::Status::NotOwned, STR_CANT_POSITION_THIS_HERE, STR_LAND_NOT_OWNED_BY_PARK);
@ -171,7 +174,7 @@ GameActions::Result SmallSceneryPlaceAction::Query() const
auto* surfaceElement = MapGetSurfaceElementAt(_loc); auto* surfaceElement = MapGetSurfaceElementAt(_loc);
if (surfaceElement != nullptr && !gCheatsDisableClearanceChecks && surfaceElement->GetWaterHeight() > 0) if (surfaceElement != nullptr && !GetGameState().Cheats.DisableClearanceChecks && surfaceElement->GetWaterHeight() > 0)
{ {
int32_t water_height = surfaceElement->GetWaterHeight() - 1; int32_t water_height = surfaceElement->GetWaterHeight() - 1;
if (water_height > targetHeight) if (water_height > targetHeight)
@ -181,7 +184,7 @@ GameActions::Result SmallSceneryPlaceAction::Query() const
} }
} }
if (!gCheatsDisableClearanceChecks && !(sceneryEntry->HasFlag(SMALL_SCENERY_FLAG_STACKABLE))) if (!GetGameState().Cheats.DisableClearanceChecks && !(sceneryEntry->HasFlag(SMALL_SCENERY_FLAG_STACKABLE)))
{ {
if (isOnWater) if (isOnWater)
{ {
@ -199,13 +202,15 @@ GameActions::Result SmallSceneryPlaceAction::Query() const
} }
} }
if (!gCheatsDisableClearanceChecks && (sceneryEntry->HasFlag(SMALL_SCENERY_FLAG_REQUIRE_FLAT_SURFACE)) && !supportsRequired if (!GetGameState().Cheats.DisableClearanceChecks && (sceneryEntry->HasFlag(SMALL_SCENERY_FLAG_REQUIRE_FLAT_SURFACE))
&& !isOnWater && surfaceElement != nullptr && (surfaceElement->GetSlope() != TILE_ELEMENT_SLOPE_FLAT)) && !supportsRequired && !isOnWater && surfaceElement != nullptr
&& (surfaceElement->GetSlope() != TILE_ELEMENT_SLOPE_FLAT))
{ {
return GameActions::Result(GameActions::Status::Disallowed, STR_CANT_POSITION_THIS_HERE, STR_LEVEL_LAND_REQUIRED); return GameActions::Result(GameActions::Status::Disallowed, STR_CANT_POSITION_THIS_HERE, STR_LEVEL_LAND_REQUIRED);
} }
if (!gCheatsDisableSupportLimits && !(sceneryEntry->HasFlag(SMALL_SCENERY_FLAG_STACKABLE)) && supportsRequired) if (!GetGameState().Cheats.DisableSupportLimits && !(sceneryEntry->HasFlag(SMALL_SCENERY_FLAG_STACKABLE))
&& supportsRequired)
{ {
if (!isOnWater) if (!isOnWater)
{ {
@ -308,7 +313,7 @@ GameActions::Result SmallSceneryPlaceAction::Execute() const
res.Position.z = surfaceHeight; res.Position.z = surfaceHeight;
} }
auto* sceneryEntry = OpenRCT2::ObjectManager::GetObjectEntry<SmallSceneryEntry>(_sceneryType); auto* sceneryEntry = ObjectManager::GetObjectEntry<SmallSceneryEntry>(_sceneryType);
if (sceneryEntry == nullptr) if (sceneryEntry == nullptr)
{ {
return GameActions::Result( return GameActions::Result(
@ -357,7 +362,7 @@ GameActions::Result SmallSceneryPlaceAction::Execute() const
if (!(GetFlags() & GAME_COMMAND_FLAG_GHOST)) if (!(GetFlags() & GAME_COMMAND_FLAG_GHOST))
{ {
FootpathRemoveLitter({ _loc, targetHeight }); FootpathRemoveLitter({ _loc, targetHeight });
if (!gCheatsDisableClearanceChecks && (sceneryEntry->HasFlag(SMALL_SCENERY_FLAG_NO_WALLS))) if (!GetGameState().Cheats.DisableClearanceChecks && (sceneryEntry->HasFlag(SMALL_SCENERY_FLAG_NO_WALLS)))
{ {
WallRemoveAt({ _loc, targetHeight, targetHeight + sceneryEntry->height }); WallRemoveAt({ _loc, targetHeight, targetHeight + sceneryEntry->height });
} }

3
src/openrct2/actions/SmallSceneryRemoveAction.cpp
View File

@ -74,7 +74,8 @@ GameActions::Result SmallSceneryRemoveAction::Query() const
res.Expenditure = ExpenditureType::Landscaping; res.Expenditure = ExpenditureType::Landscaping;
res.Position = _loc; res.Position = _loc;
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !(GetFlags() & GAME_COMMAND_FLAG_GHOST) && !gCheatsSandboxMode) if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !(GetFlags() & GAME_COMMAND_FLAG_GHOST)
&& !GetGameState().Cheats.SandboxMode)
{ {
// Check if allowed to remove item // Check if allowed to remove item
if (GetGameState().ParkFlags & PARK_FLAGS_FORBID_TREE_REMOVAL) if (GetGameState().ParkFlags & PARK_FLAGS_FORBID_TREE_REMOVAL)

5
src/openrct2/actions/SmallScenerySetColourAction.cpp
View File

@ -10,6 +10,7 @@
#include "SmallScenerySetColourAction.h" #include "SmallScenerySetColourAction.h"
#include "../Cheats.h" #include "../Cheats.h"
#include "../GameState.h"
#include "../OpenRCT2.h" #include "../OpenRCT2.h"
#include "../common.h" #include "../common.h"
#include "../core/MemoryStream.h" #include "../core/MemoryStream.h"
@ -24,6 +25,8 @@
#include "../world/Surface.h" #include "../world/Surface.h"
#include "../world/TileElement.h" #include "../world/TileElement.h"
using namespace OpenRCT2;
SmallScenerySetColourAction::SmallScenerySetColourAction( SmallScenerySetColourAction::SmallScenerySetColourAction(
const CoordsXYZ& loc, uint8_t quadrant, ObjectEntryIndex sceneryType, uint8_t primaryColour, uint8_t secondaryColour, const CoordsXYZ& loc, uint8_t quadrant, ObjectEntryIndex sceneryType, uint8_t primaryColour, uint8_t secondaryColour,
uint8_t tertiaryColour) uint8_t tertiaryColour)
@ -83,7 +86,7 @@ GameActions::Result SmallScenerySetColourAction::QueryExecute(bool isExecuting)
return GameActions::Result(GameActions::Status::InvalidParameters, STR_CANT_REPAINT_THIS, STR_OFF_EDGE_OF_MAP); return GameActions::Result(GameActions::Status::InvalidParameters, STR_CANT_REPAINT_THIS, STR_OFF_EDGE_OF_MAP);
} }
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !gCheatsSandboxMode) if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !GetGameState().Cheats.SandboxMode)
{ {
if (!MapIsLocationOwned(_loc)) if (!MapIsLocationOwned(_loc))
{ {

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

@ -204,7 +204,7 @@ GameActions::Result StaffHireNewAction::QueryExecute(bool execute) const
newPeep->TrousersColour = colour; newPeep->TrousersColour = colour;
// Staff energy determines their walking speed // Staff energy determines their walking speed
switch (gCheatsSelectedStaffSpeed) switch (GetGameState().Cheats.SelectedStaffSpeed)
{ {
case StaffSpeedCheat::None: case StaffSpeedCheat::None:
newPeep->Energy = kCheatsStaffNormalSpeed; newPeep->Energy = kCheatsStaffNormalSpeed;

6
src/openrct2/actions/SurfaceSetStyleAction.cpp
View File

@ -85,7 +85,7 @@ GameActions::Result SurfaceSetStyleAction::Query() const
res.Position.z = heightMid; res.Position.z = heightMid;
// Do nothing if not in editor, sandbox mode or landscaping is forbidden // Do nothing if not in editor, sandbox mode or landscaping is forbidden
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !gCheatsSandboxMode if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !GetGameState().Cheats.SandboxMode
&& (GetGameState().ParkFlags & PARK_FLAGS_FORBID_LANDSCAPE_CHANGES)) && (GetGameState().ParkFlags & PARK_FLAGS_FORBID_LANDSCAPE_CHANGES))
{ {
return GameActions::Result( return GameActions::Result(
@ -102,7 +102,7 @@ GameActions::Result SurfaceSetStyleAction::Query() const
if (!LocationValid(coords)) if (!LocationValid(coords))
continue; continue;
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !gCheatsSandboxMode) if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !GetGameState().Cheats.SandboxMode)
{ {
if (!MapIsLocationInPark(coords)) if (!MapIsLocationInPark(coords))
continue; continue;
@ -170,7 +170,7 @@ GameActions::Result SurfaceSetStyleAction::Execute() const
if (!LocationValid(coords)) if (!LocationValid(coords))
continue; continue;
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !gCheatsSandboxMode) if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !GetGameState().Cheats.SandboxMode)
{ {
if (!MapIsLocationInPark(coords)) if (!MapIsLocationInPark(coords))
continue; continue;

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

@ -10,6 +10,7 @@
#include "TrackDesignAction.h" #include "TrackDesignAction.h"
#include "../Context.h" #include "../Context.h"
#include "../GameState.h"
#include "../management/Finance.h" #include "../management/Finance.h"
#include "../management/Research.h" #include "../management/Research.h"
#include "../object/ObjectManager.h" #include "../object/ObjectManager.h"
@ -22,6 +23,8 @@
#include "RideSetSettingAction.h" #include "RideSetSettingAction.h"
#include "RideSetVehicleAction.h" #include "RideSetVehicleAction.h"
using namespace OpenRCT2;
TrackDesignAction::TrackDesignAction(const CoordsXYZD& location, const TrackDesign& td) TrackDesignAction::TrackDesignAction(const CoordsXYZD& location, const TrackDesign& td)
: _loc(location) : _loc(location)
, _td(td) , _td(td)
@ -61,13 +64,13 @@ GameActions::Result TrackDesignAction::Query() const
GameActions::Status::InvalidParameters, STR_RIDE_CONSTRUCTION_CANT_CONSTRUCT_THIS_HERE, STR_OFF_EDGE_OF_MAP); GameActions::Status::InvalidParameters, STR_RIDE_CONSTRUCTION_CANT_CONSTRUCT_THIS_HERE, STR_OFF_EDGE_OF_MAP);
} }
auto& objManager = OpenRCT2::GetContext()->GetObjectManager(); auto& objManager = GetContext()->GetObjectManager();
auto entryIndex = objManager.GetLoadedObjectEntryIndex(_td.vehicle_object); auto entryIndex = objManager.GetLoadedObjectEntryIndex(_td.vehicle_object);
if (entryIndex == OBJECT_ENTRY_INDEX_NULL) if (entryIndex == OBJECT_ENTRY_INDEX_NULL)
{ {
// Force a fallback if the entry is not invented yet a td6 of it is selected, // Force a fallback if the entry is not invented yet a td6 of it is selected,
// which can happen in select-by-track-type mode // which can happen in select-by-track-type mode
if (!RideEntryIsInvented(entryIndex) && !gCheatsIgnoreResearchStatus) if (!RideEntryIsInvented(entryIndex) && !GetGameState().Cheats.IgnoreResearchStatus)
{ {
entryIndex = OBJECT_ENTRY_INDEX_NULL; entryIndex = OBJECT_ENTRY_INDEX_NULL;
} }
@ -133,13 +136,13 @@ GameActions::Result TrackDesignAction::Execute() const
res.Position.z = _loc.z; res.Position.z = _loc.z;
res.Expenditure = ExpenditureType::RideConstruction; res.Expenditure = ExpenditureType::RideConstruction;
auto& objManager = OpenRCT2::GetContext()->GetObjectManager(); auto& objManager = GetContext()->GetObjectManager();
auto entryIndex = objManager.GetLoadedObjectEntryIndex(_td.vehicle_object); auto entryIndex = objManager.GetLoadedObjectEntryIndex(_td.vehicle_object);
if (entryIndex != OBJECT_ENTRY_INDEX_NULL) if (entryIndex != OBJECT_ENTRY_INDEX_NULL)
{ {
// Force a fallback if the entry is not invented yet a track design using it is selected. // Force a fallback if the entry is not invented yet a track design using it is selected.
// This can happen on rides with multiple vehicles where some have been invented and some haven’t. // This can happen on rides with multiple vehicles where some have been invented and some haven’t.
if (!RideEntryIsInvented(entryIndex) && !gCheatsIgnoreResearchStatus) if (!RideEntryIsInvented(entryIndex) && !GetGameState().Cheats.IgnoreResearchStatus)
{ {
entryIndex = OBJECT_ENTRY_INDEX_NULL; entryIndex = OBJECT_ENTRY_INDEX_NULL;
} }
@ -247,14 +250,14 @@ GameActions::Result TrackDesignAction::Execute() const
ride->entrance_style = gLastEntranceStyle; ride->entrance_style = gLastEntranceStyle;
} }
for (int32_t i = 0; i < OpenRCT2::Limits::NumColourSchemes; i++) for (int32_t i = 0; i < Limits::NumColourSchemes; i++)
{ {
ride->track_colour[i].main = _td.track_spine_colour[i]; ride->track_colour[i].main = _td.track_spine_colour[i];
ride->track_colour[i].additional = _td.track_rail_colour[i]; ride->track_colour[i].additional = _td.track_rail_colour[i];
ride->track_colour[i].supports = _td.track_support_colour[i]; ride->track_colour[i].supports = _td.track_support_colour[i];
} }
for (size_t i = 0; i < OpenRCT2::Limits::MaxVehicleColours; i++) for (size_t i = 0; i < Limits::MaxVehicleColours; i++)
{ {
ride->vehicle_colours[i] = _td.vehicle_colours[i]; ride->vehicle_colours[i] = _td.vehicle_colours[i];
} }

25
src/openrct2/actions/TrackPlaceAction.cpp
View File

@ -9,6 +9,7 @@
#include "TrackPlaceAction.h" #include "TrackPlaceAction.h"
#include "../GameState.h"
#include "../core/Numerics.hpp" #include "../core/Numerics.hpp"
#include "../management/Finance.h" #include "../management/Finance.h"
#include "../ride/RideData.h" #include "../ride/RideData.h"
@ -21,6 +22,7 @@
#include "../world/Surface.h" #include "../world/Surface.h"
#include "RideSetSettingAction.h" #include "RideSetSettingAction.h"
using namespace OpenRCT2;
using namespace OpenRCT2::TrackMetaData; using namespace OpenRCT2::TrackMetaData;
TrackPlaceAction::TrackPlaceAction( TrackPlaceAction::TrackPlaceAction(
@ -89,7 +91,7 @@ GameActions::Result TrackPlaceAction::Query() const
GameActions::Status::InvalidParameters, STR_RIDE_CONSTRUCTION_CANT_CONSTRUCT_THIS_HERE, STR_NONE); GameActions::Status::InvalidParameters, STR_RIDE_CONSTRUCTION_CANT_CONSTRUCT_THIS_HERE, STR_NONE);
} }
if (_rideType != ride->type && !gCheatsAllowArbitraryRideTypeChanges) if (_rideType != ride->type && !GetGameState().Cheats.AllowArbitraryRideTypeChanges)
{ {
return GameActions::Result( return GameActions::Result(
GameActions::Status::InvalidParameters, STR_RIDE_CONSTRUCTION_CANT_CONSTRUCT_THIS_HERE, STR_NONE); GameActions::Status::InvalidParameters, STR_RIDE_CONSTRUCTION_CANT_CONSTRUCT_THIS_HERE, STR_NONE);
@ -120,7 +122,7 @@ GameActions::Result TrackPlaceAction::Query() const
if (!(GetActionFlags() & GameActions::Flags::AllowWhilePaused)) if (!(GetActionFlags() & GameActions::Flags::AllowWhilePaused))
{ {
if (GameIsPaused() && !gCheatsBuildInPauseMode) if (GameIsPaused() && !GetGameState().Cheats.BuildInPauseMode)
{ {
return GameActions::Result( return GameActions::Result(
GameActions::Status::Disallowed, STR_RIDE_CONSTRUCTION_CANT_CONSTRUCT_THIS_HERE, GameActions::Status::Disallowed, STR_RIDE_CONSTRUCTION_CANT_CONSTRUCT_THIS_HERE,
@ -150,7 +152,8 @@ GameActions::Result TrackPlaceAction::Query() const
} }
// Backwards steep lift hills are allowed, even on roller coasters that do not support forwards steep lift hills. // Backwards steep lift hills are allowed, even on roller coasters that do not support forwards steep lift hills.
if ((_trackPlaceFlags & CONSTRUCTION_LIFT_HILL_SELECTED) if ((_trackPlaceFlags & CONSTRUCTION_LIFT_HILL_SELECTED)
&& !ride->GetRideTypeDescriptor().SupportsTrackPiece(TRACK_LIFT_HILL_STEEP) && !gCheatsEnableChainLiftOnAllTrack) && !ride->GetRideTypeDescriptor().SupportsTrackPiece(TRACK_LIFT_HILL_STEEP)
&& !GetGameState().Cheats.EnableChainLiftOnAllTrack)
{ {
const auto& ted = GetTrackElementDescriptor(_trackType); const auto& ted = GetTrackElementDescriptor(_trackType);
if (ted.Flags & TRACK_ELEM_FLAG_IS_STEEP_UP) if (ted.Flags & TRACK_ELEM_FLAG_IS_STEEP_UP)
@ -176,7 +179,7 @@ GameActions::Result TrackPlaceAction::Query() const
return GameActions::Result( return GameActions::Result(
GameActions::Status::InvalidParameters, STR_RIDE_CONSTRUCTION_CANT_CONSTRUCT_THIS_HERE, STR_OFF_EDGE_OF_MAP); GameActions::Status::InvalidParameters, STR_RIDE_CONSTRUCTION_CANT_CONSTRUCT_THIS_HERE, STR_OFF_EDGE_OF_MAP);
} }
if (!MapIsLocationOwned(tileCoords) && !gCheatsSandboxMode) if (!MapIsLocationOwned(tileCoords) && !GetGameState().Cheats.SandboxMode)
{ {
return GameActions::Result( return GameActions::Result(
GameActions::Status::Disallowed, STR_RIDE_CONSTRUCTION_CANT_CONSTRUCT_THIS_HERE, STR_LAND_NOT_OWNED_BY_PARK); GameActions::Status::Disallowed, STR_RIDE_CONSTRUCTION_CANT_CONSTRUCT_THIS_HERE, STR_LAND_NOT_OWNED_BY_PARK);
@ -192,7 +195,7 @@ GameActions::Result TrackPlaceAction::Query() const
STR_TILE_ELEMENT_LIMIT_REACHED); STR_TILE_ELEMENT_LIMIT_REACHED);
} }
if (!gCheatsAllowTrackPlaceInvalidHeights) if (!GetGameState().Cheats.AllowTrackPlaceInvalidHeights)
{ {
if (ted.Flags & TRACK_ELEM_FLAG_STARTS_AT_HALF_HEIGHT) if (ted.Flags & TRACK_ELEM_FLAG_STARTS_AT_HALF_HEIGHT)
{ {
@ -296,7 +299,7 @@ GameActions::Result TrackPlaceAction::Query() const
} }
} }
if (clearanceData.GroundFlags & ELEMENT_IS_UNDERWATER && !gCheatsDisableClearanceChecks) if (clearanceData.GroundFlags & ELEMENT_IS_UNDERWATER && !GetGameState().Cheats.DisableClearanceChecks)
{ {
return GameActions::Result( return GameActions::Result(
GameActions::Status::Disallowed, STR_RIDE_CONSTRUCTION_CANT_CONSTRUCT_THIS_HERE, GameActions::Status::Disallowed, STR_RIDE_CONSTRUCTION_CANT_CONSTRUCT_THIS_HERE,
@ -359,7 +362,7 @@ GameActions::Result TrackPlaceAction::Query() const
return GameActions::Result(GameActions::Status::Unknown, STR_RIDE_CONSTRUCTION_CANT_CONSTRUCT_THIS_HERE, STR_NONE); return GameActions::Result(GameActions::Status::Unknown, STR_RIDE_CONSTRUCTION_CANT_CONSTRUCT_THIS_HERE, STR_NONE);
} }
if (!gCheatsDisableSupportLimits) if (!GetGameState().Cheats.DisableSupportLimits)
{ {
int32_t ride_height = clearanceZ - surfaceElement->GetBaseZ(); int32_t ride_height = clearanceZ - surfaceElement->GetBaseZ();
if (ride_height >= 0) if (ride_height >= 0)
@ -486,7 +489,7 @@ GameActions::Result TrackPlaceAction::Execute() const
} }
} }
if (!(GetFlags() & GAME_COMMAND_FLAG_GHOST) && !gCheatsDisableClearanceChecks) if (!(GetFlags() & GAME_COMMAND_FLAG_GHOST) && !GetGameState().Cheats.DisableClearanceChecks)
{ {
FootpathRemoveLitter(mapLoc); FootpathRemoveLitter(mapLoc);
if (rideTypeFlags & RIDE_TYPE_FLAG_TRACK_NO_WALLS) if (rideTypeFlags & RIDE_TYPE_FLAG_TRACK_NO_WALLS)
@ -616,7 +619,7 @@ GameActions::Result TrackPlaceAction::Execute() const
uint8_t availableDirections = entranceDirections & 0x0F; uint8_t availableDirections = entranceDirections & 0x0F;
if (availableDirections != 0) if (availableDirections != 0)
{ {
if (!(GetFlags() & GAME_COMMAND_FLAG_GHOST) && !gCheatsDisableClearanceChecks) if (!(GetFlags() & GAME_COMMAND_FLAG_GHOST) && !GetGameState().Cheats.DisableClearanceChecks)
{ {
for (int32_t chosenDirection = UtilBitScanForward(availableDirections); chosenDirection != -1; for (int32_t chosenDirection = UtilBitScanForward(availableDirections); chosenDirection != -1;
chosenDirection = UtilBitScanForward(availableDirections)) chosenDirection = UtilBitScanForward(availableDirections))
@ -658,7 +661,7 @@ GameActions::Result TrackPlaceAction::Execute() const
} }
} }
if (!gCheatsDisableClearanceChecks || !(GetFlags() & GAME_COMMAND_FLAG_GHOST)) if (!GetGameState().Cheats.DisableClearanceChecks || !(GetFlags() & GAME_COMMAND_FLAG_GHOST))
{ {
FootpathConnectEdges(mapLoc, tileElement, GetFlags()); FootpathConnectEdges(mapLoc, tileElement, GetFlags());
} }
@ -689,7 +692,7 @@ GameActions::Result TrackPlaceAction::Execute() const
if (ride->mode == RideMode::PoweredLaunch) if (ride->mode == RideMode::PoweredLaunch)
{ {
if (ride->GetRideTypeDescriptor().SupportsRideMode(RideMode::PoweredLaunchBlockSectioned) if (ride->GetRideTypeDescriptor().SupportsRideMode(RideMode::PoweredLaunchBlockSectioned)
|| gCheatsShowAllOperatingModes) || GetGameState().Cheats.ShowAllOperatingModes)
newMode = RideMode::PoweredLaunchBlockSectioned; newMode = RideMode::PoweredLaunchBlockSectioned;
else else
newMode = RideMode::PoweredLaunch; newMode = RideMode::PoweredLaunch;

4
src/openrct2/actions/TrackRemoveAction.cpp
View File

@ -9,6 +9,7 @@
#include "TrackRemoveAction.h" #include "TrackRemoveAction.h"
#include "../GameState.h"
#include "../management/Finance.h" #include "../management/Finance.h"
#include "../ride/RideData.h" #include "../ride/RideData.h"
#include "../ride/Track.h" #include "../ride/Track.h"
@ -19,6 +20,7 @@
#include "../world/Surface.h" #include "../world/Surface.h"
#include "RideSetSettingAction.h" #include "RideSetSettingAction.h"
using namespace OpenRCT2;
using namespace OpenRCT2::TrackMetaData; using namespace OpenRCT2::TrackMetaData;
TrackRemoveAction::TrackRemoveAction(track_type_t trackType, int32_t sequence, const CoordsXYZD& origin) TrackRemoveAction::TrackRemoveAction(track_type_t trackType, int32_t sequence, const CoordsXYZD& origin)
@ -440,7 +442,7 @@ GameActions::Result TrackRemoveAction::Execute() const
InvalidateTestResults(*ride); InvalidateTestResults(*ride);
FootpathQueueChainReset(); FootpathQueueChainReset();
if (!gCheatsDisableClearanceChecks || !(tileElement->IsGhost())) if (!GetGameState().Cheats.DisableClearanceChecks || !(tileElement->IsGhost()))
{ {
FootpathRemoveEdgesAt(mapLoc, tileElement); FootpathRemoveEdgesAt(mapLoc, tileElement);
} }

17
src/openrct2/actions/WallPlaceAction.cpp
View File

@ -9,6 +9,7 @@
#include "WallPlaceAction.h" #include "WallPlaceAction.h"
#include "../GameState.h"
#include "../OpenRCT2.h" #include "../OpenRCT2.h"
#include "../management/Finance.h" #include "../management/Finance.h"
#include "../object/LargeSceneryEntry.h" #include "../object/LargeSceneryEntry.h"
@ -23,6 +24,7 @@
#include "../world/Surface.h" #include "../world/Surface.h"
#include "../world/Wall.h" #include "../world/Wall.h"
using namespace OpenRCT2;
using namespace OpenRCT2::TrackMetaData; using namespace OpenRCT2::TrackMetaData;
WallPlaceAction::WallPlaceAction( WallPlaceAction::WallPlaceAction(
@ -81,7 +83,8 @@ GameActions::Result WallPlaceAction::Query() const
} }
auto mapSizeMax = GetMapSizeMaxXY(); auto mapSizeMax = GetMapSizeMaxXY();
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !(GetFlags() & GAME_COMMAND_FLAG_TRACK_DESIGN) && !gCheatsSandboxMode) if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !(GetFlags() & GAME_COMMAND_FLAG_TRACK_DESIGN)
&& !GetGameState().Cheats.SandboxMode)
{ {
if (_loc.z == 0) if (_loc.z == 0)
{ {
@ -138,14 +141,14 @@ GameActions::Result WallPlaceAction::Query() const
{ {
uint16_t waterHeight = surfaceElement->GetWaterHeight(); uint16_t waterHeight = surfaceElement->GetWaterHeight();
if (targetHeight < waterHeight && !gCheatsDisableClearanceChecks) if (targetHeight < waterHeight && !GetGameState().Cheats.DisableClearanceChecks)
{ {
return GameActions::Result( return GameActions::Result(
GameActions::Status::Disallowed, STR_CANT_BUILD_THIS_HERE, STR_CANT_BUILD_THIS_UNDERWATER); GameActions::Status::Disallowed, STR_CANT_BUILD_THIS_HERE, STR_CANT_BUILD_THIS_UNDERWATER);
} }
} }
if (targetHeight < surfaceElement->GetBaseZ() && !gCheatsDisableClearanceChecks) if (targetHeight < surfaceElement->GetBaseZ() && !GetGameState().Cheats.DisableClearanceChecks)
{ {
return GameActions::Result( return GameActions::Result(
GameActions::Status::Disallowed, STR_CANT_BUILD_THIS_HERE, STR_CAN_ONLY_BUILD_THIS_ABOVE_GROUND); GameActions::Status::Disallowed, STR_CANT_BUILD_THIS_HERE, STR_CAN_ONLY_BUILD_THIS_ABOVE_GROUND);
@ -217,7 +220,7 @@ GameActions::Result WallPlaceAction::Query() const
} }
} }
auto* wallEntry = OpenRCT2::ObjectManager::GetObjectEntry<WallSceneryEntry>(_wallType); auto* wallEntry = ObjectManager::GetObjectEntry<WallSceneryEntry>(_wallType);
if (wallEntry == nullptr) if (wallEntry == nullptr)
{ {
@ -248,7 +251,7 @@ GameActions::Result WallPlaceAction::Query() const
clearanceHeight += wallEntry->height; clearanceHeight += wallEntry->height;
bool wallAcrossTrack = false; bool wallAcrossTrack = false;
if (!(GetFlags() & GAME_COMMAND_FLAG_TRACK_DESIGN) && !gCheatsDisableClearanceChecks) if (!(GetFlags() & GAME_COMMAND_FLAG_TRACK_DESIGN) && !GetGameState().Cheats.DisableClearanceChecks)
{ {
auto result = WallCheckObstruction(wallEntry, targetHeight / 8, clearanceHeight, &wallAcrossTrack); auto result = WallCheckObstruction(wallEntry, targetHeight / 8, clearanceHeight, &wallAcrossTrack);
if (result.Error != GameActions::Status::Ok) if (result.Error != GameActions::Status::Ok)
@ -307,7 +310,7 @@ GameActions::Result WallPlaceAction::Execute() const
} }
auto targetLoc = CoordsXYZ(_loc, targetHeight); auto targetLoc = CoordsXYZ(_loc, targetHeight);
auto* wallEntry = OpenRCT2::ObjectManager::GetObjectEntry<WallSceneryEntry>(_wallType); auto* wallEntry = ObjectManager::GetObjectEntry<WallSceneryEntry>(_wallType);
if (wallEntry == nullptr) if (wallEntry == nullptr)
{ {
@ -323,7 +326,7 @@ GameActions::Result WallPlaceAction::Execute() const
clearanceHeight += wallEntry->height; clearanceHeight += wallEntry->height;
bool wallAcrossTrack = false; bool wallAcrossTrack = false;
if (!(GetFlags() & GAME_COMMAND_FLAG_TRACK_DESIGN) && !gCheatsDisableClearanceChecks) if (!(GetFlags() & GAME_COMMAND_FLAG_TRACK_DESIGN) && !GetGameState().Cheats.DisableClearanceChecks)
{ {
auto result = WallCheckObstruction(wallEntry, targetHeight / COORDS_Z_STEP, clearanceHeight, &wallAcrossTrack); auto result = WallCheckObstruction(wallEntry, targetHeight / COORDS_Z_STEP, clearanceHeight, &wallAcrossTrack);
if (result.Error != GameActions::Status::Ok) if (result.Error != GameActions::Status::Ok)

4
src/openrct2/actions/WallRemoveAction.cpp
View File

@ -10,6 +10,7 @@
#include "WallRemoveAction.h" #include "WallRemoveAction.h"
#include "../Cheats.h" #include "../Cheats.h"
#include "../GameState.h"
#include "../OpenRCT2.h" #include "../OpenRCT2.h"
#include "../core/MemoryStream.h" #include "../core/MemoryStream.h"
#include "../interface/Window.h" #include "../interface/Window.h"
@ -50,7 +51,8 @@ GameActions::Result WallRemoveAction::Query() const
} }
const bool isGhost = GetFlags() & GAME_COMMAND_FLAG_GHOST; const bool isGhost = GetFlags() & GAME_COMMAND_FLAG_GHOST;
if (!isGhost && !(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !gCheatsSandboxMode && !MapIsLocationOwned(_loc)) if (!isGhost && !(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !GetGameState().Cheats.SandboxMode
&& !MapIsLocationOwned(_loc))
{ {
return GameActions::Result(GameActions::Status::NotOwned, STR_CANT_REMOVE_THIS, STR_LAND_NOT_OWNED_BY_PARK); return GameActions::Result(GameActions::Status::NotOwned, STR_CANT_REMOVE_THIS, STR_LAND_NOT_OWNED_BY_PARK);
} }

5
src/openrct2/actions/WallSetColourAction.cpp
View File

@ -9,6 +9,7 @@
#include "WallSetColourAction.h" #include "WallSetColourAction.h"
#include "../GameState.h"
#include "../OpenRCT2.h" #include "../OpenRCT2.h"
#include "../management/Finance.h" #include "../management/Finance.h"
#include "../object/WallSceneryEntry.h" #include "../object/WallSceneryEntry.h"
@ -19,6 +20,8 @@
#include "../world/Scenery.h" #include "../world/Scenery.h"
#include "../world/Surface.h" #include "../world/Surface.h"
using namespace OpenRCT2;
WallSetColourAction::WallSetColourAction( WallSetColourAction::WallSetColourAction(
const CoordsXYZD& loc, int32_t primaryColour, int32_t secondaryColour, int32_t tertiaryColour) const CoordsXYZD& loc, int32_t primaryColour, int32_t secondaryColour, int32_t tertiaryColour)
: _loc(loc) : _loc(loc)
@ -63,7 +66,7 @@ GameActions::Result WallSetColourAction::Query() const
return GameActions::Result(GameActions::Status::InvalidParameters, STR_CANT_REPAINT_THIS, STR_OFF_EDGE_OF_MAP); return GameActions::Result(GameActions::Status::InvalidParameters, STR_CANT_REPAINT_THIS, STR_OFF_EDGE_OF_MAP);
} }
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !MapIsLocationInPark(_loc) && !gCheatsSandboxMode) if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !MapIsLocationInPark(_loc) && !GetGameState().Cheats.SandboxMode)
{ {
return GameActions::Result(GameActions::Status::NotOwned, STR_CANT_REPAINT_THIS, STR_LAND_NOT_OWNED_BY_PARK); return GameActions::Result(GameActions::Status::NotOwned, STR_CANT_REPAINT_THIS, STR_LAND_NOT_OWNED_BY_PARK);
} }

9
src/openrct2/actions/WaterLowerAction.cpp
View File

@ -9,11 +9,14 @@
#include "WaterLowerAction.h" #include "WaterLowerAction.h"
#include "../GameState.h"
#include "../OpenRCT2.h" #include "../OpenRCT2.h"
#include "../audio/audio.h" #include "../audio/audio.h"
#include "../ride/RideConstruction.h" #include "../ride/RideConstruction.h"
#include "WaterSetHeightAction.h" #include "WaterSetHeightAction.h"
using namespace OpenRCT2;
WaterLowerAction::WaterLowerAction(MapRange range) WaterLowerAction::WaterLowerAction(MapRange range)
: _range(range) : _range(range)
{ {
@ -76,7 +79,7 @@ GameActions::Result WaterLowerAction::QueryExecute(bool isExecuting) const
if (surfaceElement == nullptr) if (surfaceElement == nullptr)
continue; continue;
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !gCheatsSandboxMode) if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !GetGameState().Cheats.SandboxMode)
{ {
if (!MapIsLocationInPark(CoordsXY{ x, y })) if (!MapIsLocationInPark(CoordsXY{ x, y }))
{ {
@ -119,7 +122,7 @@ GameActions::Result WaterLowerAction::QueryExecute(bool isExecuting) const
if (isExecuting && hasChanged) if (isExecuting && hasChanged)
{ {
OpenRCT2::Audio::Play3D(OpenRCT2::Audio::SoundId::LayingOutWater, res.Position); Audio::Play3D(Audio::SoundId::LayingOutWater, res.Position);
} }
// Force ride construction to recheck area // Force ride construction to recheck area
_currentTrackSelectionFlags |= TRACK_SELECTION_FLAG_RECHECK; _currentTrackSelectionFlags |= TRACK_SELECTION_FLAG_RECHECK;
@ -135,7 +138,7 @@ uint8_t WaterLowerAction::GetLowestHeight(const MapRange& validRange) const
{ {
for (int32_t x = validRange.GetLeft(); x <= validRange.GetRight(); x += COORDS_XY_STEP) for (int32_t x = validRange.GetLeft(); x <= validRange.GetRight(); x += COORDS_XY_STEP)
{ {
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !gCheatsSandboxMode) if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !GetGameState().Cheats.SandboxMode)
{ {
if (!MapIsLocationInPark(CoordsXY{ x, y })) if (!MapIsLocationInPark(CoordsXY{ x, y }))
{ {

5
src/openrct2/actions/WaterRaiseAction.cpp
View File

@ -9,6 +9,7 @@
#include "WaterRaiseAction.h" #include "WaterRaiseAction.h"
#include "../GameState.h"
#include "../OpenRCT2.h" #include "../OpenRCT2.h"
#include "../audio/audio.h" #include "../audio/audio.h"
#include "../ride/RideConstruction.h" #include "../ride/RideConstruction.h"
@ -76,7 +77,7 @@ GameActions::Result WaterRaiseAction::QueryExecute(bool isExecuting) const
if (surfaceElement == nullptr) if (surfaceElement == nullptr)
continue; continue;
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !gCheatsSandboxMode) if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !OpenRCT2::GetGameState().Cheats.SandboxMode)
{ {
if (!MapIsLocationInPark(CoordsXY{ x, y })) if (!MapIsLocationInPark(CoordsXY{ x, y }))
{ {
@ -148,7 +149,7 @@ uint16_t WaterRaiseAction::GetHighestHeight(const MapRange& validRange) const
{ {
for (int32_t x = validRange.GetLeft(); x <= validRange.GetRight(); x += COORDS_XY_STEP) for (int32_t x = validRange.GetLeft(); x <= validRange.GetRight(); x += COORDS_XY_STEP)
{ {
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !gCheatsSandboxMode) if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !OpenRCT2::GetGameState().Cheats.SandboxMode)
{ {
if (!MapIsLocationInPark(CoordsXY{ x, y })) if (!MapIsLocationInPark(CoordsXY{ x, y }))
{ {

6
src/openrct2/actions/WaterSetHeightAction.cpp
View File

@ -48,7 +48,7 @@ GameActions::Result WaterSetHeightAction::Query() const
res.Expenditure = ExpenditureType::Landscaping; res.Expenditure = ExpenditureType::Landscaping;
res.Position = { _coords, _height * COORDS_Z_STEP }; res.Position = { _coords, _height * COORDS_Z_STEP };
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !gCheatsSandboxMode if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !GetGameState().Cheats.SandboxMode
&& GetGameState().ParkFlags & PARK_FLAGS_FORBID_LANDSCAPE_CHANGES) && GetGameState().ParkFlags & PARK_FLAGS_FORBID_LANDSCAPE_CHANGES)
{ {
return GameActions::Result(GameActions::Status::Disallowed, STR_NONE, STR_FORBIDDEN_BY_THE_LOCAL_AUTHORITY); return GameActions::Result(GameActions::Status::Disallowed, STR_NONE, STR_FORBIDDEN_BY_THE_LOCAL_AUTHORITY);
@ -65,7 +65,7 @@ GameActions::Result WaterSetHeightAction::Query() const
return GameActions::Result(GameActions::Status::NotOwned, STR_NONE, STR_LAND_NOT_OWNED_BY_PARK); return GameActions::Result(GameActions::Status::NotOwned, STR_NONE, STR_LAND_NOT_OWNED_BY_PARK);
} }
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !gCheatsSandboxMode) if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !GetGameState().Cheats.SandboxMode)
{ {
if (!MapIsLocationInPark(_coords)) if (!MapIsLocationInPark(_coords))
{ {
@ -117,7 +117,7 @@ GameActions::Result WaterSetHeightAction::Execute() const
int32_t surfaceHeight = TileElementHeight(_coords); int32_t surfaceHeight = TileElementHeight(_coords);
FootpathRemoveLitter({ _coords, surfaceHeight }); FootpathRemoveLitter({ _coords, surfaceHeight });
if (!gCheatsDisableClearanceChecks) if (!GetGameState().Cheats.DisableClearanceChecks)
WallRemoveAtZ({ _coords, surfaceHeight }); WallRemoveAtZ({ _coords, surfaceHeight });
SurfaceElement* surfaceElement = MapGetSurfaceElementAt(_coords); SurfaceElement* surfaceElement = MapGetSurfaceElementAt(_coords);

14
src/openrct2/entity/Guest.cpp
View File

@ -2048,7 +2048,7 @@ bool Guest::ShouldGoOnRide(Ride& ride, StationIndex entranceNum, bool atQueue, b
// excitement check and will only do a basic intensity check when they arrive at the ride itself. // excitement check and will only do a basic intensity check when they arrive at the ride itself.
if (ride.id == GuestHeadingToRideId) if (ride.id == GuestHeadingToRideId)
{ {
if (ride.intensity > RIDE_RATING(10, 00) && !gCheatsIgnoreRideIntensity) if (ride.intensity > RIDE_RATING(10, 00) && !GetGameState().Cheats.IgnoreRideIntensity)
{ {
PeepRideIsTooIntense(this, ride, peepAtRide); PeepRideIsTooIntense(this, ride, peepAtRide);
return false; return false;
@ -2074,7 +2074,7 @@ bool Guest::ShouldGoOnRide(Ride& ride, StationIndex entranceNum, bool atQueue, b
// ride intensity check and get me on a sheltered ride! // ride intensity check and get me on a sheltered ride!
if (!ClimateIsRaining() || !ShouldRideWhileRaining(ride)) if (!ClimateIsRaining() || !ShouldRideWhileRaining(ride))
{ {
if (!gCheatsIgnoreRideIntensity) if (!GetGameState().Cheats.IgnoreRideIntensity)
{ {
// Intensity calculations. Even though the max intensity can go up to 15, it's capped // Intensity calculations. Even though the max intensity can go up to 15, it's capped
// at 10.0 (before happiness calculations). A full happiness bar will increase the max // at 10.0 (before happiness calculations). A full happiness bar will increase the max
@ -2140,7 +2140,7 @@ bool Guest::ShouldGoOnRide(Ride& ride, StationIndex entranceNum, bool atQueue, b
return false; return false;
} }
if (!gCheatsIgnoreRideIntensity) if (!GetGameState().Cheats.IgnoreRideIntensity)
{ {
if (ride.max_positive_vertical_g > FIXED_2DP(5, 00) || ride.max_negative_vertical_g < FIXED_2DP(-4, 00) if (ride.max_positive_vertical_g > FIXED_2DP(5, 00) || ride.max_negative_vertical_g < FIXED_2DP(-4, 00)
|| ride.max_lateral_g > FIXED_2DP(4, 00)) || ride.max_lateral_g > FIXED_2DP(4, 00))
@ -2854,7 +2854,7 @@ static bool PeepShouldGoOnRideAgain(Guest* peep, const Ride& ride)
return false; return false;
if (!RideHasRatings(ride)) if (!RideHasRatings(ride))
return false; return false;
if (ride.intensity > RIDE_RATING(10, 00) && !gCheatsIgnoreRideIntensity) if (ride.intensity > RIDE_RATING(10, 00) && !GetGameState().Cheats.IgnoreRideIntensity)
return false; return false;
if (peep->Happiness < 180) if (peep->Happiness < 180)
return false; return false;
@ -2899,7 +2899,7 @@ static bool PeepReallyLikedRide(Guest* peep, const Ride& ride)
return false; return false;
if (!RideHasRatings(ride)) if (!RideHasRatings(ride))
return false; return false;
if (ride.intensity > RIDE_RATING(10, 00) && !gCheatsIgnoreRideIntensity) if (ride.intensity > RIDE_RATING(10, 00) && !GetGameState().Cheats.IgnoreRideIntensity)
return false; return false;
return true; return true;
} }
@ -3018,7 +3018,7 @@ static PeepThoughtType PeepAssessSurroundings(int16_t centre_x, int16_t centre_y
if (nearby_music == 1 && num_rubbish < 20) if (nearby_music == 1 && num_rubbish < 20)
return PeepThoughtType::Music; return PeepThoughtType::Music;
if (num_rubbish < 2 && !gCheatsDisableLittering) if (num_rubbish < 2 && !GetGameState().Cheats.DisableLittering)
// if disable littering cheat is enabled, peeps will not have the "clean and tidy park" thought // if disable littering cheat is enabled, peeps will not have the "clean and tidy park" thought
return PeepThoughtType::VeryClean; return PeepThoughtType::VeryClean;
@ -6188,7 +6188,7 @@ static PathElement* FindBreakableElement(const CoordsXYZ& loc)
*/ */
static void PeepUpdateWalkingBreakScenery(Guest* peep) static void PeepUpdateWalkingBreakScenery(Guest* peep)
{ {
if (gCheatsDisableVandalism) if (GetGameState().Cheats.DisableVandalism)
return; return;
if (!(peep->PeepFlags & PEEP_FLAGS_ANGRY)) if (!(peep->PeepFlags & PEEP_FLAGS_ANGRY))

2
src/openrct2/entity/Litter.cpp
View File

@ -49,7 +49,7 @@ static bool IsLocationLitterable(const CoordsXYZ& mapPos)
*/ */
void Litter::Create(const CoordsXYZD& litterPos, Type type) void Litter::Create(const CoordsXYZD& litterPos, Type type)
{ {
if (gCheatsDisableLittering) if (GetGameState().Cheats.DisableLittering)
return; return;
auto offsetLitterPos = litterPos auto offsetLitterPos = litterPos

2
src/openrct2/interface/Colour.h
View File

@ -253,4 +253,4 @@ uint8_t BlendColours(const uint8_t paletteIndex1, const uint8_t paletteIndex2);
#endif #endif
typedef uint8_t BlendColourMapType[PALETTE_COUNT][PALETTE_COUNT]; typedef uint8_t BlendColourMapType[PALETTE_COUNT][PALETTE_COUNT];
BlendColourMapType* GetBlendColourMap(); BlendColourMapType* GetBlendColourMap();

14
src/openrct2/interface/InteractiveConsole.cpp
View File

@ -211,7 +211,7 @@ static int32_t ConsoleCommandRides(InteractiveConsole& console, const arguments_
auto res = SetOperatingSetting(RideId::FromUnderlying(ride_index), RideSetSetting::RideType, type); auto res = SetOperatingSetting(RideId::FromUnderlying(ride_index), RideSetSetting::RideType, type);
if (res == kMoney64Undefined) if (res == kMoney64Undefined)
{ {
if (!gCheatsAllowArbitraryRideTypeChanges) if (!GetGameState().Cheats.AllowArbitraryRideTypeChanges)
{ {
console.WriteFormatLine( console.WriteFormatLine(
"That didn't work. Try enabling the 'Allow arbitrary ride type changes' cheat"); "That didn't work. Try enabling the 'Allow arbitrary ride type changes' cheat");
@ -721,15 +721,15 @@ static int32_t ConsoleCommandGet(InteractiveConsole& console, const arguments_t&
} }
else if (argv[0] == "cheat_sandbox_mode") else if (argv[0] == "cheat_sandbox_mode")
{ {
console.WriteFormatLine("cheat_sandbox_mode %d", gCheatsSandboxMode); console.WriteFormatLine("cheat_sandbox_mode %d", GetGameState().Cheats.SandboxMode);
} }
else if (argv[0] == "cheat_disable_clearance_checks") else if (argv[0] == "cheat_disable_clearance_checks")
{ {
console.WriteFormatLine("cheat_disable_clearance_checks %d", gCheatsDisableClearanceChecks); console.WriteFormatLine("cheat_disable_clearance_checks %d", GetGameState().Cheats.DisableClearanceChecks);
} }
else if (argv[0] == "cheat_disable_support_limits") else if (argv[0] == "cheat_disable_support_limits")
{ {
console.WriteFormatLine("cheat_disable_support_limits %d", gCheatsDisableSupportLimits); console.WriteFormatLine("cheat_disable_support_limits %d", GetGameState().Cheats.DisableSupportLimits);
} }
else if (argv[0] == "current_rotation") else if (argv[0] == "current_rotation")
{ {
@ -1111,7 +1111,7 @@ static int32_t ConsoleCommandSet(InteractiveConsole& console, const arguments_t&
} }
else if (argv[0] == "cheat_sandbox_mode" && InvalidArguments(&invalidArgs, int_valid[0])) else if (argv[0] == "cheat_sandbox_mode" && InvalidArguments(&invalidArgs, int_valid[0]))
{ {
if (gCheatsSandboxMode != (int_val[0] != 0)) if (GetGameState().Cheats.SandboxMode != (int_val[0] != 0))
{ {
auto cheatSetAction = CheatSetAction(CheatType::SandboxMode, int_val[0] != 0); auto cheatSetAction = CheatSetAction(CheatType::SandboxMode, int_val[0] != 0);
cheatSetAction.SetCallback([&console](const GameAction*, const GameActions::Result* res) { cheatSetAction.SetCallback([&console](const GameAction*, const GameActions::Result* res) {
@ -1129,7 +1129,7 @@ static int32_t ConsoleCommandSet(InteractiveConsole& console, const arguments_t&
} }
else if (argv[0] == "cheat_disable_clearance_checks" && InvalidArguments(&invalidArgs, int_valid[0])) else if (argv[0] == "cheat_disable_clearance_checks" && InvalidArguments(&invalidArgs, int_valid[0]))
{ {
if (gCheatsDisableClearanceChecks != (int_val[0] != 0)) if (GetGameState().Cheats.DisableClearanceChecks != (int_val[0] != 0))
{ {
auto cheatSetAction = CheatSetAction(CheatType::DisableClearanceChecks, int_val[0] != 0); auto cheatSetAction = CheatSetAction(CheatType::DisableClearanceChecks, int_val[0] != 0);
cheatSetAction.SetCallback([&console](const GameAction*, const GameActions::Result* res) { cheatSetAction.SetCallback([&console](const GameAction*, const GameActions::Result* res) {
@ -1147,7 +1147,7 @@ static int32_t ConsoleCommandSet(InteractiveConsole& console, const arguments_t&
} }
else if (argv[0] == "cheat_disable_support_limits" && InvalidArguments(&invalidArgs, int_valid[0])) else if (argv[0] == "cheat_disable_support_limits" && InvalidArguments(&invalidArgs, int_valid[0]))
{ {
if (gCheatsDisableSupportLimits != (int_val[0] != 0)) if (GetGameState().Cheats.DisableSupportLimits != (int_val[0] != 0))
{ {
auto cheatSetAction = CheatSetAction(CheatType::DisableSupportLimits, int_val[0] != 0); auto cheatSetAction = CheatSetAction(CheatType::DisableSupportLimits, int_val[0] != 0);
cheatSetAction.SetCallback([&console](const GameAction*, const GameActions::Result* res) { cheatSetAction.SetCallback([&console](const GameAction*, const GameActions::Result* res) {

5
src/openrct2/management/Marketing.cpp
View File

@ -11,6 +11,7 @@
#include "../Cheats.h" #include "../Cheats.h"
#include "../Game.h" #include "../Game.h"
#include "../GameState.h"
#include "../config/Config.h" #include "../config/Config.h"
#include "../entity/Guest.h" #include "../entity/Guest.h"
#include "../interface/Window.h" #include "../interface/Window.h"
@ -24,6 +25,8 @@
#include "Finance.h" #include "Finance.h"
#include "NewsItem.h" #include "NewsItem.h"
using namespace OpenRCT2;
const money64 AdvertisingCampaignPricePerWeek[] = { const money64 AdvertisingCampaignPricePerWeek[] = {
50.00_GBP, // PARK_ENTRY_FREE 50.00_GBP, // PARK_ENTRY_FREE
50.00_GBP, // RIDE_FREE 50.00_GBP, // RIDE_FREE
@ -100,7 +103,7 @@ void MarketingUpdate()
{ {
PROFILED_FUNCTION(); PROFILED_FUNCTION();
if (gCheatsNeverendingMarketing) if (GetGameState().Cheats.NeverendingMarketing)
return; return;
for (auto it = gMarketingCampaigns.begin(); it != gMarketingCampaigns.end();) for (auto it = gMarketingCampaigns.begin(); it != gMarketingCampaigns.end();)

2
src/openrct2/management/Research.cpp
View File

@ -627,7 +627,7 @@ bool SceneryGroupIsInvented(int32_t sgIndex)
return true; return true;
} }
if (gCheatsIgnoreResearchStatus) if (GetGameState().Cheats.IgnoreResearchStatus)
{ {
return true; return true;
} }

3
src/openrct2/paint/VirtualFloor.cpp
View File

@ -10,6 +10,7 @@
#include "VirtualFloor.h" #include "VirtualFloor.h"
#include "../Cheats.h" #include "../Cheats.h"
#include "../GameState.h"
#include "../Input.h" #include "../Input.h"
#include "../config/Config.h" #include "../config/Config.h"
#include "../interface/Viewport.h" #include "../interface/Viewport.h"
@ -244,7 +245,7 @@ static void VirtualFloorGetTileProperties(
*tileOwned = MapIsLocationOwned({ loc, height }); *tileOwned = MapIsLocationOwned({ loc, height });
if (gCheatsSandboxMode) if (GetGameState().Cheats.SandboxMode)
*tileOwned = true; *tileOwned = true;
// Iterate through the map elements of the current tile to find: // Iterate through the map elements of the current tile to find:

4
src/openrct2/paint/tile_element/Paint.Surface.cpp
View File

@ -40,6 +40,8 @@
#include <cstring> #include <cstring>
#include <iterator> #include <iterator>
using namespace OpenRCT2;
// Needed to make the sign appear above footpaths. // Needed to make the sign appear above footpaths.
static constexpr int16_t ForSaleSignZOffset = 3; static constexpr int16_t ForSaleSignZOffset = 3;
@ -1188,7 +1190,7 @@ void PaintSurface(PaintSession& session, uint8_t direction, uint16_t height, con
PaintPatrolArea(session, tileElement, height, surfaceShape); PaintPatrolArea(session, tileElement, height, surfaceShape);
// Draw Peep Spawns // Draw Peep Spawns
if (((gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) || gCheatsSandboxMode) if (((gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) || GetGameState().Cheats.SandboxMode)
&& session.ViewFlags & VIEWPORT_FLAG_LAND_OWNERSHIP) && session.ViewFlags & VIEWPORT_FLAG_LAND_OWNERSHIP)
{ {
const CoordsXY& pos = session.MapPosition; const CoordsXY& pos = session.MapPosition;

14
src/openrct2/ride/Ride.cpp
View File

@ -1434,7 +1434,7 @@ static void RideBreakdownUpdate(Ride& ride)
// continues. // continues.
if ((ride.reliability == 0 if ((ride.reliability == 0
|| static_cast<int32_t>(ScenarioRand() & 0x2FFFFF) <= 1 + RIDE_INITIAL_RELIABILITY - ride.reliability) || static_cast<int32_t>(ScenarioRand() & 0x2FFFFF) <= 1 + RIDE_INITIAL_RELIABILITY - ride.reliability)
&& !gCheatsDisableAllBreakdowns) && !GetGameState().Cheats.DisableAllBreakdowns)
{ {
int32_t breakdownReason = RideGetNewBreakdownProblem(ride); int32_t breakdownReason = RideGetNewBreakdownProblem(ride);
if (breakdownReason != -1) if (breakdownReason != -1)
@ -1493,7 +1493,7 @@ static int32_t RideGetNewBreakdownProblem(const Ride& ride)
return -1; return -1;
// If brakes failure is disabled, also take it out of the equation (see above comment why) // If brakes failure is disabled, also take it out of the equation (see above comment why)
if (gCheatsDisableBrakesFailure) if (GetGameState().Cheats.DisableBrakesFailure)
return -1; return -1;
auto monthsOld = ride.GetAge(); auto monthsOld = ride.GetAge();
@ -5077,7 +5077,7 @@ void Ride::UpdateMaxVehicles()
} }
int32_t newCarsPerTrain = std::max(proposed_num_cars_per_train, rideEntry->min_cars_in_train); int32_t newCarsPerTrain = std::max(proposed_num_cars_per_train, rideEntry->min_cars_in_train);
maxCarsPerTrain = std::max(maxCarsPerTrain, static_cast<int32_t>(rideEntry->min_cars_in_train)); maxCarsPerTrain = std::max(maxCarsPerTrain, static_cast<int32_t>(rideEntry->min_cars_in_train));
if (!gCheatsDisableTrainLengthLimit) if (!GetGameState().Cheats.DisableTrainLengthLimit)
{ {
newCarsPerTrain = std::min(maxCarsPerTrain, newCarsPerTrain); newCarsPerTrain = std::min(maxCarsPerTrain, newCarsPerTrain);
} }
@ -5166,7 +5166,7 @@ void Ride::UpdateMaxVehicles()
maxNumTrains = rideEntry->cars_per_flat_ride; maxNumTrains = rideEntry->cars_per_flat_ride;
} }
if (gCheatsDisableTrainLengthLimit) if (GetGameState().Cheats.DisableTrainLengthLimit)
{ {
maxNumTrains = OpenRCT2::Limits::MaxTrainsPerRide; maxNumTrains = OpenRCT2::Limits::MaxTrainsPerRide;
} }
@ -5512,7 +5512,7 @@ int32_t RideGetEntryIndex(int32_t rideType, int32_t rideSubType)
} }
// Can happen in select-by-track-type mode // Can happen in select-by-track-type mode
if (!RideEntryIsInvented(rideEntryIndex) && !gCheatsIgnoreResearchStatus) if (!RideEntryIsInvented(rideEntryIndex) && !GetGameState().Cheats.IgnoreResearchStatus)
{ {
continue; continue;
} }
@ -5741,7 +5741,7 @@ void Ride::FormatNameTo(Formatter& ft) const
uint64_t Ride::GetAvailableModes() const uint64_t Ride::GetAvailableModes() const
{ {
if (gCheatsShowAllOperatingModes) if (GetGameState().Cheats.ShowAllOperatingModes)
return AllRideModesAvailable; return AllRideModesAvailable;
return GetRideTypeDescriptor().RideModes; return GetRideTypeDescriptor().RideModes;
@ -5923,7 +5923,7 @@ ResultWithMessage Ride::ChangeStatusCheckTrackValidity(const CoordsXYE& trackEle
} }
} }
if (subtype != OBJECT_ENTRY_INDEX_NULL && !gCheatsEnableAllDrawableTrackPieces) if (subtype != OBJECT_ENTRY_INDEX_NULL && !GetGameState().Cheats.EnableAllDrawableTrackPieces)
{ {
const auto* rideEntry = GetRideEntryByIndex(subtype); const auto* rideEntry = GetRideEntryByIndex(subtype);
if (rideEntry->flags & RIDE_ENTRY_FLAG_NO_INVERSIONS) if (rideEntry->flags & RIDE_ENTRY_FLAG_NO_INVERSIONS)

5
src/openrct2/ride/RideConstruction.cpp
View File

@ -697,7 +697,8 @@ void RideConstructionSetDefaultNextPiece()
_currentTrackPitchEnd = slope; _currentTrackPitchEnd = slope;
_previousTrackPitchEnd = slope; _previousTrackPitchEnd = slope;
_currentTrackLiftHill = tileElement->AsTrack()->HasChain() _currentTrackLiftHill = tileElement->AsTrack()->HasChain()
&& ((slope != TrackPitch::Down25 && slope != TrackPitch::Down60) || gCheatsEnableChainLiftOnAllTrack); && ((slope != TrackPitch::Down25 && slope != TrackPitch::Down60)
|| GetGameState().Cheats.EnableChainLiftOnAllTrack);
break; break;
} }
case RideConstructionState::Back: case RideConstructionState::Back:
@ -744,7 +745,7 @@ void RideConstructionSetDefaultNextPiece()
// Set track slope and lift hill // Set track slope and lift hill
_currentTrackPitchEnd = slope; _currentTrackPitchEnd = slope;
_previousTrackPitchEnd = slope; _previousTrackPitchEnd = slope;
if (!gCheatsEnableChainLiftOnAllTrack) if (!GetGameState().Cheats.EnableChainLiftOnAllTrack)
{ {
_currentTrackLiftHill = tileElement->AsTrack()->HasChain(); _currentTrackLiftHill = tileElement->AsTrack()->HasChain();
} }

11
src/openrct2/ride/RideData.cpp
View File

@ -20,6 +20,7 @@
#include "RideData.h" #include "RideData.h"
#include "../Cheats.h" #include "../Cheats.h"
#include "../GameState.h"
#include "../audio/audio.h" #include "../audio/audio.h"
#include "../interface/Colour.h" #include "../interface/Colour.h"
#include "../localisation/Localisation.h" #include "../localisation/Localisation.h"
@ -120,6 +121,7 @@
#include <iterator> #include <iterator>
using namespace OpenRCT2;
using namespace OpenRCT2::Entity::Yaw; using namespace OpenRCT2::Entity::Yaw;
// clang-format off // clang-format off
@ -180,7 +182,7 @@ const CarEntry CableLiftVehicle = {
.no_seating_rows = 0, .no_seating_rows = 0,
.spinning_inertia = 0, .spinning_inertia = 0,
.spinning_friction = 255, .spinning_friction = 255,
.friction_sound_id = OpenRCT2::Audio::SoundId::LiftClassic, .friction_sound_id = Audio::SoundId::LiftClassic,
.ReversedCarIndex = 0, .ReversedCarIndex = 0,
.sound_range = 0, .sound_range = 0,
.double_sound_frequency = 0, .double_sound_frequency = 0,
@ -358,13 +360,14 @@ bool RideTypeDescriptor::HasFlag(uint64_t flag) const
void RideTypeDescriptor::GetAvailableTrackPieces(RideTrackGroup& res) const void RideTypeDescriptor::GetAvailableTrackPieces(RideTrackGroup& res) const
{ {
res = EnabledTrackPieces; res = EnabledTrackPieces;
if (gCheatsEnableAllDrawableTrackPieces) if (GetGameState().Cheats.EnableAllDrawableTrackPieces)
res |= ExtraTrackPieces; res |= ExtraTrackPieces;
} }
bool RideTypeDescriptor::SupportsTrackPiece(const uint64_t trackPiece) const bool RideTypeDescriptor::SupportsTrackPiece(const uint64_t trackPiece) const
{ {
return EnabledTrackPieces.get(trackPiece) || (gCheatsEnableAllDrawableTrackPieces && ExtraTrackPieces.get(trackPiece)); return EnabledTrackPieces.get(trackPiece)
|| (GetGameState().Cheats.EnableAllDrawableTrackPieces && ExtraTrackPieces.get(trackPiece));
} }
ResearchCategory RideTypeDescriptor::GetResearchCategory() const ResearchCategory RideTypeDescriptor::GetResearchCategory() const
@ -407,7 +410,7 @@ void UpdateEnabledRidePieces(ride_type_t rideType)
{ {
GetRideTypeDescriptor(rideType).GetAvailableTrackPieces(_enabledRidePieces); GetRideTypeDescriptor(rideType).GetAvailableTrackPieces(_enabledRidePieces);
if (!gCheatsEnableAllDrawableTrackPieces) if (!GetGameState().Cheats.EnableAllDrawableTrackPieces)
{ {
_enabledRidePieces &= ~_disabledRidePieces; _enabledRidePieces &= ~_disabledRidePieces;
} }

2
src/openrct2/ride/RideRatings.cpp
View File

@ -1142,7 +1142,7 @@ static void RideRatingsCalculateValue(Ride& ride)
+ (((ride.nausea * ratingsMultipliers.Nausea) * 32) >> 15); + (((ride.nausea * ratingsMultipliers.Nausea) * 32) >> 15);
int32_t monthsOld = 0; int32_t monthsOld = 0;
if (!gCheatsDisableRideValueAging) if (!GetGameState().Cheats.DisableRideValueAging)
{ {
monthsOld = ride.GetAge(); monthsOld = ride.GetAge();
} }

11
src/openrct2/ride/Track.cpp
View File

@ -11,6 +11,7 @@
#include "../Cheats.h" #include "../Cheats.h"
#include "../Game.h" #include "../Game.h"
#include "../GameState.h"
#include "../audio/audio.h" #include "../audio/audio.h"
#include "../config/Config.h" #include "../config/Config.h"
#include "../interface/Viewport.h" #include "../interface/Viewport.h"
@ -34,6 +35,7 @@
#include "TrackData.h" #include "TrackData.h"
#include "TrackDesign.h" #include "TrackDesign.h"
using namespace OpenRCT2;
using namespace OpenRCT2::TrackMetaData; using namespace OpenRCT2::TrackMetaData;
PitchAndRoll TrackPitchAndRollStart(track_type_t trackType) PitchAndRoll TrackPitchAndRollStart(track_type_t trackType)
@ -121,7 +123,7 @@ ResultWithMessage TrackAddStationElement(CoordsXYZD loc, RideId rideIndex, int32
if (ride->GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_HAS_SINGLE_PIECE_STATION)) if (ride->GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_HAS_SINGLE_PIECE_STATION))
{ {
if (ride->num_stations >= OpenRCT2::Limits::MaxStationsPerRide) if (ride->num_stations >= Limits::MaxStationsPerRide)
{ {
return { false, STR_NO_MORE_STATIONS_ALLOWED_ON_THIS_RIDE }; return { false, STR_NO_MORE_STATIONS_ALLOWED_ON_THIS_RIDE };
} }
@ -190,7 +192,7 @@ ResultWithMessage TrackAddStationElement(CoordsXYZD loc, RideId rideIndex, int32
// When attempting to place a track design, it sometimes happens that the front and back of station 0 are built, // When attempting to place a track design, it sometimes happens that the front and back of station 0 are built,
// but the middle is not. Allow this, so the track place function can actually finish building all 4 stations. // but the middle is not. Allow this, so the track place function can actually finish building all 4 stations.
// This _might_ cause issues if the track designs is bugged and actually has 5. // This _might_ cause issues if the track designs is bugged and actually has 5.
if (stationBackLoc == stationFrontLoc && ride->num_stations >= OpenRCT2::Limits::MaxStationsPerRide && !fromTrackDesign) if (stationBackLoc == stationFrontLoc && ride->num_stations >= Limits::MaxStationsPerRide && !fromTrackDesign)
{ {
return { false, STR_NO_MORE_STATIONS_ALLOWED_ON_THIS_RIDE }; return { false, STR_NO_MORE_STATIONS_ALLOWED_ON_THIS_RIDE };
} }
@ -327,8 +329,7 @@ ResultWithMessage TrackRemoveStationElement(const CoordsXYZD& loc, RideId rideIn
if (!(flags & GAME_COMMAND_FLAG_APPLY)) if (!(flags & GAME_COMMAND_FLAG_APPLY))
{ {
if ((removeLoc != stationBackLoc) && (removeLoc != stationFrontLoc) if ((removeLoc != stationBackLoc) && (removeLoc != stationFrontLoc) && ride->num_stations >= Limits::MaxStationsPerRide)
&& ride->num_stations >= OpenRCT2::Limits::MaxStationsPerRide)
{ {
return { false, STR_NO_MORE_STATIONS_ALLOWED_ON_THIS_RIDE }; return { false, STR_NO_MORE_STATIONS_ALLOWED_ON_THIS_RIDE };
} }
@ -943,7 +944,7 @@ void TrackElement::SetBrakeClosed(bool isClosed)
bool TrackElement::IsIndestructible() const bool TrackElement::IsIndestructible() const
{ {
return (Flags2 & TRACK_ELEMENT_FLAGS2_INDESTRUCTIBLE_TRACK_PIECE) != 0 && !gCheatsMakeAllDestructible; return (Flags2 & TRACK_ELEMENT_FLAGS2_INDESTRUCTIBLE_TRACK_PIECE) != 0 && !GetGameState().Cheats.MakeAllDestructible;
} }
void TrackElement::SetIsIndestructible(bool isIndestructible) void TrackElement::SetIsIndestructible(bool isIndestructible)

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

@ -743,7 +743,7 @@ static std::optional<TrackSceneryEntry> TrackDesignPlaceSceneryElementGetEntry(c
{ {
result.Type = obj->GetObjectType(); result.Type = obj->GetObjectType();
result.Index = objectMgr.GetLoadedObjectEntryIndex(obj); result.Index = objectMgr.GetLoadedObjectEntryIndex(obj);
if (!gCheatsIgnoreResearchStatus) if (!GetGameState().Cheats.IgnoreResearchStatus)
{ {
objectUnavailable = !ResearchIsInvented(result.Type, result.Index); objectUnavailable = !ResearchIsInvented(result.Type, result.Index);
} }
@ -1975,7 +1975,7 @@ static bool TrackDesignPlacePreview(TrackDesignState& tds, TrackDesign* td6, mon
{ {
*flags |= TRACK_DESIGN_FLAG_VEHICLE_UNAVAILABLE; *flags |= TRACK_DESIGN_FLAG_VEHICLE_UNAVAILABLE;
} }
else if (!RideEntryIsInvented(entry_index) && !gCheatsIgnoreResearchStatus) else if (!RideEntryIsInvented(entry_index) && !GetGameState().Cheats.IgnoreResearchStatus)
{ {
*flags |= TRACK_DESIGN_FLAG_VEHICLE_UNAVAILABLE; *flags |= TRACK_DESIGN_FLAG_VEHICLE_UNAVAILABLE;
} }

97
src/openrct2/scripting/bindings/game/ScCheats.hpp
View File

@ -12,6 +12,7 @@
#ifdef ENABLE_SCRIPTING #ifdef ENABLE_SCRIPTING
# include "../../../Cheats.h" # include "../../../Cheats.h"
# include "../../../GameState.h"
# include "../../Duktape.hpp" # include "../../Duktape.hpp"
# include "../../ScriptEngine.h" # include "../../ScriptEngine.h"
@ -78,266 +79,266 @@ namespace OpenRCT2::Scripting
private: private:
bool allowArbitraryRideTypeChanges_get() bool allowArbitraryRideTypeChanges_get()
{ {
return gCheatsAllowArbitraryRideTypeChanges; return GetGameState().Cheats.AllowArbitraryRideTypeChanges;
} }
void allowArbitraryRideTypeChanges_set(bool value) void allowArbitraryRideTypeChanges_set(bool value)
{ {
ThrowIfGameStateNotMutable(); ThrowIfGameStateNotMutable();
gCheatsAllowArbitraryRideTypeChanges = value; GetGameState().Cheats.AllowArbitraryRideTypeChanges = value;
} }
bool allowTrackPlaceInvalidHeights_get() bool allowTrackPlaceInvalidHeights_get()
{ {
return gCheatsAllowTrackPlaceInvalidHeights; return GetGameState().Cheats.AllowTrackPlaceInvalidHeights;
} }
void allowTrackPlaceInvalidHeights_set(bool value) void allowTrackPlaceInvalidHeights_set(bool value)
{ {
ThrowIfGameStateNotMutable(); ThrowIfGameStateNotMutable();
gCheatsAllowTrackPlaceInvalidHeights = value; GetGameState().Cheats.AllowTrackPlaceInvalidHeights = value;
} }
bool buildInPauseMode_get() bool buildInPauseMode_get()
{ {
return gCheatsBuildInPauseMode; return GetGameState().Cheats.BuildInPauseMode;
} }
void buildInPauseMode_set(bool value) void buildInPauseMode_set(bool value)
{ {
ThrowIfGameStateNotMutable(); ThrowIfGameStateNotMutable();
gCheatsBuildInPauseMode = value; GetGameState().Cheats.BuildInPauseMode = value;
} }
bool disableAllBreakdowns_get() bool disableAllBreakdowns_get()
{ {
return gCheatsDisableAllBreakdowns; return GetGameState().Cheats.DisableAllBreakdowns;
} }
void disableAllBreakdowns_set(bool value) void disableAllBreakdowns_set(bool value)
{ {
ThrowIfGameStateNotMutable(); ThrowIfGameStateNotMutable();
gCheatsDisableAllBreakdowns = value; GetGameState().Cheats.DisableAllBreakdowns = value;
} }
bool disableBrakesFailure_get() bool disableBrakesFailure_get()
{ {
return gCheatsDisableBrakesFailure; return GetGameState().Cheats.DisableBrakesFailure;
} }
void disableBrakesFailure_set(bool value) void disableBrakesFailure_set(bool value)
{ {
ThrowIfGameStateNotMutable(); ThrowIfGameStateNotMutable();
gCheatsDisableBrakesFailure = value; GetGameState().Cheats.DisableBrakesFailure = value;
} }
bool disableClearanceChecks_get() bool disableClearanceChecks_get()
{ {
return gCheatsDisableClearanceChecks; return GetGameState().Cheats.DisableClearanceChecks;
} }
void disableClearanceChecks_set(bool value) void disableClearanceChecks_set(bool value)
{ {
ThrowIfGameStateNotMutable(); ThrowIfGameStateNotMutable();
gCheatsDisableClearanceChecks = value; GetGameState().Cheats.DisableClearanceChecks = value;
} }
bool disableLittering_get() bool disableLittering_get()
{ {
return gCheatsDisableLittering; return GetGameState().Cheats.DisableLittering;
} }
void disableLittering_set(bool value) void disableLittering_set(bool value)
{ {
ThrowIfGameStateNotMutable(); ThrowIfGameStateNotMutable();
gCheatsDisableLittering = value; GetGameState().Cheats.DisableLittering = value;
} }
bool disablePlantAging_get() bool disablePlantAging_get()
{ {
return gCheatsDisablePlantAging; return GetGameState().Cheats.DisablePlantAging;
} }
void disablePlantAging_set(bool value) void disablePlantAging_set(bool value)
{ {
ThrowIfGameStateNotMutable(); ThrowIfGameStateNotMutable();
gCheatsDisablePlantAging = value; GetGameState().Cheats.DisablePlantAging = value;
} }
bool allowRegularPathAsQueue_get() bool allowRegularPathAsQueue_get()
{ {
return gCheatsAllowRegularPathAsQueue; return GetGameState().Cheats.AllowRegularPathAsQueue;
} }
void allowRegularPathAsQueue_set(bool value) void allowRegularPathAsQueue_set(bool value)
{ {
ThrowIfGameStateNotMutable(); ThrowIfGameStateNotMutable();
gCheatsAllowRegularPathAsQueue = value; GetGameState().Cheats.AllowRegularPathAsQueue = value;
} }
bool allowSpecialColourSchemes_get() bool allowSpecialColourSchemes_get()
{ {
return gCheatsAllowSpecialColourSchemes; return GetGameState().Cheats.AllowSpecialColourSchemes;
} }
void allowSpecialColourSchemes_set(bool value) void allowSpecialColourSchemes_set(bool value)
{ {
ThrowIfGameStateNotMutable(); ThrowIfGameStateNotMutable();
gCheatsAllowSpecialColourSchemes = value; GetGameState().Cheats.AllowSpecialColourSchemes = value;
} }
bool disableRideValueAging_get() bool disableRideValueAging_get()
{ {
return gCheatsDisableRideValueAging; return GetGameState().Cheats.DisableRideValueAging;
} }
void disableRideValueAging_set(bool value) void disableRideValueAging_set(bool value)
{ {
ThrowIfGameStateNotMutable(); ThrowIfGameStateNotMutable();
gCheatsDisableRideValueAging = value; GetGameState().Cheats.DisableRideValueAging = value;
} }
bool disableSupportLimits_get() bool disableSupportLimits_get()
{ {
return gCheatsDisableSupportLimits; return GetGameState().Cheats.DisableSupportLimits;
} }
void disableSupportLimits_set(bool value) void disableSupportLimits_set(bool value)
{ {
ThrowIfGameStateNotMutable(); ThrowIfGameStateNotMutable();
gCheatsDisableSupportLimits = value; GetGameState().Cheats.DisableSupportLimits = value;
} }
bool disableTrainLengthLimit_get() bool disableTrainLengthLimit_get()
{ {
return gCheatsDisableTrainLengthLimit; return GetGameState().Cheats.DisableTrainLengthLimit;
} }
void disableTrainLengthLimit_set(bool value) void disableTrainLengthLimit_set(bool value)
{ {
ThrowIfGameStateNotMutable(); ThrowIfGameStateNotMutable();
gCheatsDisableTrainLengthLimit = value; GetGameState().Cheats.DisableTrainLengthLimit = value;
} }
bool disableVandalism_get() bool disableVandalism_get()
{ {
return gCheatsDisableVandalism; return GetGameState().Cheats.DisableVandalism;
} }
void disableVandalism_set(bool value) void disableVandalism_set(bool value)
{ {
ThrowIfGameStateNotMutable(); ThrowIfGameStateNotMutable();
gCheatsDisableVandalism = value; GetGameState().Cheats.DisableVandalism = value;
} }
bool enableAllDrawableTrackPieces_get() bool enableAllDrawableTrackPieces_get()
{ {
return gCheatsEnableAllDrawableTrackPieces; return GetGameState().Cheats.EnableAllDrawableTrackPieces;
} }
void enableAllDrawableTrackPieces_set(bool value) void enableAllDrawableTrackPieces_set(bool value)
{ {
ThrowIfGameStateNotMutable(); ThrowIfGameStateNotMutable();
gCheatsEnableAllDrawableTrackPieces = value; GetGameState().Cheats.EnableAllDrawableTrackPieces = value;
} }
bool enableChainLiftOnAllTrack_get() bool enableChainLiftOnAllTrack_get()
{ {
return gCheatsEnableChainLiftOnAllTrack; return GetGameState().Cheats.EnableChainLiftOnAllTrack;
} }
void enableChainLiftOnAllTrack_set(bool value) void enableChainLiftOnAllTrack_set(bool value)
{ {
ThrowIfGameStateNotMutable(); ThrowIfGameStateNotMutable();
gCheatsEnableChainLiftOnAllTrack = value; GetGameState().Cheats.EnableChainLiftOnAllTrack = value;
} }
bool fastLiftHill_get() bool fastLiftHill_get()
{ {
return gCheatsUnlockOperatingLimits; return GetGameState().Cheats.UnlockOperatingLimits;
} }
void fastLiftHill_set(bool value) void fastLiftHill_set(bool value)
{ {
ThrowIfGameStateNotMutable(); ThrowIfGameStateNotMutable();
gCheatsUnlockOperatingLimits = value; GetGameState().Cheats.UnlockOperatingLimits = value;
} }
bool freezeWeather_get() bool freezeWeather_get()
{ {
return gCheatsFreezeWeather; return GetGameState().Cheats.FreezeWeather;
} }
void freezeWeather_set(bool value) void freezeWeather_set(bool value)
{ {
ThrowIfGameStateNotMutable(); ThrowIfGameStateNotMutable();
gCheatsFreezeWeather = value; GetGameState().Cheats.FreezeWeather = value;
} }
bool ignoreResearchStatus_get() bool ignoreResearchStatus_get()
{ {
return gCheatsIgnoreResearchStatus; return GetGameState().Cheats.IgnoreResearchStatus;
} }
void ignoreResearchStatus_set(bool value) void ignoreResearchStatus_set(bool value)
{ {
ThrowIfGameStateNotMutable(); ThrowIfGameStateNotMutable();
gCheatsIgnoreResearchStatus = value; GetGameState().Cheats.IgnoreResearchStatus = value;
} }
bool ignoreRideIntensity_get() bool ignoreRideIntensity_get()
{ {
return gCheatsIgnoreRideIntensity; return GetGameState().Cheats.IgnoreRideIntensity;
} }
void ignoreRideIntensity_set(bool value) void ignoreRideIntensity_set(bool value)
{ {
ThrowIfGameStateNotMutable(); ThrowIfGameStateNotMutable();
gCheatsIgnoreRideIntensity = value; GetGameState().Cheats.IgnoreRideIntensity = value;
} }
bool neverendingMarketing_get() bool neverendingMarketing_get()
{ {
return gCheatsNeverendingMarketing; return GetGameState().Cheats.NeverendingMarketing;
} }
void neverendingMarketing_set(bool value) void neverendingMarketing_set(bool value)
{ {
ThrowIfGameStateNotMutable(); ThrowIfGameStateNotMutable();
gCheatsNeverendingMarketing = value; GetGameState().Cheats.NeverendingMarketing = value;
} }
bool sandboxMode_get() bool sandboxMode_get()
{ {
return gCheatsSandboxMode; return GetGameState().Cheats.SandboxMode;
} }
void sandboxMode_set(bool value) void sandboxMode_set(bool value)
{ {
ThrowIfGameStateNotMutable(); ThrowIfGameStateNotMutable();
gCheatsSandboxMode = value; GetGameState().Cheats.SandboxMode = value;
} }
bool showAllOperatingModes_get() bool showAllOperatingModes_get()
{ {
return gCheatsShowAllOperatingModes; return GetGameState().Cheats.ShowAllOperatingModes;
} }
void showAllOperatingModes_set(bool value) void showAllOperatingModes_set(bool value)
{ {
ThrowIfGameStateNotMutable(); ThrowIfGameStateNotMutable();
gCheatsShowAllOperatingModes = value; GetGameState().Cheats.ShowAllOperatingModes = value;
} }
bool showVehiclesFromOtherTrackTypes_get() bool showVehiclesFromOtherTrackTypes_get()
{ {
return gCheatsShowVehiclesFromOtherTrackTypes; return GetGameState().Cheats.ShowVehiclesFromOtherTrackTypes;
} }
void showVehiclesFromOtherTrackTypes_set(bool value) void showVehiclesFromOtherTrackTypes_set(bool value)
{ {
ThrowIfGameStateNotMutable(); ThrowIfGameStateNotMutable();
gCheatsShowVehiclesFromOtherTrackTypes = value; GetGameState().Cheats.ShowVehiclesFromOtherTrackTypes = value;
} }
}; };
} // namespace OpenRCT2::Scripting } // namespace OpenRCT2::Scripting

6
src/openrct2/windows/_legacy.cpp
View File

@ -10,6 +10,7 @@
#include "../Cheats.h" #include "../Cheats.h"
#include "../Context.h" #include "../Context.h"
#include "../Game.h" #include "../Game.h"
#include "../GameState.h"
#include "../Input.h" #include "../Input.h"
#include "../actions/MazeSetTrackAction.h" #include "../actions/MazeSetTrackAction.h"
#include "../actions/TrackPlaceAction.h" #include "../actions/TrackPlaceAction.h"
@ -30,6 +31,7 @@
#include <iterator> #include <iterator>
#include <tuple> #include <tuple>
using namespace OpenRCT2;
using namespace OpenRCT2::TrackMetaData; using namespace OpenRCT2::TrackMetaData;
bool gDisableErrorWindowSound = false; bool gDisableErrorWindowSound = false;
@ -307,7 +309,7 @@ bool WindowRideConstructionUpdateState(
if (alternativeType != TrackElemType::None && (availablePieces.get(trackType))) if (alternativeType != TrackElemType::None && (availablePieces.get(trackType)))
{ {
trackType = alternativeType; trackType = alternativeType;
if (!gCheatsEnableChainLiftOnAllTrack) if (!GetGameState().Cheats.EnableChainLiftOnAllTrack)
liftHillAndInvertedState &= ~CONSTRUCTION_LIFT_HILL_SELECTED; liftHillAndInvertedState &= ~CONSTRUCTION_LIFT_HILL_SELECTED;
} }
} }
@ -357,7 +359,7 @@ bool WindowRideConstructionUpdateState(
turnOffLiftHill = true; turnOffLiftHill = true;
} }
if (turnOffLiftHill && !gCheatsEnableChainLiftOnAllTrack) if (turnOffLiftHill && !GetGameState().Cheats.EnableChainLiftOnAllTrack)
{ {
liftHillAndInvertedState &= ~CONSTRUCTION_LIFT_HILL_SELECTED; liftHillAndInvertedState &= ~CONSTRUCTION_LIFT_HILL_SELECTED;
_currentTrackLiftHill &= ~CONSTRUCTION_LIFT_HILL_SELECTED; _currentTrackLiftHill &= ~CONSTRUCTION_LIFT_HILL_SELECTED;

2
src/openrct2/world/Climate.cpp
View File

@ -126,7 +126,7 @@ void ClimateUpdate()
if (gScreenFlags & (~SCREEN_FLAGS_PLAYING)) if (gScreenFlags & (~SCREEN_FLAGS_PLAYING))
return; return;
if (!gCheatsFreezeWeather) if (!GetGameState().Cheats.FreezeWeather)
{ {
if (gameState.ClimateUpdateTimer) if (gameState.ClimateUpdateTimer)
{ {

2
src/openrct2/world/ConstructionClearance.cpp
View File

@ -137,7 +137,7 @@ GameActions::Result MapCanConstructWithClearAt(
return res; return res;
} }
if (gCheatsDisableClearanceChecks) if (GetGameState().Cheats.DisableClearanceChecks)
{ {
res.SetData(ConstructClearResult{ groundFlags }); res.SetData(ConstructClearResult{ groundFlags });
return res; return res;

9
src/openrct2/world/Footpath.cpp
View File

@ -10,6 +10,7 @@
#include "../Cheats.h" #include "../Cheats.h"
#include "../Context.h" #include "../Context.h"
#include "../Game.h" #include "../Game.h"
#include "../GameState.h"
#include "../Identifiers.h" #include "../Identifiers.h"
#include "../OpenRCT2.h" #include "../OpenRCT2.h"
#include "../actions/FootpathPlaceAction.h" #include "../actions/FootpathPlaceAction.h"
@ -825,7 +826,7 @@ static void Loc6A6D7E(
FootpathNeighbourList* neighbourList) FootpathNeighbourList* neighbourList)
{ {
auto targetPos = CoordsXY{ initialTileElementPos } + CoordsDirectionDelta[direction]; auto targetPos = CoordsXY{ initialTileElementPos } + CoordsDirectionDelta[direction];
if (((gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) || gCheatsSandboxMode) && MapIsEdge(targetPos)) if (((gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) || OpenRCT2::GetGameState().Cheats.SandboxMode) && MapIsEdge(targetPos))
{ {
if (query) if (query)
{ {
@ -2353,7 +2354,7 @@ void FootpathRemoveEdgesAt(const CoordsXY& footpathPos, TileElement* tileElement
static ObjectEntryIndex FootpathGetDefaultSurface(bool queue) static ObjectEntryIndex FootpathGetDefaultSurface(bool queue)
{ {
bool showEditorPaths = ((gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) || gCheatsSandboxMode); bool showEditorPaths = ((gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) || OpenRCT2::GetGameState().Cheats.SandboxMode);
for (ObjectEntryIndex i = 0; i < MAX_FOOTPATH_SURFACE_OBJECTS; i++) for (ObjectEntryIndex i = 0; i < MAX_FOOTPATH_SURFACE_OBJECTS; i++)
{ {
auto pathEntry = GetPathSurfaceEntry(i); auto pathEntry = GetPathSurfaceEntry(i);
@ -2377,7 +2378,7 @@ static bool FootpathIsSurfaceEntryOkay(ObjectEntryIndex index, bool queue)
auto pathEntry = GetPathSurfaceEntry(index); auto pathEntry = GetPathSurfaceEntry(index);
if (pathEntry != nullptr) if (pathEntry != nullptr)
{ {
bool showEditorPaths = ((gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) || gCheatsSandboxMode); bool showEditorPaths = ((gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) || OpenRCT2::GetGameState().Cheats.SandboxMode);
if (!showEditorPaths && (pathEntry->Flags & FOOTPATH_ENTRY_FLAG_SHOW_ONLY_IN_SCENARIO_EDITOR)) if (!showEditorPaths && (pathEntry->Flags & FOOTPATH_ENTRY_FLAG_SHOW_ONLY_IN_SCENARIO_EDITOR))
{ {
return false; return false;
@ -2405,7 +2406,7 @@ static ObjectEntryIndex FootpathGetDefaultRailings()
static bool FootpathIsLegacyPathEntryOkay(ObjectEntryIndex index) static bool FootpathIsLegacyPathEntryOkay(ObjectEntryIndex index)
{ {
bool showEditorPaths = ((gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) || gCheatsSandboxMode); bool showEditorPaths = ((gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) || OpenRCT2::GetGameState().Cheats.SandboxMode);
auto& objManager = OpenRCT2::GetContext()->GetObjectManager(); auto& objManager = OpenRCT2::GetContext()->GetObjectManager();
auto footpathObj = static_cast<FootpathObject*>(objManager.GetLoadedObject(ObjectType::Paths, index)); auto footpathObj = static_cast<FootpathObject*>(objManager.GetLoadedObject(ObjectType::Paths, index));
if (footpathObj != nullptr) if (footpathObj != nullptr)

12
src/openrct2/world/Map.cpp
View File

@ -827,7 +827,7 @@ bool MapCanBuildAt(const CoordsXYZ& loc)
{ {
if (gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) if (gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR)
return true; return true;
if (gCheatsSandboxMode) if (GetGameState().Cheats.SandboxMode)
return true; return true;
if (MapIsLocationOwned(loc)) if (MapIsLocationOwned(loc))
return true; return true;
@ -963,7 +963,7 @@ uint8_t MapGetLowestLandHeight(const MapRange& range)
if (surfaceElement != nullptr && min_height > surfaceElement->BaseHeight) if (surfaceElement != nullptr && min_height > surfaceElement->BaseHeight)
{ {
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !gCheatsSandboxMode) if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !GetGameState().Cheats.SandboxMode)
{ {
if (!MapIsLocationInPark(CoordsXY{ xi, yi })) if (!MapIsLocationInPark(CoordsXY{ xi, yi }))
{ {
@ -992,7 +992,7 @@ uint8_t MapGetHighestLandHeight(const MapRange& range)
auto* surfaceElement = MapGetSurfaceElementAt(CoordsXY{ xi, yi }); auto* surfaceElement = MapGetSurfaceElementAt(CoordsXY{ xi, yi });
if (surfaceElement != nullptr) if (surfaceElement != nullptr)
{ {
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !gCheatsSandboxMode) if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !GetGameState().Cheats.SandboxMode)
{ {
if (!MapIsLocationInPark(CoordsXY{ xi, yi })) if (!MapIsLocationInPark(CoordsXY{ xi, yi }))
{ {
@ -1362,8 +1362,8 @@ void MapRemoveOutOfRangeElements()
// NOTE: This is only a workaround for non-networked games. // NOTE: This is only a workaround for non-networked games.
// Map resize has to become its own Game Action to properly solve this issue. // Map resize has to become its own Game Action to properly solve this issue.
// //
bool buildState = gCheatsBuildInPauseMode; bool buildState = GetGameState().Cheats.BuildInPauseMode;
gCheatsBuildInPauseMode = true; GetGameState().Cheats.BuildInPauseMode = true;
for (int32_t y = MAXIMUM_MAP_SIZE_BIG - COORDS_XY_STEP; y >= 0; y -= COORDS_XY_STEP) for (int32_t y = MAXIMUM_MAP_SIZE_BIG - COORDS_XY_STEP; y >= 0; y -= COORDS_XY_STEP)
{ {
@ -1384,7 +1384,7 @@ void MapRemoveOutOfRangeElements()
} }
// Reset cheat state // Reset cheat state
gCheatsBuildInPauseMode = buildState; GetGameState().Cheats.BuildInPauseMode = buildState;
} }
static void MapExtendBoundarySurfaceExtendTile(const SurfaceElement& sourceTile, SurfaceElement& destTile) static void MapExtendBoundarySurfaceExtendTile(const SurfaceElement& sourceTile, SurfaceElement& destTile)

6
src/openrct2/world/Scenery.cpp
View File

@ -180,7 +180,7 @@ void SmallSceneryElement::UpdateAge(const CoordsXY& sceneryPos)
return; return;
} }
if (gCheatsDisablePlantAging && sceneryEntry->HasFlag(SMALL_SCENERY_FLAG_CAN_BE_WATERED)) if (OpenRCT2::GetGameState().Cheats.DisablePlantAging && sceneryEntry->HasFlag(SMALL_SCENERY_FLAG_CAN_BE_WATERED))
{ {
return; return;
} }
@ -315,7 +315,7 @@ bool IsSceneryAvailableToBuild(const ScenerySelection& item)
return true; return true;
} }
if (!gCheatsIgnoreResearchStatus) if (!OpenRCT2::GetGameState().Cheats.IgnoreResearchStatus)
{ {
if (!SceneryIsInvented(item)) if (!SceneryIsInvented(item))
{ {
@ -323,7 +323,7 @@ bool IsSceneryAvailableToBuild(const ScenerySelection& item)
} }
} }
if (!gCheatsSandboxMode && !(gScreenFlags & SCREEN_FLAGS_EDITOR)) if (!OpenRCT2::GetGameState().Cheats.SandboxMode && !(gScreenFlags & SCREEN_FLAGS_EDITOR))
{ {
if (IsSceneryItemRestricted(item)) if (IsSceneryItemRestricted(item))
{ {

4
test/tests/PlayTests.cpp
View File

@ -116,7 +116,7 @@ TEST_F(PlayTests, SecondGuestInQueueShouldNotRideIfNoFunds)
execute<RideSetPriceAction>(ferrisWheel.id, 0, true); execute<RideSetPriceAction>(ferrisWheel.id, 0, true);
// Ignore intensity to stimulate peeps to queue into ferris wheel // Ignore intensity to stimulate peeps to queue into ferris wheel
gCheatsIgnoreRideIntensity = true; GetGameState().Cheats.IgnoreRideIntensity = true;
// Insert a rich guest // Insert a rich guest
auto richGuest = gs->GetPark().GenerateGuest(); auto richGuest = gs->GetPark().GenerateGuest();
@ -176,7 +176,7 @@ TEST_F(PlayTests, CarRideWithOneCarOnlyAcceptsTwoGuests)
execute<RideSetPriceAction>(carRide.id, 0, true); execute<RideSetPriceAction>(carRide.id, 0, true);
// Ignore intensity to stimulate peeps to queue into the ride // Ignore intensity to stimulate peeps to queue into the ride
gCheatsIgnoreRideIntensity = true; GetGameState().Cheats.IgnoreRideIntensity = true;
// Create some guests // Create some guests
std::vector<Peep*> guests; std::vector<Peep*> guests;