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()
{
auto cheatSetAction = CheatSetAction(CheatType::DisableClearanceChecks, gCheatsDisableClearanceChecks ? 0 : 1);
auto cheatSetAction = CheatSetAction(
CheatType::DisableClearanceChecks, GetGameState().Cheats.DisableClearanceChecks ? 0 : 1);
GameActions::Execute(&cheatSetAction);
}

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

@ -364,7 +364,7 @@ InteractionInfo ViewportInteractionGetItemRight(const ScreenCoordsXY& screenCoor
else
{
// 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;
return info;
@ -494,7 +494,7 @@ InteractionInfo ViewportInteractionGetItemRight(const ScreenCoordsXY& screenCoor
return info;
}
case ViewportInteractionItem::ParkEntrance:
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !gCheatsSandboxMode)
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !GetGameState().Cheats.SandboxMode)
break;
if (tileElement->GetType() != TileElementType::Entrance)

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

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

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

@ -13,6 +13,7 @@
#include <openrct2-ui/interface/Dropdown.h>
#include <openrct2-ui/interface/Widget.h>
#include <openrct2/Context.h>
#include <openrct2/GameState.h>
#include <openrct2/Input.h>
#include <openrct2/core/BitSet.hpp>
#include <openrct2/drawing/Drawing.h>
@ -525,7 +526,8 @@ void WindowDropdownShowColour(WindowBase* w, Widget* widget, uint8_t dropdownCol
{
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
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;
// 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();
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,
// 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;
}
// 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;
}
@ -1393,7 +1396,7 @@ public:
void KeyboardShortcutDemolishCurrent()
{
if (IsWidgetDisabled(WIDX_REMOVE) || widgets[WIDX_REMOVE].type == WindowWidgetType::Empty
|| (!gCheatsBuildInPauseMode && GameIsPaused()))
|| (!GetGameState().Cheats.BuildInPauseMode && GameIsPaused()))
{
return;
}

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

