mirrors/OpenRCT2
1
0
Fork 0
mirror of https://github.com/OpenRCT2/OpenRCT2 synced 2025-12-22 23:33:04 +01:00
Code Issues Releases Wiki Activity

clang-format root

Browse Source
This commit is contained in:
clang-format
2018-06-22 23:25:16 +02:00
committed by Hielke Morsink
parent 9c022606f1
commit c57bbca827
36 changed files with 2278 additions and 1895 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
src/openrct2-cli/Cli.cpp
View File

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

37
src/openrct2-dll/openrct2-dll.cpp
View File

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

8
src/openrct2-win/openrct2-win.cpp
View File

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

677
src/openrct2/Cheats.cpp
View File

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

12
src/openrct2/Cheats.h
View File

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

318
src/openrct2/CmdlineSprite.cpp
View File

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

2
src/openrct2/CmdlineSprite.h
View File

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

436
src/openrct2/Context.cpp
View File

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

79
src/openrct2/Context.h
View File

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

17
src/openrct2/Date.cpp
View File

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

6
src/openrct2/Date.h
View File

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

42
src/openrct2/Diagnostic.cpp
View File

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

66
src/openrct2/Diagnostic.h
View File

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

591
src/openrct2/Editor.cpp
View File

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

21
src/openrct2/Editor.h
View File

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

280
src/openrct2/EditorObjectSelectionSession.cpp
View File

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

12
src/openrct2/EditorObjectSelectionSession.h
View File

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

57
src/openrct2/FileClassifier.cpp
View File

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

6
src/openrct2/FileClassifier.h
View File

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

512
src/openrct2/Game.cpp
View File

File diff suppressed because it is too large Load Diff

75
src/openrct2/Game.h
View File

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

31
src/openrct2/GameState.cpp
View File

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

17
src/openrct2/GameState.h
View File

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

10
src/openrct2/Input.cpp
View File

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

17
src/openrct2/Input.h
View File

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

372
src/openrct2/Intro.cpp
View File

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

9
src/openrct2/Intro.h
View File

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

5
src/openrct2/OpenRCT2.h
View File

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

20
src/openrct2/ParkImporter.cpp
View File

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

27
src/openrct2/ParkImporter.h
View File

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

80
src/openrct2/PlatformEnvironment.cpp
View File

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

73
src/openrct2/PlatformEnvironment.h
View File

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

16
src/openrct2/Version.cpp
View File

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

46
src/openrct2/Version.h
View File

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

151
src/openrct2/common.h
View File

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

38
src/openrct2/sprites.h
View File

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