mirrors/OpenRCT2
1
0
Fork 0
mirror of https://github.com/OpenRCT2/OpenRCT2 synced 2025-12-23 15:52:55 +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

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

@@ -9,7 +9,6 @@
#include <openrct2/Context.h>
#include <openrct2/OpenRCT2.h>
#include <openrct2/platform/platform.h>
using namespace OpenRCT2;

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

@@ -13,18 +13,17 @@
#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;

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

@@ -12,7 +12,9 @@
#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);

539
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"
@@ -60,8 +61,10 @@ static void cheat_set_grass_length(int32_t length)
int32_t x, y;
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,7 +122,8 @@ 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);
@@ -126,7 +133,8 @@ static void cheat_remove_litter()
rct_scenery_entry* sceneryEntry;
tile_element_iterator_begin(&it);
do {
do
{
if (it.element->GetType() != TILE_ELEMENT_TYPE_PATH)
continue;
@@ -150,11 +158,13 @@ static void cheat_fix_rides()
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();
}
@@ -195,7 +205,8 @@ static void cheat_reset_crash_status()
int32_t i;
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;
@@ -210,7 +221,8 @@ static void cheat_10_minute_inspections()
int32_t i;
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
@@ -276,8 +290,10 @@ static void cheat_set_guest_parameter(int32_t parameter, int32_t value)
int32_t spriteIndex;
rct_peep* peep;
FOR_ALL_GUESTS(spriteIndex, peep) {
switch(parameter) {
FOR_ALL_GUESTS (spriteIndex, peep)
{
switch (parameter)
{
case GUEST_PARAMETER_HAPPINESS:
peep->happiness = value;
peep->happiness_target = value;
@@ -314,7 +330,6 @@ static void cheat_set_guest_parameter(int32_t parameter, int32_t value)
}
peep->UpdateSpriteType();
}
}
static void cheat_give_all_guests(int32_t object)
@@ -322,7 +337,8 @@ static void cheat_give_all_guests(int32_t object)
int32_t spriteIndex;
rct_peep* peep;
FOR_ALL_GUESTS(spriteIndex, peep) {
FOR_ALL_GUESTS (spriteIndex, peep)
{
switch (object)
{
case OBJECT_MONEY:
@@ -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();
}
}
@@ -410,8 +428,10 @@ static void cheat_explode_guests()
int32_t sprite_index;
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;
}
}
@@ -422,7 +442,8 @@ static void cheat_set_staff_speed(uint8_t value)
uint16_t spriteIndex;
rct_peep* peep;
FOR_ALL_STAFF(spriteIndex, peep) {
FOR_ALL_STAFF (spriteIndex, peep)
{
peep->energy = value;
peep->energy_target = value;
}
@@ -433,8 +454,10 @@ 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) {
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.
@@ -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,10 +479,12 @@ static void cheat_own_all_land()
}
// Completely unown peep spawn points
for (const auto &spawn : gPeepSpawns) {
for (const auto& spawn : gPeepSpawns)
{
int32_t x = spawn.x;
int32_t y = spawn.y;
if (x != PEEP_SPAWN_UNDEFINED) {
if (x != PEEP_SPAWN_UNDEFINED)
{
rct_tile_element* surfaceElement = map_get_surface_element_at({ x, y });
surfaceElement->properties.surface.ownership = OWNERSHIP_UNOWNED;
update_park_fences_around_tile({ x, y });
@@ -486,55 +512,158 @@ void game_command_cheat(
{
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;
}
if (network_get_mode() == NETWORK_MODE_NONE) {
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)
{
config_save_default();
}
window_invalidate_by_class(WC_CHEATS);
@@ -567,120 +696,170 @@ void cheats_reset()
}
// 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) {
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 "";

10
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,7 +99,8 @@ enum {
GUEST_PARAMETER_PREFERRED_RIDE_INTENSITY
};
enum {
enum
{
OBJECT_MONEY,
OBJECT_PARK_MAP,
OBJECT_BALLOON,

216
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;
};
@@ -93,27 +98,32 @@ static bool sprite_file_open(const utf8 *path)
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) {
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) {
if (fread(spriteFileData, spriteFileHeader.total_size, 1, file) != 1)
{
free(spriteFileData);
free(openElements);
fclose(file);
@@ -122,7 +132,8 @@ 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++) {
for (uint32_t i = 0; i < spriteFileHeader.num_entries; i++)
{
rct_g1_element_32bit* inElement = &openElements[i];
rct_g1_element* outElement = &spriteFileEntries[i];
@@ -148,20 +159,24 @@ static bool sprite_file_save(const char *path)
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) {
if (saveElements == nullptr)
{
fclose(file);
return false;
}
for (uint32_t i = 0; i < spriteFileHeader.num_entries; i++) {
for (uint32_t i = 0; i < spriteFileHeader.num_entries; i++)
{
rct_g1_element* inElement = &spriteFileEntries[i];
rct_g1_element_32bit* outElement = &saveElements[i];
@@ -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;
}
@@ -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;
@@ -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
{
@@ -286,14 +332,19 @@ int32_t cmdline_for_sprite(const char **argv, int32_t argc)
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) {
}
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,16 +354,20 @@ int32_t cmdline_for_sprite(const char **argv, int32_t argc)
sprite_file_close();
return 1;
} else {
}
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;
@@ -328,8 +383,11 @@ 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;
}
@@ -338,17 +396,20 @@ int32_t cmdline_for_sprite(const char **argv, int32_t argc)
int32_t spriteIndex = atoi(argv[2]);
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,8 +417,11 @@ 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;
}
@@ -365,7 +429,8 @@ int32_t cmdline_for_sprite(const char **argv, int32_t argc)
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
@@ -420,9 +488,11 @@ 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;
}
@@ -435,13 +505,15 @@ 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];
int16_t x_offset = 0;
@@ -470,10 +542,12 @@ int32_t cmdline_for_sprite(const char **argv, int32_t argc)
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;
}
@@ -488,15 +562,19 @@ int32_t cmdline_for_sprite(const char **argv, int32_t argc)
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;
}
@@ -510,7 +588,12 @@ int32_t cmdline_for_sprite(const char **argv, int32_t argc)
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;
}
@@ -579,10 +662,16 @@ int32_t cmdline_for_sprite(const char **argv, int32_t argc)
uint8_t* buffer;
int bufferLength;
if (!sprite_file_import(imagePath,
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))
keep_palette,
forceBmp,
&spriteElement,
&buffer,
&bufferLength,
gSpriteMode))
{
fprintf(stderr, "Could not import image file: %s\nCanceling\n", imagePath);
json_decref(sprite_list);
@@ -600,7 +689,8 @@ 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);
@@ -608,7 +698,8 @@ int32_t cmdline_for_sprite(const char **argv, int32_t argc)
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;
}