@ -607,7 +607,7 @@ public:
auto result = GameActions::Execute(&gameAction);
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);
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;
}
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
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);
}
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !gCheatsSandboxMode)
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !GetGameState().Cheats.SandboxMode)
{
// Render the map legend
if (selected_tab == PAGE_RIDES)
@ -1461,7 +1461,7 @@ private:
{
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;
else if (selected_tab == PAGE_RIDES)
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);
// Skip if vehicle type is not invented yet
if (!RideEntryIsInvented(rideEntryIndex) && !gCheatsIgnoreResearchStatus)
if (!RideEntryIsInvented(rideEntryIndex) && !GetGameState().Cheats.IgnoreResearchStatus)
{
continue;
}
@ -677,7 +677,7 @@ private:
for (auto rideEntryIndex : rideEntries)
{
// Skip if vehicle type is not invented yet
if (!RideEntryIsInvented(rideEntryIndex) && !gCheatsIgnoreResearchStatus)
if (!RideEntryIsInvented(rideEntryIndex) && !GetGameState().Cheats.IgnoreResearchStatus)
continue;
// Ride entries

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

@ -1603,7 +1603,7 @@ private:
}
}
}
if (gCheatsAllowArbitraryRideTypeChanges)
if (GetGameState().Cheats.AllowArbitraryRideTypeChanges)
{
minHeight += 15;
}
@ -1904,7 +1904,7 @@ private:
int32_t rideTypeIterator, rideTypeIteratorMax;
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)
|| ride.type == RIDE_TYPE_MINI_GOLF))
@ -1945,7 +1945,7 @@ private:
continue;
// Skip if vehicle type has not been invented yet
if (!RideEntryIsInvented(rideEntryIndex) && !gCheatsIgnoreResearchStatus)
if (!RideEntryIsInvented(rideEntryIndex) && !GetGameState().Cheats.IgnoreResearchStatus)
continue;
auto name = currentRideEntry->naming.Name;
@ -2233,7 +2233,7 @@ private:
disabled_widgets &= ~((1uLL << WIDX_DEMOLISH) | (1uLL << WIDX_CONSTRUCTION));
if (ride->lifecycle_flags & (RIDE_LIFECYCLE_INDESTRUCTIBLE | RIDE_LIFECYCLE_INDESTRUCTIBLE_TRACK)
&& !gCheatsMakeAllDestructible)
&& !GetGameState().Cheats.MakeAllDestructible)
disabled_widgets |= (1uLL << WIDX_DEMOLISH);
auto ft = Formatter::Common();
@ -2271,7 +2271,7 @@ private:
AnchorBorderWidgets();
const int32_t offset = gCheatsAllowArbitraryRideTypeChanges ? 15 : 0;
const int32_t offset = GetGameState().Cheats.AllowArbitraryRideTypeChanges ? 15 : 0;
// Anchor main page specific widgets
widgets[WIDX_VIEWPORT].right = width - 26;
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].bottom = height - 5;
if (!gCheatsAllowArbitraryRideTypeChanges)
if (!GetGameState().Cheats.AllowArbitraryRideTypeChanges)
{
widgets[WIDX_RIDE_TYPE].type = WindowWidgetType::Empty;
widgets[WIDX_RIDE_TYPE_DROPDOWN].type = WindowWidgetType::Empty;
@ -2698,7 +2698,7 @@ private:
widgets[WIDX_VEHICLE_TYPE].text = rideEntry->naming.Name;
// 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_INCREASE].type = WindowWidgetType::Button;
@ -2712,7 +2712,7 @@ private:
}
// 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_INCREASE].type = WindowWidgetType::Button;
@ -2726,7 +2726,8 @@ private:
}
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;
if (ride->HasLifecycleFlag(RIDE_LIFECYCLE_REVERSED_TRAINS))
@ -2954,9 +2955,9 @@ private:
const auto& operatingSettings = ride->GetRideTypeDescriptor().OperatingSettings;
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;
}
@ -2975,8 +2976,8 @@ private:
const auto& operatingSettings = ride->GetRideTypeDescriptor().OperatingSettings;
uint8_t maxValue = operatingSettings.MaxValue;
uint8_t minValue = gCheatsUnlockOperatingLimits ? 0 : operatingSettings.MinValue;
if (gCheatsUnlockOperatingLimits)
uint8_t minValue = GetGameState().Cheats.UnlockOperatingLimits ? 0 : operatingSettings.MinValue;
if (GetGameState().Cheats.UnlockOperatingLimits)
{
maxValue = OpenRCT2::Limits::CheatsMaxOperatingLimit;
}
@ -3113,17 +3114,19 @@ private:
ModeTweakDecrease();
break;
case WIDX_LIFT_HILL_SPEED_INCREASE:
upperBound = gCheatsUnlockOperatingLimits ? OpenRCT2::Limits::CheatsMaxOperatingLimit
: ride->GetRideTypeDescriptor().LiftData.maximum_speed;
lowerBound = gCheatsUnlockOperatingLimits ? 0 : ride->GetRideTypeDescriptor().LiftData.minimum_speed;
upperBound = GetGameState().Cheats.UnlockOperatingLimits ? OpenRCT2::Limits::CheatsMaxOperatingLimit
: ride->GetRideTypeDescriptor().LiftData.maximum_speed;
lowerBound = GetGameState().Cheats.UnlockOperatingLimits ? 0
: ride->GetRideTypeDescriptor().LiftData.minimum_speed;
SetOperatingSetting(
rideId, RideSetSetting::LiftHillSpeed,
std::clamp<int16_t>(ride->lift_hill_speed + 1, lowerBound, upperBound));
break;
case WIDX_LIFT_HILL_SPEED_DECREASE:
upperBound = gCheatsUnlockOperatingLimits ? OpenRCT2::Limits::CheatsMaxOperatingLimit
: ride->GetRideTypeDescriptor().LiftData.maximum_speed;
lowerBound = gCheatsUnlockOperatingLimits ? 0 : ride->GetRideTypeDescriptor().LiftData.minimum_speed;
upperBound = GetGameState().Cheats.UnlockOperatingLimits ? OpenRCT2::Limits::CheatsMaxOperatingLimit
: ride->GetRideTypeDescriptor().LiftData.maximum_speed;
lowerBound = GetGameState().Cheats.UnlockOperatingLimits ? 0
: ride->GetRideTypeDescriptor().LiftData.minimum_speed;
SetOperatingSetting(
rideId, RideSetSetting::LiftHillSpeed,
std::clamp<int16_t>(ride->lift_hill_speed - 1, lowerBound, upperBound));
@ -3169,15 +3172,15 @@ private:
LoadDropdown(&widgets[widgetIndex]);
break;
case WIDX_OPERATE_NUMBER_OF_CIRCUITS_INCREASE:
upperBound = gCheatsUnlockOperatingLimits ? OpenRCT2::Limits::CheatsMaxOperatingLimit
: OpenRCT2::Limits::MaxCircuitsPerRide;
upperBound = GetGameState().Cheats.UnlockOperatingLimits ? OpenRCT2::Limits::CheatsMaxOperatingLimit
: OpenRCT2::Limits::MaxCircuitsPerRide;
lowerBound = 1;
SetOperatingSetting(
rideId, RideSetSetting::NumCircuits, std::clamp<int16_t>(ride->num_circuits + 1, lowerBound, upperBound));
break;
case WIDX_OPERATE_NUMBER_OF_CIRCUITS_DECREASE:
upperBound = gCheatsUnlockOperatingLimits ? OpenRCT2::Limits::CheatsMaxOperatingLimit
: OpenRCT2::Limits::MaxCircuitsPerRide;
upperBound = GetGameState().Cheats.UnlockOperatingLimits ? OpenRCT2::Limits::CheatsMaxOperatingLimit
: OpenRCT2::Limits::MaxCircuitsPerRide;
lowerBound = 1;
SetOperatingSetting(
rideId, RideSetSetting::NumCircuits, std::clamp<int16_t>(ride->num_circuits - 1, lowerBound, upperBound));
@ -3219,9 +3222,9 @@ private:
}
const auto& operatingSettings = ride.GetRideTypeDescriptor().OperatingSettings;
int16_t maxValue = gCheatsUnlockOperatingLimits ? OpenRCT2::Limits::CheatsMaxOperatingLimit
: operatingSettings.MaxValue;
int16_t minValue = gCheatsUnlockOperatingLimits ? 0 : operatingSettings.MinValue;
int16_t maxValue = GetGameState().Cheats.UnlockOperatingLimits ? OpenRCT2::Limits::CheatsMaxOperatingLimit
: operatingSettings.MaxValue;
int16_t minValue = GetGameState().Cheats.UnlockOperatingLimits ? 0 : operatingSettings.MinValue;
const auto& title = widgets[WIDX_MODE_TWEAK_LABEL].text;
Formatter ft;
@ -3300,9 +3303,9 @@ private:
if (widgetIndex == WIDX_MODE_TWEAK)
{
const auto& operatingSettings = ride->GetRideTypeDescriptor().OperatingSettings;
uint32_t maxValue = gCheatsUnlockOperatingLimits ? OpenRCT2::Limits::CheatsMaxOperatingLimit
: operatingSettings.MaxValue;
uint32_t minValue = gCheatsUnlockOperatingLimits ? 0 : operatingSettings.MinValue;
uint32_t maxValue = GetGameState().Cheats.UnlockOperatingLimits ? OpenRCT2::Limits::CheatsMaxOperatingLimit
: operatingSettings.MaxValue;
uint32_t minValue = GetGameState().Cheats.UnlockOperatingLimits ? 0 : operatingSettings.MinValue;
auto multiplier = ride->GetRideTypeDescriptor().OperatingSettings.OperatingSettingMultiplier;
try
@ -4880,7 +4883,7 @@ private:
}
}
if (gCheatsUnlockOperatingLimits || musicObj->SupportsRideType(ride->type))
if (GetGameState().Cheats.UnlockOperatingLimits || musicObj->SupportsRideType(ride->type))
{
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)
&& !gCheatsEnableAllDrawableTrackPieces)
&& !GetGameState().Cheats.EnableAllDrawableTrackPieces)
{
// Disable lift hill toggle and banking if current track piece is uphill
if (_previousTrackPitchEnd == TrackPitch::Up25 || _previousTrackPitchEnd == TrackPitch::Up60
@ -714,7 +714,7 @@ public:
{
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))
{
@ -808,7 +808,7 @@ public:
{
if (_currentTrackPitchEnd == TrackPitch::None && _previousTrackRollEnd != TrackRoll::None
&& (!currentRide->GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_UP_INCLINE_REQUIRES_LIFT)
|| gCheatsEnableAllDrawableTrackPieces))
|| GetGameState().Cheats.EnableAllDrawableTrackPieces))
{
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 (gCheatsEnableChainLiftOnAllTrack)
if (GetGameState().Cheats.EnableChainLiftOnAllTrack)
{
disabledWidgets &= ~(1uLL << WIDX_CHAIN_LIFT);
}
@ -1290,7 +1290,8 @@ public:
case WIDX_CHAIN_LIFT:
RideConstructionInvalidateCurrentTrack();
_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;
_currentTrackPrice = kMoney64Undefined;
WindowRideConstructionUpdateActiveElements();
@ -1369,7 +1370,7 @@ public:
case WIDX_O_TRACK:
RideConstructionInvalidateCurrentTrack();
_currentTrackAlternative |= RIDE_TYPE_ALTERNATIVE_TRACK_PIECES;
if (!gCheatsEnableChainLiftOnAllTrack)
if (!GetGameState().Cheats.EnableChainLiftOnAllTrack)
_currentTrackLiftHill &= ~CONSTRUCTION_LIFT_HILL_SELECTED;
_currentTrackPrice = kMoney64Undefined;
WindowRideConstructionUpdateActiveElements();
@ -1686,13 +1687,14 @@ public:
if (currentRide->GetRideTypeDescriptor().HasFlag(RIDE_TYPE_FLAG_UP_INCLINE_REQUIRES_LIFT)
&& (_currentTrackPitchEnd == TrackPitch::Up25 || _currentTrackPitchEnd == TrackPitch::Up60)
&& !gCheatsEnableAllDrawableTrackPieces)
&& !GetGameState().Cheats.EnableAllDrawableTrackPieces)
{
_currentTrackLiftHill |= CONSTRUCTION_LIFT_HILL_SELECTED;
}
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;
}
@ -2190,7 +2192,7 @@ private:
}
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);
if (_rideConstructionState == RideConstructionState::Back)
{
@ -2414,7 +2416,7 @@ private:
{
_currentTrackPitchEnd = slope;
_currentTrackPrice = kMoney64Undefined;
if (_rideConstructionState == RideConstructionState::Front && !gCheatsEnableChainLiftOnAllTrack)
if (_rideConstructionState == RideConstructionState::Front && !GetGameState().Cheats.EnableChainLiftOnAllTrack)
{
switch (slope)
{
@ -3487,7 +3489,7 @@ void RideConstructionTooldownConstruct(const ScreenCoordsXY& screenCoords)
z -= bx;
// 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;
}

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

@ -661,7 +661,7 @@ public:
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;
if (IsSceneryItemRestricted(tabSelectedScenery))

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

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

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

@ -174,7 +174,7 @@ public:
mapZ = GetBaseZ(mapCoords);
CoordsXYZD trackLoc = { mapCoords, mapZ, _currentTrackPieceDirection };
if (GameIsNotPaused() || gCheatsBuildInPauseMode)
if (GameIsNotPaused() || GetGameState().Cheats.BuildInPauseMode)
{
ClearProvisional();
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
// 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()
{
gCheatsSandboxMode = false;
gCheatsDisableClearanceChecks = false;
gCheatsDisableSupportLimits = false;
gCheatsShowAllOperatingModes = false;
gCheatsShowVehiclesFromOtherTrackTypes = false;
gCheatsDisableTrainLengthLimit = false;
gCheatsEnableChainLiftOnAllTrack = false;
gCheatsUnlockOperatingLimits = false;
gCheatsDisableBrakesFailure = false;
gCheatsDisableAllBreakdowns = false;
gCheatsBuildInPauseMode = false;
gCheatsIgnoreRideIntensity = false;
gCheatsDisableVandalism = false;
gCheatsDisableLittering = false;
gCheatsNeverendingMarketing = false;
gCheatsFreezeWeather = false;
gCheatsDisablePlantAging = false;
gCheatsAllowArbitraryRideTypeChanges = false;
gCheatsDisableRideValueAging = false;
gCheatsIgnoreResearchStatus = false;
gCheatsEnableAllDrawableTrackPieces = false;
gCheatsAllowTrackPlaceInvalidHeights = false;
gCheatsAllowRegularPathAsQueue = false;
gCheatsAllowSpecialColourSchemes = false;
gCheatsMakeAllDestructible = false;
gCheatsSelectedStaffSpeed = StaffSpeedCheat::None;
auto& gameState = GetGameState();
gameState.Cheats.SandboxMode = false;
gameState.Cheats.DisableClearanceChecks = false;
gameState.Cheats.DisableSupportLimits = false;
gameState.Cheats.ShowAllOperatingModes = false;
gameState.Cheats.ShowVehiclesFromOtherTrackTypes = false;
gameState.Cheats.DisableTrainLengthLimit = false;
gameState.Cheats.EnableChainLiftOnAllTrack = false;
gameState.Cheats.UnlockOperatingLimits = false;
gameState.Cheats.DisableBrakesFailure = false;
gameState.Cheats.DisableAllBreakdowns = false;
gameState.Cheats.BuildInPauseMode = false;
gameState.Cheats.IgnoreRideIntensity = false;
gameState.Cheats.DisableVandalism = false;
gameState.Cheats.DisableLittering = false;
gameState.Cheats.NeverendingMarketing = false;
gameState.Cheats.FreezeWeather = false;
gameState.Cheats.DisablePlantAging = false;
gameState.Cheats.AllowArbitraryRideTypeChanges = false;
gameState.Cheats.DisableRideValueAging = false;
gameState.Cheats.IgnoreResearchStatus = false;
gameState.Cheats.EnableAllDrawableTrackPieces = false;
gameState.Cheats.AllowTrackPlaceInvalidHeights = false;
gameState.Cheats.AllowRegularPathAsQueue = false;
gameState.Cheats.AllowSpecialColourSchemes = false;
gameState.Cheats.MakeAllDestructible = false;
gameState.Cheats.SelectedStaffSpeed = StaffSpeedCheat::None;
}
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)
{
uint16_t count = 0;
auto& gameState = GetGameState();
if (ds.IsSaving())
{
@ -111,32 +87,35 @@ void CheatsSerialise(DataSerialiser& ds)
uint64_t countOffset = stream.GetPosition();
ds << count;
CheatEntrySerialise(ds, CheatType::SandboxMode, gCheatsSandboxMode, count);
CheatEntrySerialise(ds, CheatType::DisableClearanceChecks, gCheatsDisableClearanceChecks, count);
CheatEntrySerialise(ds, CheatType::DisableSupportLimits, gCheatsDisableSupportLimits, count);
CheatEntrySerialise(ds, CheatType::ShowAllOperatingModes, gCheatsShowAllOperatingModes, count);
CheatEntrySerialise(ds, CheatType::ShowVehiclesFromOtherTrackTypes, gCheatsShowVehiclesFromOtherTrackTypes, count);
CheatEntrySerialise(ds, CheatType::FastLiftHill, gCheatsUnlockOperatingLimits, count);
CheatEntrySerialise(ds, CheatType::DisableBrakesFailure, gCheatsDisableBrakesFailure, count);
CheatEntrySerialise(ds, CheatType::DisableAllBreakdowns, gCheatsDisableAllBreakdowns, count);
CheatEntrySerialise(ds, CheatType::BuildInPauseMode, gCheatsBuildInPauseMode, count);
CheatEntrySerialise(ds, CheatType::IgnoreRideIntensity, gCheatsIgnoreRideIntensity, count);
CheatEntrySerialise(ds, CheatType::DisableVandalism, gCheatsDisableVandalism, count);
CheatEntrySerialise(ds, CheatType::DisableLittering, gCheatsDisableLittering, count);
CheatEntrySerialise(ds, CheatType::NeverEndingMarketing, gCheatsNeverendingMarketing, count);
CheatEntrySerialise(ds, CheatType::FreezeWeather, gCheatsFreezeWeather, count);
CheatEntrySerialise(ds, CheatType::DisableTrainLengthLimit, gCheatsDisableTrainLengthLimit, count);
CheatEntrySerialise(ds, CheatType::DisablePlantAging, gCheatsDisablePlantAging, count);
CheatEntrySerialise(ds, CheatType::EnableChainLiftOnAllTrack, gCheatsEnableChainLiftOnAllTrack, count);
CheatEntrySerialise(ds, CheatType::AllowArbitraryRideTypeChanges, gCheatsAllowArbitraryRideTypeChanges, count);
CheatEntrySerialise(ds, CheatType::DisableRideValueAging, gCheatsDisableRideValueAging, count);
CheatEntrySerialise(ds, CheatType::IgnoreResearchStatus, gCheatsIgnoreResearchStatus, count);
CheatEntrySerialise(ds, CheatType::EnableAllDrawableTrackPieces, gCheatsEnableAllDrawableTrackPieces, count);
CheatEntrySerialise(ds, CheatType::AllowTrackPlaceInvalidHeights, gCheatsAllowTrackPlaceInvalidHeights, count);
CheatEntrySerialise(ds, CheatType::AllowRegularPathAsQueue, gCheatsAllowRegularPathAsQueue, count);
CheatEntrySerialise(ds, CheatType::AllowSpecialColourSchemes, gCheatsAllowSpecialColourSchemes, count);
CheatEntrySerialise(ds, CheatType::MakeDestructible, gCheatsMakeAllDestructible, count);
CheatEntrySerialise(ds, CheatType::SetStaffSpeed, gCheatsSelectedStaffSpeed, count);
CheatEntrySerialise(ds, CheatType::SandboxMode, gameState.Cheats.SandboxMode, count);
CheatEntrySerialise(ds, CheatType::DisableClearanceChecks, gameState.Cheats.DisableClearanceChecks, count);
CheatEntrySerialise(ds, CheatType::DisableSupportLimits, gameState.Cheats.DisableSupportLimits, count);
CheatEntrySerialise(ds, CheatType::ShowAllOperatingModes, gameState.Cheats.ShowAllOperatingModes, count);
CheatEntrySerialise(
ds, CheatType::ShowVehiclesFromOtherTrackTypes, gameState.Cheats.ShowVehiclesFromOtherTrackTypes, count);
CheatEntrySerialise(ds, CheatType::FastLiftHill, gameState.Cheats.UnlockOperatingLimits, count);
CheatEntrySerialise(ds, CheatType::DisableBrakesFailure, gameState.Cheats.DisableBrakesFailure, count);
CheatEntrySerialise(ds, CheatType::DisableAllBreakdowns, gameState.Cheats.DisableAllBreakdowns, count);
CheatEntrySerialise(ds, CheatType::BuildInPauseMode, gameState.Cheats.BuildInPauseMode, count);
CheatEntrySerialise(ds, CheatType::IgnoreRideIntensity, gameState.Cheats.IgnoreRideIntensity, count);
CheatEntrySerialise(ds, CheatType::DisableVandalism, gameState.Cheats.DisableVandalism, count);
CheatEntrySerialise(ds, CheatType::DisableLittering, gameState.Cheats.DisableLittering, count);
CheatEntrySerialise(ds, CheatType::NeverEndingMarketing, gameState.Cheats.NeverendingMarketing, count);
CheatEntrySerialise(ds, CheatType::FreezeWeather, gameState.Cheats.FreezeWeather, count);
CheatEntrySerialise(ds, CheatType::DisableTrainLengthLimit, gameState.Cheats.DisableTrainLengthLimit, count);
CheatEntrySerialise(ds, CheatType::DisablePlantAging, gameState.Cheats.DisablePlantAging, count);
CheatEntrySerialise(ds, CheatType::EnableChainLiftOnAllTrack, gameState.Cheats.EnableChainLiftOnAllTrack, count);
CheatEntrySerialise(
ds, CheatType::AllowArbitraryRideTypeChanges, gameState.Cheats.AllowArbitraryRideTypeChanges, count);
CheatEntrySerialise(ds, CheatType::DisableRideValueAging, gameState.Cheats.DisableRideValueAging, count);
CheatEntrySerialise(ds, CheatType::IgnoreResearchStatus, gameState.Cheats.IgnoreResearchStatus, count);
CheatEntrySerialise(ds, CheatType::EnableAllDrawableTrackPieces, gameState.Cheats.EnableAllDrawableTrackPieces, count);
CheatEntrySerialise(
ds, CheatType::AllowTrackPlaceInvalidHeights, gameState.Cheats.AllowTrackPlaceInvalidHeights, 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.
uint64_t endOffset = stream.GetPosition();
@ -161,85 +140,85 @@ void CheatsSerialise(DataSerialiser& ds)
switch (static_cast<CheatType>(type))
{
case CheatType::SandboxMode:
ds << gCheatsSandboxMode;
ds << gameState.Cheats.SandboxMode;
break;
case CheatType::DisableClearanceChecks:
ds << gCheatsDisableClearanceChecks;
ds << gameState.Cheats.DisableClearanceChecks;
break;
case CheatType::DisableSupportLimits:
ds << gCheatsDisableSupportLimits;
ds << gameState.Cheats.DisableSupportLimits;
break;
case CheatType::ShowAllOperatingModes:
ds << gCheatsShowAllOperatingModes;
ds << gameState.Cheats.ShowAllOperatingModes;
break;
case CheatType::ShowVehiclesFromOtherTrackTypes:
ds << gCheatsShowVehiclesFromOtherTrackTypes;
ds << gameState.Cheats.ShowVehiclesFromOtherTrackTypes;
break;
case CheatType::FastLiftHill:
ds << gCheatsUnlockOperatingLimits;
ds << gameState.Cheats.UnlockOperatingLimits;
break;
case CheatType::DisableBrakesFailure:
ds << gCheatsDisableBrakesFailure;
ds << gameState.Cheats.DisableBrakesFailure;
break;
case CheatType::DisableAllBreakdowns:
ds << gCheatsDisableAllBreakdowns;
ds << gameState.Cheats.DisableAllBreakdowns;
break;
case CheatType::BuildInPauseMode:
ds << gCheatsBuildInPauseMode;
ds << gameState.Cheats.BuildInPauseMode;
break;
case CheatType::IgnoreRideIntensity:
ds << gCheatsIgnoreRideIntensity;
ds << gameState.Cheats.IgnoreRideIntensity;
break;
case CheatType::DisableVandalism:
ds << gCheatsDisableVandalism;
ds << gameState.Cheats.DisableVandalism;
break;
case CheatType::DisableLittering:
ds << gCheatsDisableLittering;
ds << gameState.Cheats.DisableLittering;
break;
case CheatType::NeverEndingMarketing:
ds << gCheatsNeverendingMarketing;
ds << gameState.Cheats.NeverendingMarketing;
break;
case CheatType::FreezeWeather:
ds << gCheatsFreezeWeather;
ds << gameState.Cheats.FreezeWeather;
break;
case CheatType::DisableTrainLengthLimit:
ds << gCheatsDisableTrainLengthLimit;
ds << gameState.Cheats.DisableTrainLengthLimit;
break;
case CheatType::DisablePlantAging:
ds << gCheatsDisablePlantAging;
ds << gameState.Cheats.DisablePlantAging;
break;
case CheatType::EnableChainLiftOnAllTrack:
ds << gCheatsEnableChainLiftOnAllTrack;
ds << gameState.Cheats.EnableChainLiftOnAllTrack;
break;
case CheatType::AllowArbitraryRideTypeChanges:
ds << gCheatsAllowArbitraryRideTypeChanges;
ds << gameState.Cheats.AllowArbitraryRideTypeChanges;
break;
case CheatType::DisableRideValueAging:
ds << gCheatsDisableRideValueAging;
ds << gameState.Cheats.DisableRideValueAging;
break;
case CheatType::IgnoreResearchStatus:
ds << gCheatsIgnoreResearchStatus;
ds << gameState.Cheats.IgnoreResearchStatus;
break;
case CheatType::EnableAllDrawableTrackPieces:
ds << gCheatsEnableAllDrawableTrackPieces;
ds << gameState.Cheats.EnableAllDrawableTrackPieces;
break;
case CheatType::AllowTrackPlaceInvalidHeights:
ds << gCheatsAllowTrackPlaceInvalidHeights;
ds << gameState.Cheats.AllowTrackPlaceInvalidHeights;
break;
case CheatType::NoCapOnQueueLengthDummy:
ds << dummyBool;
break;
case CheatType::AllowRegularPathAsQueue:
ds << gCheatsAllowRegularPathAsQueue;
ds << gameState.Cheats.AllowRegularPathAsQueue;
break;
case CheatType::AllowSpecialColourSchemes:
ds << gCheatsAllowSpecialColourSchemes;
ds << gameState.Cheats.AllowSpecialColourSchemes;
break;
case CheatType::MakeDestructible:
ds << gCheatsMakeAllDestructible;
ds << gameState.Cheats.MakeAllDestructible;
break;
case CheatType::SetStaffSpeed:
ds << gCheatsSelectedStaffSpeed;
ds << gameState.Cheats.SelectedStaffSpeed;
break;
default:
break;

55
src/openrct2/Cheats.h
View File

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

3
src/openrct2/GameState.h
View File

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

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

@ -239,5 +239,6 @@ void ClearAction::ResetClearLargeSceneryFlag()
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 "../Cheats.h"
#include "../GameState.h"
#include "../OpenRCT2.h"
#include "../core/MemoryStream.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);
}
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);
}

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

@ -10,6 +10,7 @@
#include "FootpathAdditionRemoveAction.h"
#include "../Cheats.h"
#include "../GameState.h"
#include "../OpenRCT2.h"
#include "../core/MemoryStream.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);
}
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);
}

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

@ -10,6 +10,7 @@
#include "FootpathLayoutPlaceAction.h"
#include "../Cheats.h"
#include "../GameState.h"
#include "../OpenRCT2.h"
#include "../core/MemoryStream.h"
#include "../interface/Window.h"
@ -23,6 +24,8 @@
#include "../world/Surface.h"
#include "../world/Wall.h"
using namespace OpenRCT2;
FootpathLayoutPlaceAction::FootpathLayoutPlaceAction(
const CoordsXYZ& loc, uint8_t slope, ObjectEntryIndex type, ObjectEntryIndex railingsType, uint8_t edges,
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);
}
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_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>();
gFootpathGroundFlags = clearanceData.GroundFlags;
if (!gCheatsDisableClearanceChecks && (clearanceData.GroundFlags & ELEMENT_IS_UNDERWATER))
if (!GetGameState().Cheats.DisableClearanceChecks && (clearanceData.GroundFlags & ELEMENT_IS_UNDERWATER))
{
return GameActions::Result(
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);
}
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);
}
@ -132,7 +132,7 @@ GameActions::Result FootpathPlaceAction::Execute() const
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
auto zLow = _loc.z;
@ -314,7 +314,7 @@ GameActions::Result FootpathPlaceAction::ElementInsertQuery(GameActions::Result
const auto clearanceData = canBuild.GetData<ConstructClearResult>();
gFootpathGroundFlags = clearanceData.GroundFlags;
if (!gCheatsDisableClearanceChecks && (clearanceData.GroundFlags & ELEMENT_IS_UNDERWATER))
if (!GetGameState().Cheats.DisableClearanceChecks && (clearanceData.GroundFlags & ELEMENT_IS_UNDERWATER))
{
return GameActions::Result(
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 "../Cheats.h"
#include "../GameState.h"
#include "../OpenRCT2.h"
#include "../core/MemoryStream.h"
#include "../interface/Window.h"
@ -21,6 +22,8 @@
#include "../world/Wall.h"
#include "BannerRemoveAction.h"
using namespace OpenRCT2;
FootpathRemoveAction::FootpathRemoveAction(const CoordsXYZ& 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);
}
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::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)
return true;
if (gCheatsBuildInPauseMode)
if (GetGameState().Cheats.BuildInPauseMode)
return true;
if (actionFlags & GameActions::Flags::AllowWhilePaused)
return true;

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

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

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

@ -11,6 +11,7 @@
#include "LandRaiseAction.h"
#include "../Context.h"
#include "../GameState.h"
#include "../OpenRCT2.h"
#include "../actions/LandSetHeightAction.h"
#include "../audio/audio.h"
@ -94,7 +95,7 @@ GameActions::Result LandRaiseAction::QueryExecute(bool isExecuting) const
if (surfaceElement == nullptr)
continue;
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !gCheatsSandboxMode)
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !OpenRCT2::GetGameState().Cheats.SandboxMode)
{
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);
}
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !gCheatsSandboxMode)
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !GetGameState().Cheats.SandboxMode)
{
if (!MapIsLocationInPark(_coords))
{
@ -76,7 +76,7 @@ GameActions::Result LandSetHeightAction::Query() const
}
money64 sceneryRemovalCost = 0;
if (!gCheatsDisableClearanceChecks)
if (!GetGameState().Cheats.DisableClearanceChecks)
{
if (gameState.ParkFlags & PARK_FLAGS_FORBID_TREE_REMOVAL)
{
@ -93,7 +93,7 @@ GameActions::Result LandSetHeightAction::Query() const
}
// Check for ride support limits
if (!gCheatsDisableSupportLimits)
if (!GetGameState().Cheats.DisableSupportLimits)
{
errorMessage = CheckRideSupports();
if (errorMessage != STR_NONE)
@ -124,7 +124,7 @@ GameActions::Result LandSetHeightAction::Query() const
return res;
}
if (!gCheatsDisableClearanceChecks)
if (!GetGameState().Cheats.DisableClearanceChecks)
{
uint8_t zCorner = _height;
if (_style & TILE_ELEMENT_SURFACE_RAISED_CORNERS_MASK)
@ -157,7 +157,7 @@ GameActions::Result LandSetHeightAction::Execute() const
auto surfaceHeight = TileElementHeight(_coords);
FootpathRemoveLitter({ _coords, surfaceHeight });
if (!gCheatsDisableClearanceChecks)
if (!GetGameState().Cheats.DisableClearanceChecks)
{
WallRemoveAt({ _coords, _height * 8 - 16, _height * 8 + 32 });
cost += GetSmallSceneryRemovalCost();

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

@ -10,6 +10,7 @@
#include "LandSetRightsAction.h"
#include "../Context.h"
#include "../GameState.h"
#include "../OpenRCT2.h"
#include "../actions/LandSetHeightAction.h"
#include "../audio/audio.h"
@ -82,7 +83,7 @@ GameActions::Result LandSetRightsAction::QueryExecute(bool isExecuting) const
res.Position = centre;
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);
}

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

@ -9,6 +9,7 @@
#include "LargeSceneryPlaceAction.h"
#include "../GameState.h"
#include "../OpenRCT2.h"
#include "../management/Finance.h"
#include "../object/LargeSceneryEntry.h"
@ -21,6 +22,8 @@
#include "../world/MapAnimation.h"
#include "../world/Surface.h"
using namespace OpenRCT2;
LargeSceneryPlaceAction::LargeSceneryPlaceAction(
const CoordsXYZD& loc, ObjectEntryIndex sceneryType, uint8_t primaryColour, uint8_t secondaryColour, uint8_t tertiaryColour)
: _loc(loc)
@ -81,7 +84,7 @@ GameActions::Result LargeSceneryPlaceAction::Query() const
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)
{
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>();
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))
{
@ -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);
}
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(
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;
auto* sceneryEntry = OpenRCT2::ObjectManager::GetObjectEntry<LargeSceneryEntry>(_sceneryType);
auto* sceneryEntry = ObjectManager::GetObjectEntry<LargeSceneryEntry>(_sceneryType);
if (sceneryEntry == nullptr)
{
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))
{
FootpathRemoveLitter({ curTile, zLow });
if (!gCheatsDisableClearanceChecks)
if (!GetGameState().Cheats.DisableClearanceChecks)
{
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;
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !gCheatsSandboxMode)
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !GetGameState().Cheats.SandboxMode)
{
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;
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !gCheatsSandboxMode)
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !GetGameState().Cheats.SandboxMode)
{
if (!MapIsLocationOwned({ currentTile.x, currentTile.y, currentTile.z }))
{

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

@ -9,6 +9,7 @@
#include "LargeScenerySetColourAction.h"
#include "../GameState.h"
#include "../OpenRCT2.h"
#include "../management/Finance.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 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))
{

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

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

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

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

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

@ -41,7 +41,7 @@ void ParkEntranceRemoveAction::Serialise(DataSerialiser& stream)
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);
}

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

@ -43,7 +43,7 @@ void PeepSpawnPlaceAction::Serialise(DataSerialiser& stream)
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);
}

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

@ -161,7 +161,7 @@ GameActions::Result RideCreateAction::Execute() const
ride->vehicle_change_timeout = 0;
ride->num_stations = 0;
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
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)
&& _modifyType == RIDE_MODIFY_DEMOLISH)
&& !gCheatsMakeAllDestructible)
&& !GetGameState().Cheats.MakeAllDestructible)
{
return GameActions::Result(
GameActions::Status::NoClearance, STR_CANT_DEMOLISH_RIDE,

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

@ -9,6 +9,7 @@
#include "RideEntranceExitPlaceAction.h"
#include "../GameState.h"
#include "../actions/RideEntranceExitRemoveAction.h"
#include "../management/Finance.h"
#include "../ride/Ride.h"
@ -16,6 +17,8 @@
#include "../world/ConstructionClearance.h"
#include "../world/MapAnimation.h"
using namespace OpenRCT2;
RideEntranceExitPlaceAction::RideEntranceExitPlaceAction(
const CoordsXY& loc, Direction direction, RideId rideIndex, StationIndex stationNum, bool isExit)
: _loc(loc)
@ -59,7 +62,7 @@ GameActions::Result RideEntranceExitPlaceAction::Query() const
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());
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);
}
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);
}
@ -167,7 +170,7 @@ GameActions::Result RideEntranceExitPlaceAction::Execute() const
auto z = station.GetBaseZ();
if (!(GetFlags() & GAME_COMMAND_FLAG_ALLOW_DURING_PAUSED) && !(GetFlags() & GAME_COMMAND_FLAG_GHOST)
&& !gCheatsDisableClearanceChecks)
&& !GetGameState().Cheats.DisableClearanceChecks)
{
FootpathRemoveLitter({ _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
: 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);
}

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

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

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

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

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

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

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

@ -74,7 +74,8 @@ GameActions::Result SmallSceneryRemoveAction::Query() const
res.Expenditure = ExpenditureType::Landscaping;
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
if (GetGameState().ParkFlags & PARK_FLAGS_FORBID_TREE_REMOVAL)

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

@ -10,6 +10,7 @@
#include "SmallScenerySetColourAction.h"
#include "../Cheats.h"
#include "../GameState.h"
#include "../OpenRCT2.h"
#include "../common.h"
#include "../core/MemoryStream.h"
@ -24,6 +25,8 @@
#include "../world/Surface.h"
#include "../world/TileElement.h"
using namespace OpenRCT2;
SmallScenerySetColourAction::SmallScenerySetColourAction(
const CoordsXYZ& loc, uint8_t quadrant, ObjectEntryIndex sceneryType, uint8_t primaryColour, uint8_t secondaryColour,
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);
}
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !gCheatsSandboxMode)
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !GetGameState().Cheats.SandboxMode)
{
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;
// Staff energy determines their walking speed
switch (gCheatsSelectedStaffSpeed)
switch (GetGameState().Cheats.SelectedStaffSpeed)
{
case StaffSpeedCheat::None:
newPeep->Energy = kCheatsStaffNormalSpeed;

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

@ -85,7 +85,7 @@ GameActions::Result SurfaceSetStyleAction::Query() const
res.Position.z = heightMid;
// 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))
{
return GameActions::Result(
@ -102,7 +102,7 @@ GameActions::Result SurfaceSetStyleAction::Query() const
if (!LocationValid(coords))
continue;
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !gCheatsSandboxMode)
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !GetGameState().Cheats.SandboxMode)
{
if (!MapIsLocationInPark(coords))
continue;
@ -170,7 +170,7 @@ GameActions::Result SurfaceSetStyleAction::Execute() const
if (!LocationValid(coords))
continue;
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !gCheatsSandboxMode)
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !GetGameState().Cheats.SandboxMode)
{
if (!MapIsLocationInPark(coords))
continue;

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

@ -10,6 +10,7 @@
#include "TrackDesignAction.h"
#include "../Context.h"
#include "../GameState.h"
#include "../management/Finance.h"
#include "../management/Research.h"
#include "../object/ObjectManager.h"
@ -22,6 +23,8 @@
#include "RideSetSettingAction.h"
#include "RideSetVehicleAction.h"
using namespace OpenRCT2;
TrackDesignAction::TrackDesignAction(const CoordsXYZD& location, const TrackDesign& td)
: _loc(location)
, _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);
}
auto& objManager = OpenRCT2::GetContext()->GetObjectManager();
auto& objManager = GetContext()->GetObjectManager();
auto entryIndex = objManager.GetLoadedObjectEntryIndex(_td.vehicle_object);
if (entryIndex == OBJECT_ENTRY_INDEX_NULL)
{
// 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
if (!RideEntryIsInvented(entryIndex) && !gCheatsIgnoreResearchStatus)
if (!RideEntryIsInvented(entryIndex) && !GetGameState().Cheats.IgnoreResearchStatus)
{
entryIndex = OBJECT_ENTRY_INDEX_NULL;
}
@ -133,13 +136,13 @@ GameActions::Result TrackDesignAction::Execute() const
res.Position.z = _loc.z;
res.Expenditure = ExpenditureType::RideConstruction;
auto& objManager = OpenRCT2::GetContext()->GetObjectManager();
auto& objManager = GetContext()->GetObjectManager();
auto entryIndex = objManager.GetLoadedObjectEntryIndex(_td.vehicle_object);
if (entryIndex != OBJECT_ENTRY_INDEX_NULL)
{
// 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.
if (!RideEntryIsInvented(entryIndex) && !gCheatsIgnoreResearchStatus)
if (!RideEntryIsInvented(entryIndex) && !GetGameState().Cheats.IgnoreResearchStatus)
{
entryIndex = OBJECT_ENTRY_INDEX_NULL;
}
@ -247,14 +250,14 @@ GameActions::Result TrackDesignAction::Execute() const
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].additional = _td.track_rail_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];
}

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