166
src/openrct2/Context.cpp
View File

@@ -15,9 +15,20 @@
#ifdef __EMSCRIPTEN__
#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;
@@ -115,7 +112,8 @@ namespace OpenRCT2
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:
@@ -129,10 +127,10 @@ namespace OpenRCT2
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;
}
@@ -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)
@@ -528,8 +480,7 @@ namespace OpenRCT2
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());
@@ -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,7 +649,8 @@ namespace OpenRCT2
}
}
switch (gOpenRCT2StartupAction) {
switch (gOpenRCT2StartupAction)
{
case STARTUP_ACTION_INTRO:
gIntroState = INTRO_STATE_PUBLISHER_BEGIN;
title_load();
@@ -808,10 +762,14 @@ 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;
}
@@ -828,14 +786,16 @@ namespace OpenRCT2
do
{
RunFrame();
}
while (!_finished);
} while (!_finished);
#else
emscripten_set_main_loop_arg([](void * vctx) ->
{
emscripten_set_main_loop_arg(
[](void* vctx) -> {
auto ctx = reinterpret_cast<Context*>(vctx);
ctx->RunFrame();
}, this, 0, 1);
},
this,
0,
1);
#endif // __EMSCRIPTEN__
log_verbose("finish openrct2 loop");
}
@@ -1050,7 +1010,7 @@ namespace OpenRCT2
{
return Context::Instance;
}
}
} // namespace OpenRCT2
void context_init()
{

3
src/openrct2/Context.h
View File

@@ -111,7 +111,8 @@ namespace OpenRCT2
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 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;

9
src/openrct2/Date.cpp
View File

@@ -7,10 +7,11 @@
* 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;
@@ -20,8 +21,8 @@ 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)
{
}

2
src/openrct2/Date.h
View File

@@ -43,4 +43,4 @@ namespace OpenRCT2
static int32_t GetDaysInMonth(int32_t month);
};
}
} // namespace OpenRCT2

26
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>
@@ -21,7 +23,8 @@ bool _log_levels[DIAGNOSTIC_LEVEL_COUNT] = { true, true, true, false, true };
static FILE* diagnostic_get_stream(DIAGNOSTIC_LEVEL level)
{
switch (level) {
switch (level)
{
case DIAGNOSTIC_LEVEL_VERBOSE:
case DIAGNOSTIC_LEVEL_INFORMATION:
return stdout;
@@ -32,7 +35,8 @@ static FILE * diagnostic_get_stream(DIAGNOSTIC_LEVEL level)
#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, ...)
{
@@ -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,13 +68,7 @@ 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, ...)
{
@@ -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])

12
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,
@@ -71,12 +72,15 @@ enum DIAGNOSTIC_LEVEL {
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_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__)

35
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;
@@ -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);
}
@@ -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)
{
@@ -787,15 +780,15 @@ namespace Editor
}
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);
}