@ -9,6 +9,7 @@
#include "TrackPlaceAction.h"
#include "../GameState.h"
#include "../core/Numerics.hpp"
#include "../management/Finance.h"
#include "../ride/RideData.h"
@ -21,6 +22,7 @@
#include "../world/Surface.h"
#include "RideSetSettingAction.h"
using namespace OpenRCT2;
using namespace OpenRCT2::TrackMetaData;
TrackPlaceAction::TrackPlaceAction(
@ -89,7 +91,7 @@ GameActions::Result TrackPlaceAction::Query() const
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(
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 (GameIsPaused() && !gCheatsBuildInPauseMode)
if (GameIsPaused() && !GetGameState().Cheats.BuildInPauseMode)
{
return GameActions::Result(
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.
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);
if (ted.Flags & TRACK_ELEM_FLAG_IS_STEEP_UP)
@ -176,7 +179,7 @@ GameActions::Result TrackPlaceAction::Query() const
return GameActions::Result(
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(
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);
}
if (!gCheatsAllowTrackPlaceInvalidHeights)
if (!GetGameState().Cheats.AllowTrackPlaceInvalidHeights)
{
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(
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);
}
if (!gCheatsDisableSupportLimits)
if (!GetGameState().Cheats.DisableSupportLimits)
{
int32_t ride_height = clearanceZ - surfaceElement->GetBaseZ();
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);
if (rideTypeFlags & RIDE_TYPE_FLAG_TRACK_NO_WALLS)
@ -616,7 +619,7 @@ GameActions::Result TrackPlaceAction::Execute() const
uint8_t availableDirections = entranceDirections & 0x0F;
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;
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());
}
@ -689,7 +692,7 @@ GameActions::Result TrackPlaceAction::Execute() const
if (ride->mode == RideMode::PoweredLaunch)
{
if (ride->GetRideTypeDescriptor().SupportsRideMode(RideMode::PoweredLaunchBlockSectioned)
|| gCheatsShowAllOperatingModes)
|| GetGameState().Cheats.ShowAllOperatingModes)
newMode = RideMode::PoweredLaunchBlockSectioned;
else
newMode = RideMode::PoweredLaunch;

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

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

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

@ -9,6 +9,7 @@
#include "WallPlaceAction.h"
#include "../GameState.h"
#include "../OpenRCT2.h"
#include "../management/Finance.h"
#include "../object/LargeSceneryEntry.h"
@ -23,6 +24,7 @@
#include "../world/Surface.h"
#include "../world/Wall.h"
using namespace OpenRCT2;
using namespace OpenRCT2::TrackMetaData;
WallPlaceAction::WallPlaceAction(
@ -81,7 +83,8 @@ GameActions::Result WallPlaceAction::Query() const
}
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)
{
@ -138,14 +141,14 @@ GameActions::Result WallPlaceAction::Query() const
{
uint16_t waterHeight = surfaceElement->GetWaterHeight();
if (targetHeight < waterHeight && !gCheatsDisableClearanceChecks)
if (targetHeight < waterHeight && !GetGameState().Cheats.DisableClearanceChecks)
{
return GameActions::Result(
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(
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)
{
@ -248,7 +251,7 @@ GameActions::Result WallPlaceAction::Query() const
clearanceHeight += wallEntry->height;
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);
if (result.Error != GameActions::Status::Ok)
@ -307,7 +310,7 @@ GameActions::Result WallPlaceAction::Execute() const
}
auto targetLoc = CoordsXYZ(_loc, targetHeight);
auto* wallEntry = OpenRCT2::ObjectManager::GetObjectEntry<WallSceneryEntry>(_wallType);
auto* wallEntry = ObjectManager::GetObjectEntry<WallSceneryEntry>(_wallType);
if (wallEntry == nullptr)
{
@ -323,7 +326,7 @@ GameActions::Result WallPlaceAction::Execute() const
clearanceHeight += wallEntry->height;
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);
if (result.Error != GameActions::Status::Ok)

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

@ -10,6 +10,7 @@
#include "WallRemoveAction.h"
#include "../Cheats.h"
#include "../GameState.h"
#include "../OpenRCT2.h"
#include "../core/MemoryStream.h"
#include "../interface/Window.h"
@ -50,7 +51,8 @@ GameActions::Result WallRemoveAction::Query() const
}
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);
}

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

@ -9,6 +9,7 @@
#include "WallSetColourAction.h"
#include "../GameState.h"
#include "../OpenRCT2.h"
#include "../management/Finance.h"
#include "../object/WallSceneryEntry.h"
@ -19,6 +20,8 @@
#include "../world/Scenery.h"
#include "../world/Surface.h"
using namespace OpenRCT2;
WallSetColourAction::WallSetColourAction(
const CoordsXYZD& loc, int32_t primaryColour, int32_t secondaryColour, int32_t tertiaryColour)
: _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);
}
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);
}

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

@ -9,11 +9,14 @@
#include "WaterLowerAction.h"
#include "../GameState.h"
#include "../OpenRCT2.h"
#include "../audio/audio.h"
#include "../ride/RideConstruction.h"
#include "WaterSetHeightAction.h"
using namespace OpenRCT2;
WaterLowerAction::WaterLowerAction(MapRange range)
: _range(range)
{
@ -76,7 +79,7 @@ GameActions::Result WaterLowerAction::QueryExecute(bool isExecuting) const
if (surfaceElement == nullptr)
continue;
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !gCheatsSandboxMode)
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !GetGameState().Cheats.SandboxMode)
{
if (!MapIsLocationInPark(CoordsXY{ x, y }))
{
@ -119,7 +122,7 @@ GameActions::Result WaterLowerAction::QueryExecute(bool isExecuting) const
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
_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)
{
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !gCheatsSandboxMode)
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !GetGameState().Cheats.SandboxMode)
{
if (!MapIsLocationInPark(CoordsXY{ x, y }))
{

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

@ -9,6 +9,7 @@
#include "WaterRaiseAction.h"
#include "../GameState.h"
#include "../OpenRCT2.h"
#include "../audio/audio.h"
#include "../ride/RideConstruction.h"
@ -76,7 +77,7 @@ GameActions::Result WaterRaiseAction::QueryExecute(bool isExecuting) const
if (surfaceElement == nullptr)
continue;
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !gCheatsSandboxMode)
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !OpenRCT2::GetGameState().Cheats.SandboxMode)
{
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)
{
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !gCheatsSandboxMode)
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !OpenRCT2::GetGameState().Cheats.SandboxMode)
{
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.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)
{
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);
}
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !gCheatsSandboxMode)
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !GetGameState().Cheats.SandboxMode)
{
if (!MapIsLocationInPark(_coords))
{
@ -117,7 +117,7 @@ GameActions::Result WaterSetHeightAction::Execute() const
int32_t surfaceHeight = TileElementHeight(_coords);
FootpathRemoveLitter({ _coords, surfaceHeight });
if (!gCheatsDisableClearanceChecks)
if (!GetGameState().Cheats.DisableClearanceChecks)
WallRemoveAtZ({ _coords, surfaceHeight });
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.
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);
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!
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
// 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;
}
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)
|| ride.max_lateral_g > FIXED_2DP(4, 00))
@ -2854,7 +2854,7 @@ static bool PeepShouldGoOnRideAgain(Guest* peep, const Ride& ride)
return false;
if (!RideHasRatings(ride))
return false;
if (ride.intensity > RIDE_RATING(10, 00) && !gCheatsIgnoreRideIntensity)
if (ride.intensity > RIDE_RATING(10, 00) && !GetGameState().Cheats.IgnoreRideIntensity)
return false;
if (peep->Happiness < 180)
return false;
@ -2899,7 +2899,7 @@ static bool PeepReallyLikedRide(Guest* peep, const Ride& ride)
return false;
if (!RideHasRatings(ride))
return false;
if (ride.intensity > RIDE_RATING(10, 00) && !gCheatsIgnoreRideIntensity)
if (ride.intensity > RIDE_RATING(10, 00) && !GetGameState().Cheats.IgnoreRideIntensity)
return false;
return true;
}
@ -3018,7 +3018,7 @@ static PeepThoughtType PeepAssessSurroundings(int16_t centre_x, int16_t centre_y
if (nearby_music == 1 && num_rubbish < 20)
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
return PeepThoughtType::VeryClean;
@ -6188,7 +6188,7 @@ static PathElement* FindBreakableElement(const CoordsXYZ& loc)
*/
static void PeepUpdateWalkingBreakScenery(Guest* peep)
{
if (gCheatsDisableVandalism)
if (GetGameState().Cheats.DisableVandalism)
return;
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)
{
if (gCheatsDisableLittering)
if (GetGameState().Cheats.DisableLittering)
return;
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
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);
if (res == kMoney64Undefined)
{
if (!gCheatsAllowArbitraryRideTypeChanges)
if (!GetGameState().Cheats.AllowArbitraryRideTypeChanges)
{
console.WriteFormatLine(
"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")
{
console.WriteFormatLine("cheat_sandbox_mode %d", gCheatsSandboxMode);
console.WriteFormatLine("cheat_sandbox_mode %d", GetGameState().Cheats.SandboxMode);
}
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")
{
console.WriteFormatLine("cheat_disable_support_limits %d", gCheatsDisableSupportLimits);
console.WriteFormatLine("cheat_disable_support_limits %d", GetGameState().Cheats.DisableSupportLimits);
}
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]))
{
if (gCheatsSandboxMode != (int_val[0] != 0))
if (GetGameState().Cheats.SandboxMode != (int_val[0] != 0))
{
auto cheatSetAction = CheatSetAction(CheatType::SandboxMode, int_val[0] != 0);
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]))
{
if (gCheatsDisableClearanceChecks != (int_val[0] != 0))
if (GetGameState().Cheats.DisableClearanceChecks != (int_val[0] != 0))
{
auto cheatSetAction = CheatSetAction(CheatType::DisableClearanceChecks, int_val[0] != 0);
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]))
{
if (gCheatsDisableSupportLimits != (int_val[0] != 0))
if (GetGameState().Cheats.DisableSupportLimits != (int_val[0] != 0))
{
auto cheatSetAction = CheatSetAction(CheatType::DisableSupportLimits, int_val[0] != 0);
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 "../Game.h"
#include "../GameState.h"
#include "../config/Config.h"
#include "../entity/Guest.h"
#include "../interface/Window.h"
@ -24,6 +25,8 @@
#include "Finance.h"
#include "NewsItem.h"
using namespace OpenRCT2;
const money64 AdvertisingCampaignPricePerWeek[] = {
50.00_GBP, // PARK_ENTRY_FREE
50.00_GBP, // RIDE_FREE
@ -100,7 +103,7 @@ void MarketingUpdate()
{
PROFILED_FUNCTION();
if (gCheatsNeverendingMarketing)
if (GetGameState().Cheats.NeverendingMarketing)
return;
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;
}
if (gCheatsIgnoreResearchStatus)
if (GetGameState().Cheats.IgnoreResearchStatus)
{
return true;
}

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

@ -10,6 +10,7 @@
#include "VirtualFloor.h"
#include "../Cheats.h"
#include "../GameState.h"
#include "../Input.h"
#include "../config/Config.h"
#include "../interface/Viewport.h"
@ -244,7 +245,7 @@ static void VirtualFloorGetTileProperties(
*tileOwned = MapIsLocationOwned({ loc, height });
if (gCheatsSandboxMode)
if (GetGameState().Cheats.SandboxMode)
*tileOwned = true;
// 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 <iterator>
using namespace OpenRCT2;
// Needed to make the sign appear above footpaths.
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);
// 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)
{
const CoordsXY& pos = session.MapPosition;

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

@ -1434,7 +1434,7 @@ static void RideBreakdownUpdate(Ride& ride)
// continues.
if ((ride.reliability == 0
|| static_cast<int32_t>(ScenarioRand() & 0x2FFFFF) <= 1 + RIDE_INITIAL_RELIABILITY - ride.reliability)
&& !gCheatsDisableAllBreakdowns)
&& !GetGameState().Cheats.DisableAllBreakdowns)
{
int32_t breakdownReason = RideGetNewBreakdownProblem(ride);
if (breakdownReason != -1)
@ -1493,7 +1493,7 @@ static int32_t RideGetNewBreakdownProblem(const Ride& ride)
return -1;
// If brakes failure is disabled, also take it out of the equation (see above comment why)
if (gCheatsDisableBrakesFailure)
if (GetGameState().Cheats.DisableBrakesFailure)
return -1;
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);
maxCarsPerTrain = std::max(maxCarsPerTrain, static_cast<int32_t>(rideEntry->min_cars_in_train));
if (!gCheatsDisableTrainLengthLimit)
if (!GetGameState().Cheats.DisableTrainLengthLimit)
{
newCarsPerTrain = std::min(maxCarsPerTrain, newCarsPerTrain);
}
@ -5166,7 +5166,7 @@ void Ride::UpdateMaxVehicles()
maxNumTrains = rideEntry->cars_per_flat_ride;
}
if (gCheatsDisableTrainLengthLimit)
if (GetGameState().Cheats.DisableTrainLengthLimit)
{
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
if (!RideEntryIsInvented(rideEntryIndex) && !gCheatsIgnoreResearchStatus)
if (!RideEntryIsInvented(rideEntryIndex) && !GetGameState().Cheats.IgnoreResearchStatus)
{
continue;
}
@ -5741,7 +5741,7 @@ void Ride::FormatNameTo(Formatter& ft) const
uint64_t Ride::GetAvailableModes() const
{
if (gCheatsShowAllOperatingModes)
if (GetGameState().Cheats.ShowAllOperatingModes)
return AllRideModesAvailable;
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);
if (rideEntry->flags & RIDE_ENTRY_FLAG_NO_INVERSIONS)

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

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

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

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

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

@ -11,6 +11,7 @@
#include "../Cheats.h"
#include "../Game.h"
#include "../GameState.h"
#include "../audio/audio.h"
#include "../config/Config.h"
#include "../interface/Viewport.h"
@ -34,6 +35,7 @@
#include "TrackData.h"
#include "TrackDesign.h"
using namespace OpenRCT2;
using namespace OpenRCT2::TrackMetaData;
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->num_stations >= OpenRCT2::Limits::MaxStationsPerRide)
if (ride->num_stations >= Limits::MaxStationsPerRide)
{
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,
// 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.
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 };
}
@ -327,8 +329,7 @@ ResultWithMessage TrackRemoveStationElement(const CoordsXYZD& loc, RideId rideIn
if (!(flags & GAME_COMMAND_FLAG_APPLY))
{
if ((removeLoc != stationBackLoc) && (removeLoc != stationFrontLoc)
&& ride->num_stations >= OpenRCT2::Limits::MaxStationsPerRide)
if ((removeLoc != stationBackLoc) && (removeLoc != stationFrontLoc) && ride->num_stations >= Limits::MaxStationsPerRide)
{
return { false, STR_NO_MORE_STATIONS_ALLOWED_ON_THIS_RIDE };
}
@ -943,7 +944,7 @@ void TrackElement::SetBrakeClosed(bool isClosed)
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)

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

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

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

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

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

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

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

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

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

@ -10,6 +10,7 @@
#include "../Cheats.h"
#include "../Context.h"
#include "../Game.h"
#include "../GameState.h"
#include "../Identifiers.h"
#include "../OpenRCT2.h"
#include "../actions/FootpathPlaceAction.h"
@ -825,7 +826,7 @@ static void Loc6A6D7E(
FootpathNeighbourList* neighbourList)
{
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)
{
@ -2353,7 +2354,7 @@ void FootpathRemoveEdgesAt(const CoordsXY& footpathPos, TileElement* tileElement
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++)
{
auto pathEntry = GetPathSurfaceEntry(i);
@ -2377,7 +2378,7 @@ static bool FootpathIsSurfaceEntryOkay(ObjectEntryIndex index, bool queue)
auto pathEntry = GetPathSurfaceEntry(index);
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))
{
return false;
@ -2405,7 +2406,7 @@ static ObjectEntryIndex FootpathGetDefaultRailings()
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 footpathObj = static_cast<FootpathObject*>(objManager.GetLoadedObject(ObjectType::Paths, index));
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)
return true;
if (gCheatsSandboxMode)
if (GetGameState().Cheats.SandboxMode)
return true;
if (MapIsLocationOwned(loc))
return true;
@ -963,7 +963,7 @@ uint8_t MapGetLowestLandHeight(const MapRange& range)
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 }))
{
@ -992,7 +992,7 @@ uint8_t MapGetHighestLandHeight(const MapRange& range)
auto* surfaceElement = MapGetSurfaceElementAt(CoordsXY{ xi, yi });
if (surfaceElement != nullptr)
{
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !gCheatsSandboxMode)
if (!(gScreenFlags & SCREEN_FLAGS_SCENARIO_EDITOR) && !GetGameState().Cheats.SandboxMode)
{
if (!MapIsLocationInPark(CoordsXY{ xi, yi }))
{
@ -1362,8 +1362,8 @@ void MapRemoveOutOfRangeElements()
// NOTE: This is only a workaround for non-networked games.
// Map resize has to become its own Game Action to properly solve this issue.
//
bool buildState = gCheatsBuildInPauseMode;
gCheatsBuildInPauseMode = true;
bool buildState = GetGameState().Cheats.BuildInPauseMode;
GetGameState().Cheats.BuildInPauseMode = true;
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
gCheatsBuildInPauseMode = buildState;
GetGameState().Cheats.BuildInPauseMode = buildState;
}
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;
}
if (gCheatsDisablePlantAging && sceneryEntry->HasFlag(SMALL_SCENERY_FLAG_CAN_BE_WATERED))
if (OpenRCT2::GetGameState().Cheats.DisablePlantAging && sceneryEntry->HasFlag(SMALL_SCENERY_FLAG_CAN_BE_WATERED))
{
return;
}
@ -315,7 +315,7 @@ bool IsSceneryAvailableToBuild(const ScenerySelection& item)
return true;
}
if (!gCheatsIgnoreResearchStatus)
if (!OpenRCT2::GetGameState().Cheats.IgnoreResearchStatus)
{
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))
{

4
test/tests/PlayTests.cpp
View File

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