3
src/openrct2/Editor.h
View File

@@ -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

136
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;
@@ -118,11 +119,13 @@ void setup_in_use_selection_flags()
tile_element_iterator iter;
tile_element_iterator_begin(&iter);
do {
do
{
uint16_t type;
rct_banner* banner;
switch (iter.element->GetType()) {
switch (iter.element->GetType())
{
default:
case TILE_ELEMENT_TYPE_SURFACE:
case TILE_ELEMENT_TYPE_TRACK:
@@ -133,7 +136,8 @@ void setup_in_use_selection_flags()
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)) {
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);
}
@@ -175,9 +179,11 @@ void setup_in_use_selection_flags()
}
} 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);
}
@@ -185,19 +191,19 @@ void setup_in_use_selection_flags()
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++) {
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++) {
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();
}
}
@@ -304,8 +316,10 @@ void unload_unselected_objects()
size_t numObjectsToUnload = 0;
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)) {
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);
@@ -357,9 +371,11 @@ void reset_selected_object_count_and_size()
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++) {
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();
}
}
@@ -385,7 +403,8 @@ int32_t window_editor_object_selection_select_object(uint8_t bh, int32_t flags,
{
int32_t numObjects = (int32_t)object_repository_get_items_count();
const ObjectRepositoryItem* item = object_repository_find_object_by_entry(entry);
if (item == nullptr) {
if (item == nullptr)
{
set_object_selection_error(bh, STR_OBJECT_SELECTION_ERR_OBJECT_DATA_NOT_FOUND);
return 0;
}
@@ -393,28 +412,35 @@ int32_t window_editor_object_selection_select_object(uint8_t bh, int32_t flags,
// 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) {
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)) {
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,7 +489,8 @@ 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);
@@ -463,7 +498,8 @@ int32_t window_editor_object_selection_select_object(uint8_t bh, int32_t flags,
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;
}
@@ -480,9 +516,11 @@ 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();
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;
}
}
@@ -500,12 +538,14 @@ int32_t editor_remove_unused_objects()
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];
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;
}

4
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];
@@ -29,4 +30,3 @@ int32_t window_editor_object_selection_select_object(uint8_t bh, int32_t flags,
* @return The number of removed objects.
*/
int32_t editor_remove_unused_objects();

29
src/openrct2/FileClassifier.cpp
View File

@@ -7,12 +7,12 @@
* 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"
@@ -139,7 +139,8 @@ static bool TryClassifyAsTD4_TD6(IStream * stream, ClassifiedFileInfo * result)
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)
{
@@ -164,13 +165,19 @@ static bool TryClassifyAsTD4_TD6(IStream * stream, ClassifiedFileInfo * result)
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;
}

180
src/openrct2/Game.cpp
View File

@@ -7,18 +7,20 @@
* OpenRCT2 is licensed under the GNU General Public License version 3.
*****************************************************************************/
#include <memory>
#include "audio/audio.h"
#include "Game.h"
#include "Cheats.h"
#include "config/Config.h"
#include "Context.h"
#include "Editor.h"
#include "FileClassifier.h"
#include "Input.h"
#include "OpenRCT2.h"
#include "ParkImporter.h"
#include "audio/audio.h"
#include "config/Config.h"
#include "core/FileScanner.h"
#include "core/Math.hpp"
#include "core/Util.hpp"
#include "Editor.h"
#include "FileClassifier.h"
#include "Game.h"
#include "Input.h"
#include "interface/Screenshot.h"
#include "interface/Viewport.h"
#include "interface/Window.h"
@@ -29,8 +31,7 @@
#include "management/Research.h"
#include "network/network.h"
#include "object/Object.h"
#include "OpenRCT2.h"
#include "ParkImporter.h"
#include "object/ObjectList.h"
#include "peep/Peep.h"
#include "peep/Staff.h"
#include "platform/platform.h"
@@ -59,7 +60,8 @@
#include "world/Sprite.h"
#include "world/Surface.h"
#include "world/Water.h"
#include "object/ObjectList.h"
#include <memory>
#define NUMBER_OF_AUTOSAVES_TO_KEEP 9
@@ -363,7 +365,8 @@ int32_t game_do_command(int32_t eax, int32_t ebx, int32_t ecx, int32_t edx, int3
* @param ebx flags
* @param esi command
*/
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)
{
int32_t cost, flags;
int32_t original_ebx, original_edx, original_esi, original_edi, original_ebp;
@@ -392,12 +395,10 @@ int32_t game_do_command_p(uint32_t command, int32_t * eax, int32_t * ebx, int32_
gGameCommandNestLevel++;
// Remove ghost scenery so it doesn't interfere with incoming network command
if ((flags & GAME_COMMAND_FLAG_NETWORKED) && !(flags & GAME_COMMAND_FLAG_GHOST) &&
(command == GAME_COMMAND_PLACE_WALL ||
command == GAME_COMMAND_PLACE_SCENERY ||
command == GAME_COMMAND_PLACE_LARGE_SCENERY ||
command == GAME_COMMAND_PLACE_BANNER ||
command == GAME_COMMAND_PLACE_PATH))
if ((flags & GAME_COMMAND_FLAG_NETWORKED) && !(flags & GAME_COMMAND_FLAG_GHOST)
&& (command == GAME_COMMAND_PLACE_WALL || command == GAME_COMMAND_PLACE_SCENERY
|| command == GAME_COMMAND_PLACE_LARGE_SCENERY || command == GAME_COMMAND_PLACE_BANNER
|| command == GAME_COMMAND_PLACE_PATH))
{
scenery_remove_ghost_tool_placement();
}
@@ -408,8 +409,10 @@ int32_t game_do_command_p(uint32_t command, int32_t * eax, int32_t * ebx, int32_
}
// Log certain commands if we are in multiplayer and logging is enabled
bool serverLog = (network_get_mode() == NETWORK_MODE_SERVER) && gGameCommandNestLevel == 1 && gConfigNetwork.log_server_actions;
bool clientLog = (network_get_mode() == NETWORK_MODE_CLIENT) && (flags & GAME_COMMAND_FLAG_NETWORKED) && gGameCommandNestLevel == 1 && gConfigNetwork.log_server_actions;
bool serverLog
= (network_get_mode() == NETWORK_MODE_SERVER) && gGameCommandNestLevel == 1 && gConfigNetwork.log_server_actions;
bool clientLog = (network_get_mode() == NETWORK_MODE_CLIENT) && (flags & GAME_COMMAND_FLAG_NETWORKED)
&& gGameCommandNestLevel == 1 && gConfigNetwork.log_server_actions;
if (serverLog || clientLog)
{
game_log_multiplayer_command(command, eax, ebx, ecx, edx, edi, ebp);
@@ -443,19 +446,19 @@ int32_t game_do_command_p(uint32_t command, int32_t * eax, int32_t * ebx, int32_
return cost;
}
if (network_get_mode() != NETWORK_MODE_NONE &&
!(flags & GAME_COMMAND_FLAG_NETWORKED) &&
!(flags & GAME_COMMAND_FLAG_GHOST) &&
!(flags & GAME_COMMAND_FLAG_5) &&
gGameCommandNestLevel == 1) /* Send only top-level commands */
if (network_get_mode() != NETWORK_MODE_NONE && !(flags & GAME_COMMAND_FLAG_NETWORKED)
&& !(flags & GAME_COMMAND_FLAG_GHOST) && !(flags & GAME_COMMAND_FLAG_5)
&& gGameCommandNestLevel == 1) /* Send only top-level commands */
{
// Disable these commands over the network
if (command != GAME_COMMAND_LOAD_OR_QUIT)
{
network_send_gamecmd(*eax, *ebx, *ecx, *edx, *esi, *edi, *ebp, game_command_callback_get_index(game_command_callback));
network_send_gamecmd(
*eax, *ebx, *ecx, *edx, *esi, *edi, *ebp, game_command_callback_get_index(game_command_callback));
if (network_get_mode() == NETWORK_MODE_CLIENT)
{
// Client sent the command to the server, do not run it locally, just return. It will run when server sends it.
// Client sent the command to the server, do not run it locally, just return. It will run when server
// sends it.
game_command_callback = nullptr;
// Decrement nest count
gGameCommandNestLevel--;
@@ -502,7 +505,8 @@ int32_t game_do_command_p(uint32_t command, int32_t * eax, int32_t * ebx, int32_
}
}
if (network_get_mode() == NETWORK_MODE_SERVER && !(flags & GAME_COMMAND_FLAG_NETWORKED) && !(flags & GAME_COMMAND_FLAG_GHOST))
if (network_get_mode() == NETWORK_MODE_SERVER && !(flags & GAME_COMMAND_FLAG_NETWORKED)
&& !(flags & GAME_COMMAND_FLAG_GHOST))
{
network_set_player_last_action(network_get_player_index(network_get_current_player_id()), command);
network_add_player_money_spent(network_get_current_player_id(), cost);
@@ -525,7 +529,8 @@ int32_t game_do_command_p(uint32_t command, int32_t * eax, int32_t * ebx, int32_
game_command_callback = nullptr;
// Show error window
if (gGameCommandNestLevel == 0 && (flags & GAME_COMMAND_FLAG_APPLY) && gUnk141F568 == gUnk13CA740 && !(flags & GAME_COMMAND_FLAG_ALLOW_DURING_PAUSED) && !(flags & GAME_COMMAND_FLAG_NETWORKED))
if (gGameCommandNestLevel == 0 && (flags & GAME_COMMAND_FLAG_APPLY) && gUnk141F568 == gUnk13CA740
&& !(flags & GAME_COMMAND_FLAG_ALLOW_DURING_PAUSED) && !(flags & GAME_COMMAND_FLAG_NETWORKED))
context_show_error(gGameCommandErrorTitle, gGameCommandErrorText);
return MONEY32_UNDEFINED;
@@ -542,24 +547,19 @@ void game_log_multiplayer_command(int command, const int * eax, const int * ebx,
{
// Get cheat name
const char* cheat = cheats_get_cheat_string(*ecx, *edx, *edi);
char * args[2] = {
(char *) player_name,
(char *) cheat
};
char* args[2] = { (char*)player_name, (char*)cheat };
format_string(log_msg, 256, STR_LOG_CHEAT_USED, args);
network_append_server_log(log_msg);
}
else if (command == GAME_COMMAND_CREATE_RIDE && *ebp == 1)
{ // ebp is 1 if the command comes from ride_create method in ride.c, other calls send ride_entry instead of ride and wont work
{ // ebp is 1 if the command comes from ride_create method in ride.c, other calls send ride_entry instead of ride and wont
// work
// Get ride name
Ride* ride = get_ride(*edx);
char ride_name[128];
format_string(ride_name, 128, ride->name, &ride->name_arguments);
char * args[2] = {
(char *) player_name,
ride_name
};
char* args[2] = { (char*)player_name, ride_name };
format_string(log_msg, 256, STR_LOG_CREATE_RIDE, args);
network_append_server_log(log_msg);
@@ -571,15 +571,14 @@ void game_log_multiplayer_command(int command, const int * eax, const int * ebx,
char ride_name[128];
format_string(ride_name, 128, ride->name, &ride->name_arguments);
char * args[2] = {
(char *) player_name,
ride_name
};
char* args[2] = { (char*)player_name, ride_name };
format_string(log_msg, 256, STR_LOG_DEMOLISH_RIDE, args);
network_append_server_log(log_msg);
}
else if (command == GAME_COMMAND_SET_RIDE_APPEARANCE || command == GAME_COMMAND_SET_RIDE_VEHICLES || command == GAME_COMMAND_SET_RIDE_SETTING)
else if (
command == GAME_COMMAND_SET_RIDE_APPEARANCE || command == GAME_COMMAND_SET_RIDE_VEHICLES
|| command == GAME_COMMAND_SET_RIDE_SETTING)
{
// Get ride name
int ride_index = *edx & 0xFF;
@@ -587,10 +586,7 @@ void game_log_multiplayer_command(int command, const int * eax, const int * ebx,
char ride_name[128];
format_string(ride_name, 128, ride->name, &ride->name_arguments);
char * args[2] = {
(char *) player_name,
ride_name
};
char* args[2] = { (char*)player_name, ride_name };
switch (command)
{
@@ -615,10 +611,7 @@ void game_log_multiplayer_command(int command, const int * eax, const int * ebx,
char ride_name[128];
format_string(ride_name, 128, ride->name, &ride->name_arguments);
char * args[2] = {
(char *) player_name,
ride_name
};
char* args[2] = { (char*)player_name, ride_name };
int status = *edx >> 8;
switch (status)
@@ -650,11 +643,7 @@ void game_log_multiplayer_command(int command, const int * eax, const int * ebx,
format_string(price_str, 16, STR_BOTTOM_TOOLBAR_CASH, price_args);
// Log change in primary or secondary price
char * args[3] = {
(char *) player_name,
ride_name,
price_str
};
char* args[3] = { (char*)player_name, ride_name, price_str };
if (*edx >> 8 == 0)
{
@@ -670,9 +659,7 @@ void game_log_multiplayer_command(int command, const int * eax, const int * ebx,
else if (command == GAME_COMMAND_SET_PARK_OPEN)
{
// Log change in park open/close
char * args[1] = {
(char *) player_name
};
char* args[1] = { (char*)player_name };
if (*edx >> 8 == 0)
{
@@ -693,16 +680,14 @@ void game_log_multiplayer_command(int command, const int * eax, const int * ebx,
format_string(price_str, 16, STR_BOTTOM_TOOLBAR_CASH, price_args);
// Log change in park entrance fee
char * args[2] = {
(char *) player_name,
price_str
};
char* args[2] = { (char*)player_name, price_str };
format_string(log_msg, 256, STR_LOG_PARK_ENTRANCE_FEE, args);
network_append_server_log(log_msg);
}
else if (command == GAME_COMMAND_PLACE_SCENERY || command == GAME_COMMAND_PLACE_WALL ||
command == GAME_COMMAND_PLACE_LARGE_SCENERY || command == GAME_COMMAND_PLACE_BANNER)
else if (
command == GAME_COMMAND_PLACE_SCENERY || command == GAME_COMMAND_PLACE_WALL
|| command == GAME_COMMAND_PLACE_LARGE_SCENERY || command == GAME_COMMAND_PLACE_BANNER)
{
uint8_t flags = *ebx & 0xFF;
if (flags & GAME_COMMAND_FLAG_GHOST)
@@ -712,15 +697,14 @@ void game_log_multiplayer_command(int command, const int * eax, const int * ebx,
}
// Log placing scenery
char * args[1] = {
(char *) player_name
};
char* args[1] = { (char*)player_name };
format_string(log_msg, 256, STR_LOG_PLACE_SCENERY, args);
network_append_server_log(log_msg);
}
else if (command == GAME_COMMAND_REMOVE_SCENERY || command == GAME_COMMAND_REMOVE_WALL ||
command == GAME_COMMAND_REMOVE_LARGE_SCENERY || command == GAME_COMMAND_REMOVE_BANNER)
else if (
command == GAME_COMMAND_REMOVE_SCENERY || command == GAME_COMMAND_REMOVE_WALL
|| command == GAME_COMMAND_REMOVE_LARGE_SCENERY || command == GAME_COMMAND_REMOVE_BANNER)
{
uint8_t flags = *ebx & 0xFF;
if (flags & GAME_COMMAND_FLAG_GHOST)
@@ -730,22 +714,19 @@ void game_log_multiplayer_command(int command, const int * eax, const int * ebx,
}
// Log removing scenery
char * args[1] = {
(char *) player_name
};
char* args[1] = { (char*)player_name };
format_string(log_msg, 256, STR_LOG_REMOVE_SCENERY, args);
network_append_server_log(log_msg);
}
else if (command == GAME_COMMAND_SET_SCENERY_COLOUR || command == GAME_COMMAND_SET_WALL_COLOUR ||
command == GAME_COMMAND_SET_LARGE_SCENERY_COLOUR || command == GAME_COMMAND_SET_BANNER_COLOUR ||
command == GAME_COMMAND_SET_BANNER_NAME || command == GAME_COMMAND_SET_SIGN_NAME ||
command == GAME_COMMAND_SET_BANNER_STYLE || command == GAME_COMMAND_SET_SIGN_STYLE)
else if (
command == GAME_COMMAND_SET_SCENERY_COLOUR || command == GAME_COMMAND_SET_WALL_COLOUR
|| command == GAME_COMMAND_SET_LARGE_SCENERY_COLOUR || command == GAME_COMMAND_SET_BANNER_COLOUR
|| command == GAME_COMMAND_SET_BANNER_NAME || command == GAME_COMMAND_SET_SIGN_NAME
|| command == GAME_COMMAND_SET_BANNER_STYLE || command == GAME_COMMAND_SET_SIGN_STYLE)
{
// Log editing scenery
char * args[1] = {
(char *) player_name
};
char* args[1] = { (char*)player_name };
format_string(log_msg, 256, STR_LOG_EDIT_SCENERY, args);
network_append_server_log(log_msg);
@@ -765,10 +746,7 @@ void game_log_multiplayer_command(int command, const int * eax, const int * ebx,
memcpy(banner_name + nameChunkOffset + 4, ebp, 4);
memcpy(banner_name + nameChunkOffset + 8, edi, 4);
banner_name[sizeof(banner_name) - 1] = '\0';
char * args_sign[2] = {
(char *) player_name,
(char *) banner_name
};
char* args_sign[2] = { (char*)player_name, (char*)banner_name };
format_string(log_msg, 256, STR_LOG_SET_SIGN_NAME, args_sign);
network_append_server_log(log_msg);
@@ -782,28 +760,21 @@ void game_log_multiplayer_command(int command, const int * eax, const int * ebx,
char ride_name[128];
format_string(ride_name, 128, ride->name, &ride->name_arguments);
char * args[2] = {
(char *) player_name,
ride_name
};
char* args[2] = { (char*)player_name, ride_name };
format_string(log_msg, 256, STR_LOG_PLACE_TRACK, args);
network_append_server_log(log_msg);
}
else if (command == GAME_COMMAND_REMOVE_TRACK)
{
char * args[1] = {
(char *) player_name
};
char* args[1] = { (char*)player_name };
format_string(log_msg, 256, STR_LOG_REMOVE_TRACK, args);
network_append_server_log(log_msg);
}
else if (command == GAME_COMMAND_PLACE_PEEP_SPAWN)
{
char * args[1] = {
(char *) player_name
};
char* args[1] = { (char*)player_name };
format_string(log_msg, 256, STR_LOG_PLACE_PEEP_SPAWN, args);
network_append_server_log(log_msg);
@@ -925,8 +896,7 @@ void utf8_to_rct2_self(char * buffer, size_t length)
{
*dst++ = '\0';
i++;
}
while (i < length);
} while (i < length);
}
void rct2_to_utf8_self(char* buffer, size_t length)
@@ -960,7 +930,6 @@ void game_convert_strings_to_utf8()
// News items
game_convert_news_items_to_utf8();
}
void game_convert_news_items_to_utf8()
@@ -1047,7 +1016,9 @@ void game_fix_save_vars()
{
log_warning("Couldn't find station, removing peep %u", spriteIndex);
peepsToRemove.push_back(peep);
} else {
}
else
{
log_warning("Amending ride station to %u.", station);
peep->current_ride_station = station;
}
@@ -1291,7 +1262,6 @@ static void limit_autosave_count(const size_t numberOfFilesToKeep, bool processL
platform_file_delete(autosaveFiles[i]);
}
for (size_t i = 0; i < autosavesCount; i++)
{
free(autosaveFiles[i]);
@@ -1319,9 +1289,17 @@ void game_autosave()
platform_get_time_local(&currentTime);
utf8 timeName[44];
snprintf(timeName, sizeof(timeName), "autosave_%04u-%02u-%02u_%02u-%02u-%02u%s",
currentDate.year, currentDate.month, currentDate.day, currentTime.hour,
currentTime.minute, currentTime.second, fileExtension);
snprintf(
timeName,
sizeof(timeName),
"autosave_%04u-%02u-%02u_%02u-%02u-%02u%s",
currentDate.year,
currentDate.month,
currentDate.day,
currentTime.hour,
currentTime.minute,
currentTime.second,
fileExtension);
limit_autosave_count(NUMBER_OF_AUTOSAVES_TO_KEEP, (gScreenFlags & SCREEN_FLAGS_EDITOR));

9
src/openrct2/Game.h
View File

@@ -118,8 +118,10 @@ enum
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);
@@ -158,7 +160,8 @@ 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);

23
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();
}
@@ -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())

15
src/openrct2/GameState.h
View File

@@ -9,9 +9,10 @@
#pragma once
#include <memory>
#include "Date.h"
#include <memory>
namespace OpenRCT2
{
class Park;
@@ -29,11 +30,17 @@ namespace OpenRCT2
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;
}
}

15
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;

80
src/openrct2/Intro.cpp
View File

@@ -7,11 +7,12 @@
* 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
@@ -40,7 +41,8 @@ void intro_update()
screen_intro_process_mouse_input();
screen_intro_process_keyboard_input();
switch (gIntroState) {
switch (gIntroState)
{
case INTRO_STATE_DISCLAIMER_1:
case INTRO_STATE_DISCLAIMER_2:
// Originally used for the disclaimer text
@@ -61,7 +63,8 @@ void intro_update()
_introStateCounter += 5;
// Check if logo is off the screen...ish
if (_introStateCounter > context_get_height() - 120) {
if (_introStateCounter > context_get_height() - 120)
{
_introStateCounter = -116;
gIntroState++;
}
@@ -77,23 +80,28 @@ void intro_update()
_introStateCounter += 5;
// Check if logo is almost scrolled to the bottom
if (!_chainLiftFinished && _introStateCounter >= context_get_height() + 40 - 421) {
if (!_chainLiftFinished && _introStateCounter >= context_get_height() + 40 - 421)
{
_chainLiftFinished = true;
// Stop the chain lift sound
if (_soundChannel != nullptr) {
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);
_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) {
if (_introStateCounter >= context_get_height() + 40)
{
// Stop the track friction sound
if (_soundChannel != nullptr) {
if (_soundChannel != nullptr)
{
Mixer_Stop_Channel(_soundChannel);
_soundChannel = nullptr;
}
@@ -108,7 +116,8 @@ void intro_update()
case INTRO_STATE_LOGO_FADE_IN:
// Fade in, add 4 / 256 to fading
_introStateCounter += 0x400;
if (_introStateCounter > 0xFF00) {
if (_introStateCounter > 0xFF00)
{
gIntroState++;
_introStateCounter = 0;
}
@@ -116,7 +125,8 @@ void intro_update()
case INTRO_STATE_LOGO_WAIT:
// Wait 80 game ticks
_introStateCounter++;
if (_introStateCounter >= 80) {
if (_introStateCounter >= 80)
{
// Set fading to 256
_introStateCounter = 0xFF00;
@@ -126,13 +136,15 @@ void intro_update()
case INTRO_STATE_LOGO_FADE_OUT:
// Fade out, subtract 4 / 256 from fading
_introStateCounter -= 0x400;
if (_introStateCounter < 0) {
if (_introStateCounter < 0)
{
gIntroState = INTRO_STATE_CLEAR;
}
break;
case INTRO_STATE_CLEAR:
// Stop any playing sound
if (_soundChannel != nullptr) {
if (_soundChannel != nullptr)
{
Mixer_Stop_Channel(_soundChannel);
_soundChannel = nullptr;
}
@@ -153,7 +165,8 @@ void intro_draw(rct_drawpixelinfo *dpi)
{
int32_t screenWidth = context_get_width();
switch (gIntroState) {
switch (gIntroState)
{
case INTRO_STATE_DISCLAIMER_1:
case INTRO_STATE_DISCLAIMER_2:
break;
@@ -164,9 +177,12 @@ void intro_draw(rct_drawpixelinfo *dpi)
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,
gfx_fill_rect(
dpi,
(screenWidth / 2) - 320 + 50,
_introStateCounter + 50,
(screenWidth / 2) - 320 + 50 + 540,
_introStateCounter + 50 + 425,
BORDER_COLOUR_PUBLISHER);
// Draw Infogrames logo
@@ -187,9 +203,12 @@ void intro_draw(rct_drawpixelinfo *dpi)
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) {
if (_introStateCounter <= 0xFF00)
{
gfx_transpose_palette(PALETTE_G1_IDX_LOGO, (_introStateCounter >> 8) & 0xFF);
} else {
}
else
{
gfx_transpose_palette(PALETTE_G1_IDX_LOGO, 255);
}
screen_intro_draw_logo(dpi);
@@ -198,9 +217,12 @@ void intro_draw(rct_drawpixelinfo *dpi)
screen_intro_draw_logo(dpi);
break;
case INTRO_STATE_LOGO_FADE_OUT:
if (_introStateCounter >= 0) {
if (_introStateCounter >= 0)
{
gfx_transpose_palette(PALETTE_G1_IDX_LOGO, (_introStateCounter >> 8) & 0xFF);
} else {
}
else
{
gfx_transpose_palette(PALETTE_G1_IDX_LOGO, 0);
}
screen_intro_draw_logo(dpi);
@@ -213,7 +235,8 @@ void intro_draw(rct_drawpixelinfo *dpi)
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();
}
}
@@ -225,8 +248,10 @@ 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) {
for (int i = 0; i < 256; i++)
{
if (keys[i] != 0)
{
screen_intro_skip_part();
break;
}
@@ -235,7 +260,8 @@ static void screen_intro_process_keyboard_input()
static void screen_intro_skip_part()
{
switch (gIntroState) {
switch (gIntroState)
{
case INTRO_STATE_NONE:
break;
case INTRO_STATE_DISCLAIMER_2:

3
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,

1
src/openrct2/OpenRCT2.h
View File

@@ -63,4 +63,3 @@ void openrct2_write_full_version_info(utf8 * buffer, size_t bufferSize);
void openrct2_finish();
int32_t cmdline_run(const char** argv, int32_t argc);

14
src/openrct2/ParkImporter.cpp
View File

@@ -7,13 +7,15 @@
* 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
{
@@ -35,13 +37,11 @@ namespace ParkImporter
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)
{
return String::Equals(extension, ".sc4", true) ||
String::Equals(extension, ".sc6", true);
}
return String::Equals(extension, ".sc4", true) || String::Equals(extension, ".sc6", true);
}
} // namespace ParkImporter

15
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;
@@ -54,10 +54,8 @@ public:
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 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;
@@ -67,11 +65,12 @@ namespace ParkImporter
{
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);
}
} // namespace ParkImporter
class ObjectLoadException : public std::exception
{

10
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;
@@ -40,7 +41,8 @@ public:
{
auto basePath = GetDirectoryPath(base);
const utf8* directoryName;
switch (base) {
switch (base)
{
default:
case DIRBASE::RCT1:
case DIRBASE::RCT2:

3
src/openrct2/PlatformEnvironment.h
View File

@@ -9,9 +9,10 @@
#pragma once
#include "common.h"
#include <memory>
#include <string>
#include "common.h"
namespace OpenRCT2
{

6
src/openrct2/Version.cpp
View File

@@ -7,15 +7,15 @@
* 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

65
src/openrct2/common.h
View File

@@ -19,11 +19,11 @@
#include <ctime>
#endif
#include "Diagnostic.h"
#include <cassert>
#include <cstdint>
#include "Diagnostic.h"
using utf8 = char;
using utf8string = utf8*;
using const_utf8string = const utf8*;
@@ -79,7 +79,9 @@ using colour_t = uint8_t;
#endif // defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
#if !((defined (_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200809L) || (defined(_XOPEN_SOURCE) && _XOPEN_SOURCE >= 700) || (defined(__APPLE__) && defined(__MACH__)) || defined(__ANDROID_API__) || defined(__FreeBSD__))
#if !( \
(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)
@@ -128,10 +130,25 @@ using BannerIndex = uint8_t;
using EMPTY_ARGS_VOID_POINTER = void();
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
@@ -185,48 +202,60 @@ using rct_string_id = uint16_t;
* 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;
};

4
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
@@ -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,