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

Split Ride and rct2_ride

This commit is contained in:
Gymnasiast 2017-09-12 11:16:57 +02:00
parent 179e4dd368
commit a28509e24c
93 changed files with 1043 additions and 821 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -191,7 +191,7 @@ static void research_rides_setup(){
// Set research required for rides in use
for (uint16 rideIndex = 0; rideIndex < 255; rideIndex++){
rct_ride* ride = get_ride(rideIndex);
Ride * ride = get_ride(rideIndex);
if (ride->type == RIDE_TYPE_NULL)continue;
gEditorSelectedObjects[OBJECT_TYPE_RIDE][ride->subtype] |= 1;
}

8
src/openrct2-ui/windows/EditorObjectiveOptions.cpp
View File

@ -1086,7 +1086,7 @@ static void window_editor_objective_options_rides_resize(rct_window *w)
static void window_editor_objective_options_rides_update(rct_window *w)
{
sint32 i, numItems;
rct_ride *ride;
Ride *ride;
w->frame_no++;
window_event_invalidate_call(w);
@ -1122,7 +1122,7 @@ static void window_editor_objective_options_rides_scrollgetheight(rct_window *w,
*/
static void window_editor_objective_options_rides_scrollmousedown(rct_window *w, sint32 scrollIndex, sint32 x, sint32 y)
{
rct_ride *ride;
Ride *ride;
sint32 i;
i = y / 12;
@ -1192,7 +1192,7 @@ static void window_editor_objective_options_rides_paint(rct_window *w, rct_drawp
static void window_editor_objective_options_rides_scrollpaint(rct_window *w, rct_drawpixelinfo *dpi, sint32 scrollIndex)
{
rct_string_id stringId;
rct_ride *ride;
Ride *ride;
sint32 colour = ColourMapA[w->colours[1]].mid_light;
gfx_fill_rect(dpi, dpi->x, dpi->y, dpi->x + dpi->width - 1, dpi->y + dpi->height - 1, colour);
@ -1232,7 +1232,7 @@ static void window_editor_objective_options_rides_scrollpaint(rct_window *w, rct
*/
static void window_editor_objective_options_update_disabled_widgets(rct_window *w)
{
rct_ride *ride;
Ride *ride;
sint32 i, numRides;
// Check if there are any rides (not shops or facilities)

12
src/openrct2/cheats.c
View File

@ -147,7 +147,7 @@ static void cheat_remove_litter()
static void cheat_fix_rides()
{
sint32 rideIndex;
rct_ride *ride;
Ride *ride;
rct_peep *mechanic;
FOR_ALL_RIDES(rideIndex, ride)
@ -169,7 +169,7 @@ static void cheat_fix_rides()
static void cheat_renew_rides()
{
sint32 i;
rct_ride *ride;
Ride *ride;
FOR_ALL_RIDES(i, ride)
{
@ -184,7 +184,7 @@ static void cheat_renew_rides()
static void cheat_make_destructible()
{
sint32 i;
rct_ride *ride;
Ride *ride;
FOR_ALL_RIDES(i, ride)
{
if (ride->lifecycle_flags & RIDE_LIFECYCLE_INDESTRUCTIBLE)
@ -198,7 +198,7 @@ static void cheat_make_destructible()
static void cheat_reset_crash_status()
{
sint32 i;
rct_ride *ride;
Ride *ride;
FOR_ALL_RIDES(i, ride){
// Reset crash status
@ -213,7 +213,7 @@ static void cheat_reset_crash_status()
static void cheat_10_minute_inspections()
{
sint32 i;
rct_ride *ride;
Ride *ride;
FOR_ALL_RIDES(i, ride) {
// Set inspection interval to 10 minutes
@ -368,7 +368,7 @@ static void cheat_remove_all_guests()
}
sint32 rideIndex;
rct_ride *ride;
Ride *ride;
FOR_ALL_RIDES(rideIndex, ride)
{

2
src/openrct2/drawing/lightfx.c
View File

@ -718,7 +718,7 @@ void lightfx_add_lights_magic_vehicles()
static const sint16 offsetLookup[32] = { 10, 10, 9, 8, 7, 6, 4, 2, 0, -2, -4, -6, -7, -8, -9, -10, -10, -10, -9, -8, -7, -6, -4, -2, 0, 2, 4, 6, 7, 8, 9, 10 };
rct_ride *ride = get_ride(vehicle->ride);
Ride *ride = get_ride(vehicle->ride);
switch (ride->type) {
case RIDE_TYPE_OBSERVATION_TOWER:
lightfx_add_3d_light(vehicleID, 0x0000 | LIGHTFX_LIGHT_QUALIFIER_SPRITE, vehicle->x, vehicle->y + 16, vehicle->z, LIGHTFX_LIGHT_TYPE_SPOT_3);

2
src/openrct2/editor.c
View File

@ -304,7 +304,7 @@ static void editor_clear_map_for_editing(bool fromSave)
//
{
sint32 i;
rct_ride *ride;
Ride *ride;
FOR_ALL_RIDES(i, ride) {
user_string_free(ride->name);
}

12
src/openrct2/game.c
View File

@ -653,7 +653,7 @@ void game_log_multiplayer_command(int command, int *eax, int* ebx, int* ecx, int
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
// Get ride name
rct_ride* ride = get_ride(*edx);
Ride* ride = get_ride(*edx);
char ride_name[128];
format_string(ride_name, 128, ride->name, &ride->name_arguments);
@ -666,7 +666,7 @@ void game_log_multiplayer_command(int command, int *eax, int* ebx, int* ecx, int
network_append_server_log(log_msg);
} else if (command == GAME_COMMAND_DEMOLISH_RIDE && (*ebp == 1 || *ebp == 0)) { // ebp is 1 if command comes from ride window prompt, so we don't log "demolishing" ride previews
// Get ride name
rct_ride* ride = get_ride(*edx);
Ride* ride = get_ride(*edx);
char ride_name[128];
format_string(ride_name, 128, ride->name, &ride->name_arguments);
@ -680,7 +680,7 @@ void game_log_multiplayer_command(int command, int *eax, int* ebx, int* ecx, int
} 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;
rct_ride* ride = get_ride(ride_index);
Ride* ride = get_ride(ride_index);
char ride_name[128];
format_string(ride_name, 128, ride->name, &ride->name_arguments);
@ -699,7 +699,7 @@ void game_log_multiplayer_command(int command, int *eax, int* ebx, int* ecx, int
} else if (command == GAME_COMMAND_SET_RIDE_STATUS) {
// Get ride name
int ride_index = *edx & 0xFF;
rct_ride* ride = get_ride(ride_index);
Ride* ride = get_ride(ride_index);
char ride_name[128];
format_string(ride_name, 128, ride->name, &ride->name_arguments);
@ -719,7 +719,7 @@ void game_log_multiplayer_command(int command, int *eax, int* ebx, int* ecx, int
} else if (command == GAME_COMMAND_SET_RIDE_PRICE) {
// Get ride name
int ride_index = *edx & 0xFF;
rct_ride* ride = get_ride(ride_index);
Ride* ride = get_ride(ride_index);
char ride_name[128];
format_string(ride_name, 128, ride->name, &ride->name_arguments);
@ -836,7 +836,7 @@ void game_log_multiplayer_command(int command, int *eax, int* ebx, int* ecx, int
} else if (command == GAME_COMMAND_PLACE_TRACK) {
// Get ride name
int ride_index = *edx & 0xFF;
rct_ride* ride = get_ride(ride_index);
Ride* ride = get_ride(ride_index);
char ride_name[128];
format_string(ride_name, 128, ride->name, &ride->name_arguments);

12
src/openrct2/interface/console.c
View File

@ -457,7 +457,7 @@ static sint32 cc_rides(const utf8 **argv, sint32 argc)
{
if (argc > 0) {
if (strcmp(argv[0], "list") == 0) {
rct_ride *ride;
Ride *ride;
sint32 i;
FOR_ALL_RIDES(i, ride) {
char name[128];
@ -510,7 +510,7 @@ static sint32 cc_rides(const utf8 **argv, sint32 argc)
} else if (ride_index < 0) {
console_printf("Ride index must not be negative");
} else {
rct_ride *ride = get_ride(ride_index);
Ride *ride = get_ride(ride_index);
if (mode <= 0 || mode > (RIDE_MODE_COUNT - 1)) {
console_printf("Invalid ride mode.");
}
@ -535,7 +535,7 @@ static sint32 cc_rides(const utf8 **argv, sint32 argc)
console_printf("This command expects integer arguments");
}
else {
rct_ride *ride = get_ride(ride_index);
Ride *ride = get_ride(ride_index);
if (friction <= 0) {
console_printf("Friction value must be strictly positive");
}
@ -566,7 +566,7 @@ static sint32 cc_rides(const utf8 **argv, sint32 argc)
console_printf("This command expects integer arguments");
}
else {
rct_ride *ride = get_ride(ride_index);
Ride *ride = get_ride(ride_index);
if (excitement <= 0) {
console_printf("Excitement value must be strictly positive");
}
@ -590,7 +590,7 @@ static sint32 cc_rides(const utf8 **argv, sint32 argc)
console_printf("This command expects integer arguments");
}
else {
rct_ride *ride = get_ride(ride_index);
Ride *ride = get_ride(ride_index);
if (intensity <= 0) {
console_printf("Intensity value must be strictly positive");
}
@ -614,7 +614,7 @@ static sint32 cc_rides(const utf8 **argv, sint32 argc)
console_printf("This command expects integer arguments");
}
else {
rct_ride *ride = get_ride(ride_index);
Ride *ride = get_ride(ride_index);
if (nausea <= 0) {
console_printf("Nausea value must be strictly positive");
}

2
src/openrct2/interface/viewport_interaction.c
View File

@ -166,7 +166,7 @@ sint32 viewport_interaction_get_item_right(sint32 x, sint32 y, viewport_interact
rct_map_element *mapElement;
rct_scenery_entry *sceneryEntry;
rct_banner *banner;
rct_ride *ride;
Ride *ride;
sint32 i, stationIndex;
// No click input for title screen or track manager

20
src/openrct2/management/award.c
View File

@ -149,7 +149,7 @@ static sint32 award_is_deserved_most_tidy(sint32 awardType, sint32 activeAwardTy
static sint32 award_is_deserved_best_rollercoasters(sint32 awardType, sint32 activeAwardTypes)
{
sint32 i, rollerCoasters;
rct_ride *ride;
Ride *ride;
rct_ride_entry *rideEntry;
rollerCoasters = 0;
@ -251,7 +251,7 @@ static sint32 award_is_deserved_safest(sint32 awardType, sint32 activeAwardTypes
sint32 i, peepsWhoDislikeVandalism;
uint16 spriteIndex;
rct_peep *peep;
rct_ride *ride;
Ride *ride;
peepsWhoDislikeVandalism = 0;
FOR_ALL_GUESTS(spriteIndex, peep) {
@ -304,7 +304,7 @@ static sint32 award_is_deserved_best_food(sint32 awardType, sint32 activeAwardTy
{
sint32 i, hungryPeeps, shops, uniqueShops;
uint64 shopTypes;
rct_ride *ride;
Ride *ride;
rct_ride_entry *rideEntry;
uint16 spriteIndex;
rct_peep *peep;
@ -353,7 +353,7 @@ static sint32 award_is_deserved_worst_food(sint32 awardType, sint32 activeAwardT
{
sint32 i, hungryPeeps, shops, uniqueShops;
uint64 shopTypes;
rct_ride *ride;
Ride *ride;
rct_ride_entry *rideEntry;
uint16 spriteIndex;
rct_peep *peep;
@ -401,7 +401,7 @@ static sint32 award_is_deserved_worst_food(sint32 awardType, sint32 activeAwardT
static sint32 award_is_deserved_best_restrooms(sint32 awardType, sint32 activeAwardTypes)
{
uint32 i, numRestrooms, guestsWhoNeedRestroom;
rct_ride *ride;
Ride *ride;
uint16 spriteIndex;
rct_peep *peep;
@ -436,7 +436,7 @@ static sint32 award_is_deserved_best_restrooms(sint32 awardType, sint32 activeAw
static sint32 award_is_deserved_most_disappointing(sint32 awardType, sint32 activeAwardTypes)
{
uint32 i, countedRides, disappointingRides;
rct_ride *ride;
Ride *ride;
if (activeAwardTypes & (1 << PARK_AWARD_BEST_VALUE))
return 0;
@ -466,7 +466,7 @@ static sint32 award_is_deserved_most_disappointing(sint32 awardType, sint32 acti
static sint32 award_is_deserved_best_water_rides(sint32 awardType, sint32 activeAwardTypes)
{
sint32 i, waterRides;
rct_ride *ride;
Ride *ride;
rct_ride_entry *rideEntry;
waterRides = 0;
@ -498,7 +498,7 @@ static sint32 award_is_deserved_best_water_rides(sint32 awardType, sint32 active
static sint32 award_is_deserved_best_custom_designed_rides(sint32 awardType, sint32 activeAwardTypes)
{
sint32 i, customDesignedRides;
rct_ride *ride;
Ride *ride;
if (activeAwardTypes & (1 << PARK_AWARD_MOST_DISAPPOINTING))
return 0;
@ -525,7 +525,7 @@ const uint8 dazzling_ride_colours[] = { 5, 14, 20, 30 };
static sint32 award_is_deserved_most_dazzling_ride_colours(sint32 awardType, sint32 activeAwardTypes)
{
sint32 i, j, countedRides, colourfulRides;
rct_ride *ride;
Ride *ride;
uint8 mainTrackColour;
if (activeAwardTypes & (1 << PARK_AWARD_MOST_DISAPPOINTING))
@ -576,7 +576,7 @@ static sint32 award_is_deserved_most_confusing_layout(sint32 awardType, sint32 a
static sint32 award_is_deserved_best_gentle_rides(sint32 awardType, sint32 activeAwardTypes)
{
sint32 i, gentleRides;
rct_ride *ride;
Ride *ride;
rct_ride_entry *rideEntry;
gentleRides = 0;

4
src/openrct2/management/finance.c
View File

@ -146,7 +146,7 @@ void finance_pay_interest()
void finance_pay_ride_upkeep()
{
sint32 i;
rct_ride* ride;
Ride* ride;
FOR_ALL_RIDES(i, ride) {
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_EVER_BEEN_OPENED)) {
@ -242,7 +242,7 @@ void finance_update_daily_profit()
current_profit -= current_loan / 600;
// Ride costs
rct_ride *ride;
Ride *ride;
sint32 i;
FOR_ALL_RIDES(i, ride) {
if (ride->status != RIDE_STATUS_CLOSED && ride->upkeep_cost != -1) {

6
src/openrct2/management/marketing.c
View File

@ -42,7 +42,7 @@ uint8 gMarketingCampaignRideIndex[22];
sint32 marketing_get_campaign_guest_generation_probability(sint32 campaign)
{
sint32 probability = AdvertisingCampaignGuestGenerationProbabilities[campaign];
rct_ride *ride;
Ride *ride;
// Lower probability of guest generation if price was already low
switch (campaign) {
@ -93,7 +93,7 @@ void marketing_update()
// This sets the string parameters for the marketing types that have an argument.
if (campaign == ADVERTISING_CAMPAIGN_RIDE_FREE || campaign == ADVERTISING_CAMPAIGN_RIDE) {
rct_ride* ride = get_ride(campaignItem);
Ride* ride = get_ride(campaignItem);
set_format_arg(0, rct_string_id, ride->name);
set_format_arg(2, uint32, ride->name_arguments);
} else if (campaign == ADVERTISING_CAMPAIGN_FOOD_OR_DRINK_FREE) {
@ -190,7 +190,7 @@ void game_command_start_campaign(sint32* eax, sint32* ebx, sint32* ecx, sint32*
bool marketing_is_campaign_type_applicable(sint32 campaignType)
{
sint32 i;
rct_ride *ride;
Ride *ride;
rct_ride_entry *rideEntry;
switch (campaignType) {

2
src/openrct2/management/news_item.c
View File

@ -208,7 +208,7 @@ static sint32 news_item_get_new_history_slot()
void news_item_get_subject_location(sint32 type, sint32 subject, sint32 *x, sint32 *y, sint32 *z)
{
sint32 i;
rct_ride *ride;
Ride *ride;
rct_peep *peep;
rct_vehicle *vehicle;

2
src/openrct2/paint/map_element/entrance.c
View File

@ -65,7 +65,7 @@ static void ride_entrance_exit_paint(paint_session * session, uint8 direction, s
}
#endif
rct_ride* ride = get_ride(map_element->properties.entrance.ride_index);
Ride* ride = get_ride(map_element->properties.entrance.ride_index);
if (ride->entrance_style == RIDE_ENTRANCE_STYLE_NONE) return;
const rct_ride_entrance_definition *style = &RideEntranceDefinitions[ride->entrance_style];

2
src/openrct2/paint/map_element/fence.c
View File

@ -364,7 +364,7 @@ void fence_paint(paint_session * session, uint8 direction, sint32 height, rct_ma
set_format_arg(0, rct_string_id, banner->string_idx);
if (banner->flags & BANNER_FLAG_LINKED_TO_RIDE) {
rct_ride * ride = get_ride(banner->colour);
Ride * ride = get_ride(banner->colour);
set_format_arg(0, rct_string_id, ride->name);
set_format_arg(2, uint32, ride->name_arguments);
}

2
src/openrct2/paint/map_element/path.c
View File

@ -397,7 +397,7 @@ static void sub_6A4101(paint_session * session, rct_map_element * map_element, u
set_format_arg(0, uint32, 0);
set_format_arg(4, uint32, 0);
rct_ride* ride = get_ride(map_element->properties.path.ride_index);
Ride* ride = get_ride(map_element->properties.path.ride_index);
rct_string_id string_id = STR_RIDE_ENTRANCE_CLOSED;
if (ride->status == RIDE_STATUS_OPEN && !(ride->lifecycle_flags & RIDE_LIFECYCLE_BROKEN_DOWN)){
set_format_arg(0, rct_string_id, ride->name);

4
src/openrct2/paint/map_element/scenery_multiple.c
View File

@ -261,7 +261,7 @@ void scenery_multiple_paint(paint_session * session, uint8 direction, uint16 hei
rct_banner *banner = &gBanners[bannerIndex];
rct_string_id stringId = banner->string_idx;
if (banner->flags & BANNER_FLAG_LINKED_TO_RIDE) {
rct_ride * ride = get_ride(banner->colour);
Ride * ride = get_ride(banner->colour);
stringId = ride->name;
set_format_arg(0, uint32, ride->name_arguments);
}
@ -351,7 +351,7 @@ void scenery_multiple_paint(paint_session * session, uint8 direction, uint16 hei
rct_banner *banner = &gBanners[bannerIndex];
set_format_arg(0, rct_string_id, banner->string_idx);
if (banner->flags & BANNER_FLAG_LINKED_TO_RIDE) {
rct_ride * ride = get_ride(banner->colour);
Ride * ride = get_ride(banner->colour);
set_format_arg(0, rct_string_id, ride->name);
set_format_arg(2, uint32, ride->name_arguments);
}

176
src/openrct2/peep/peep.c
View File

@ -138,9 +138,9 @@ static bool peep_has_ridden(rct_peep *peep, sint32 rideIndex);
static void peep_set_has_ridden_ride_type(rct_peep *peep, sint32 rideType);
static bool peep_has_ridden_ride_type(rct_peep *peep, sint32 rideType);
static void peep_on_enter_or_exit_ride(rct_peep *peep, sint32 rideIndex, sint32 flags);
static void peep_update_favourite_ride(rct_peep *peep, rct_ride *ride);
static sint16 peep_calculate_ride_satisfaction(rct_peep *peep, rct_ride *ride);
static void peep_update_ride_nausea_growth(rct_peep *peep, rct_ride *ride);
static void peep_update_favourite_ride(rct_peep *peep, Ride *ride);
static sint16 peep_calculate_ride_satisfaction(rct_peep *peep, Ride *ride);
static void peep_update_ride_nausea_growth(rct_peep *peep, Ride *ride);
static bool peep_decide_and_buy_item(rct_peep *peep, sint32 rideIndex, sint32 shopItem, money32 price);
static bool peep_should_use_cash_machine(rct_peep *peep, sint32 rideIndex);
static bool peep_should_go_on_ride(rct_peep *peep, sint32 rideIndex, sint32 entranceNum, sint32 flags);
@ -158,18 +158,18 @@ static void peep_give_real_name(rct_peep *peep);
static sint32 guest_surface_path_finding(rct_peep* peep);
static void peep_read_map(rct_peep *peep);
static bool peep_heading_for_ride_or_park_exit(rct_peep *peep);
static bool peep_update_fixing_sub_state_0(rct_ride *ride);
static bool peep_update_fixing_sub_state_1(bool firstRun, rct_peep *peep, rct_ride *ride);
static bool peep_update_fixing_sub_state_2345(bool firstRun, rct_peep *peep, rct_ride *ride);
static bool peep_update_fixing_sub_state_6(bool firstRun, rct_peep *peep, rct_ride *ride);
static bool peep_update_fixing_sub_state_7(bool firstRun, rct_peep *peep, rct_ride *ride);
static bool peep_update_fixing_sub_state_0(Ride *ride);
static bool peep_update_fixing_sub_state_1(bool firstRun, rct_peep *peep, Ride *ride);
static bool peep_update_fixing_sub_state_2345(bool firstRun, rct_peep *peep, Ride *ride);
static bool peep_update_fixing_sub_state_6(bool firstRun, rct_peep *peep, Ride *ride);
static bool peep_update_fixing_sub_state_7(bool firstRun, rct_peep *peep, Ride *ride);
static bool peep_update_fixing_sub_state_8(bool firstRun, rct_peep *peep);
static bool peep_update_fixing_sub_state_9(bool firstRun, rct_peep *peep, rct_ride *ride);
static bool peep_update_fixing_sub_state_10(bool firstRun, rct_peep *peep, rct_ride *ride);
static bool peep_update_fixing_sub_state_11(bool firstRun, rct_peep *peep, rct_ride *ride);
static bool peep_update_fixing_sub_state_12(bool firstRun, rct_peep *peep, rct_ride *ride);
static bool peep_update_fixing_sub_state_13(bool firstRun, sint32 steps, rct_peep *peep, rct_ride *ride);
static bool peep_update_fixing_sub_state_14(bool firstRun, rct_peep *peep, rct_ride *ride);
static bool peep_update_fixing_sub_state_9(bool firstRun, rct_peep *peep, Ride *ride);
static bool peep_update_fixing_sub_state_10(bool firstRun, rct_peep *peep, Ride *ride);
static bool peep_update_fixing_sub_state_11(bool firstRun, rct_peep *peep, Ride *ride);
static bool peep_update_fixing_sub_state_12(bool firstRun, rct_peep *peep, Ride *ride);
static bool peep_update_fixing_sub_state_13(bool firstRun, sint32 steps, rct_peep *peep, Ride *ride);
static bool peep_update_fixing_sub_state_14(bool firstRun, rct_peep *peep, Ride *ride);
static void peep_update_ride_inspected(sint32 rideIndex);
static void peep_release_balloon(rct_peep *peep, sint16 spawn_height);
@ -593,7 +593,7 @@ static uint8 peep_assess_surroundings(sint16 centre_x, sint16 centre_y, sint16 c
rct_map_element* mapElement = map_get_first_element_at(x / 32, y / 32);
do{
rct_ride* ride;
Ride* ride;
rct_scenery_entry* scenery;
switch (map_element_get_type(mapElement)){
@ -1001,7 +1001,7 @@ static void sub_68F41A(rct_peep *peep, sint32 index)
peep->happiness_target = max(0, peep->happiness_target - 5);
if (peep->time_on_ride > 22){
rct_ride* ride = get_ride(peep->current_ride);
Ride* ride = get_ride(peep->current_ride);
uint8 thought_type = ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_IN_RIDE) ?
PEEP_THOUGHT_TYPE_GET_OUT :
@ -1656,7 +1656,7 @@ void peep_decrement_num_riders(rct_peep* peep){
if (peep->state == PEEP_STATE_ON_RIDE
|| peep->state == PEEP_STATE_ENTERING_RIDE){
rct_ride* ride = get_ride(peep->current_ride);
Ride* ride = get_ride(peep->current_ride);
ride->num_riders--;
ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAIN | RIDE_INVALIDATE_RIDE_LIST;
}
@ -1839,7 +1839,7 @@ void peep_window_state_update(rct_peep* peep)
if (peep->type == PEEP_TYPE_GUEST) {
if (peep->state == PEEP_STATE_ON_RIDE || peep->state == PEEP_STATE_ENTERING_RIDE) {
rct_ride* ride = get_ride(peep->current_ride);
Ride* ride = get_ride(peep->current_ride);
ride->num_riders++;
ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAIN | RIDE_INVALIDATE_RIDE_LIST;
}
@ -2313,7 +2313,7 @@ static void peep_update_sitting(rct_peep* peep){
*/
void remove_peep_from_queue(rct_peep* peep)
{
rct_ride* ride = get_ride(peep->current_ride);
Ride* ride = get_ride(peep->current_ride);
uint8 cur_station = peep->current_ride_station;
// Make sure we don't underflow, building while paused might reset it to 0 where peeps have
@ -2344,7 +2344,7 @@ void remove_peep_from_queue(rct_peep* peep)
*
* rct2: 0x00691C6E
*/
static rct_vehicle* peep_choose_car_from_ride(rct_peep* peep, rct_ride* ride, uint8* car_array, uint8 car_array_size){
static rct_vehicle* peep_choose_car_from_ride(rct_peep* peep, Ride* ride, uint8* car_array, uint8 car_array_size){
uint8 chosen_car = peep_rand();
if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_HAS_G_FORCES)
&& ((chosen_car & 0xC) != 0xC)){
@ -2369,7 +2369,7 @@ static rct_vehicle* peep_choose_car_from_ride(rct_peep* peep, rct_ride* ride, ui
*
* rct2: 0x00691CD1
*/
static void peep_choose_seat_from_car(rct_peep* peep, rct_ride* ride, rct_vehicle* vehicle){
static void peep_choose_seat_from_car(rct_peep* peep, Ride* ride, rct_vehicle* vehicle){
uint8 chosen_seat = vehicle->next_free_seat;
if (ride->mode == RIDE_MODE_FORWARD_ROTATION ||
@ -2391,7 +2391,7 @@ static void peep_choose_seat_from_car(rct_peep* peep, rct_ride* ride, rct_vehicl
*
* rct2: 0x00691D27
*/
static void peep_go_to_ride_entrance(rct_peep* peep, rct_ride* ride){
static void peep_go_to_ride_entrance(rct_peep* peep, Ride* ride){
sint32 x = ride->entrances[peep->current_ride_station].x;
sint32 y = ride->entrances[peep->current_ride_station].y;
sint32 z = ride->station_heights[peep->current_ride_station];
@ -2443,7 +2443,7 @@ static void peep_go_to_ride_entrance(rct_peep* peep, rct_ride* ride){
* rct2: 0x00691A3B
*/
static void peep_update_ride_sub_state_0(rct_peep* peep){
rct_ride* ride = get_ride(peep->current_ride);
Ride* ride = get_ride(peep->current_ride);
if (peep->destination_tolerence != 0){
invalidate_sprite_2((rct_sprite*)peep);
@ -2619,7 +2619,7 @@ static const rct_xy16 _981FD4[] = {
static void peep_update_ride_sub_state_1(rct_peep* peep){
sint16 x, y, z, xy_distance;
rct_ride* ride = get_ride(peep->current_ride);
Ride* ride = get_ride(peep->current_ride);
rct_ride_entry* ride_entry = get_ride_entry(ride->subtype);
if (peep_update_action(&x, &y, &xy_distance, peep))
@ -2832,7 +2832,7 @@ static void peep_update_ride_sub_state_1(rct_peep* peep){
*
* rct2: 0x0069321D
*/
static void peep_go_to_ride_exit(rct_peep* peep, rct_ride* ride, sint16 x, sint16 y, sint16 z, uint8 exit_direction){
static void peep_go_to_ride_exit(rct_peep* peep, Ride* ride, sint16 x, sint16 y, sint16 z, uint8 exit_direction){
z += RideData5[ride->type].z;
sprite_move(x, y, z, (rct_sprite*)peep);
@ -2879,7 +2879,7 @@ static void peep_go_to_ride_exit(rct_peep* peep, rct_ride* ride, sint16 x, sint1
*
* rct2: 0x006920B4
*/
static void peep_update_ride_sub_state_2_enter_ride(rct_peep* peep, rct_ride* ride)
static void peep_update_ride_sub_state_2_enter_ride(rct_peep* peep, Ride* ride)
{
money16 ridePrice = ride_get_price(ride);
if (ridePrice != 0) {
@ -2936,7 +2936,7 @@ static void peep_update_ride_sub_state_2_enter_ride(rct_peep* peep, rct_ride* ri
*
* rct2: 0x00691FD4
*/
static void peep_update_ride_sub_state_2_rejoin_queue(rct_peep* peep, rct_ride* ride)
static void peep_update_ride_sub_state_2_rejoin_queue(rct_peep* peep, Ride* ride)
{
sint16 x, y, z;
x = ride->entrances[peep->current_ride_station].x;
@ -2974,7 +2974,7 @@ static void peep_update_ride_sub_state_2_rejoin_queue(rct_peep* peep, rct_ride*
* separate functions.
*/
static void peep_update_ride_sub_state_2(rct_peep* peep){
rct_ride* ride = get_ride(peep->current_ride);
Ride* ride = get_ride(peep->current_ride);
if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_NO_VEHICLES)){
if (ride->status != RIDE_STATUS_OPEN ||
@ -3059,7 +3059,7 @@ static void peep_update_ride_sub_state_2(rct_peep* peep){
}
static void peep_update_ride_sub_state_5(rct_peep* peep){
rct_ride* ride = get_ride(peep->current_ride);
Ride* ride = get_ride(peep->current_ride);
rct_vehicle* vehicle = GET_VEHICLE(ride->vehicles[peep->current_train]);
for (sint32 i = peep->current_car; i != 0; --i){
@ -3116,7 +3116,7 @@ static void peep_update_ride_sub_state_5(rct_peep* peep){
* rct2: 0x00693028
*/
static void peep_update_ride_sub_state_7(rct_peep* peep){
rct_ride* ride = get_ride(peep->current_ride);
Ride* ride = get_ride(peep->current_ride);
rct_vehicle* vehicle = GET_VEHICLE(ride->vehicles[peep->current_train]);
uint8 ride_station = vehicle->current_station;
@ -3320,7 +3320,7 @@ static void peep_update_ride_sub_state_7(rct_peep* peep){
* rct2: 0x0069376A
*/
static void peep_update_ride_prepare_for_state_9(rct_peep* peep){
rct_ride* ride = get_ride(peep->current_ride);
Ride* ride = get_ride(peep->current_ride);
sint16 x = ride->exits[peep->current_ride_station].x;
sint16 y = ride->exits[peep->current_ride_station].y;
@ -3382,7 +3382,7 @@ static void peep_update_ride_sub_state_8(rct_peep* peep){
*/
static void peep_update_ride_sub_state_9(rct_peep* peep){
sint16 x, y, xy_distance;
rct_ride* ride = get_ride(peep->current_ride);
Ride* ride = get_ride(peep->current_ride);
if (peep_update_action(&x, &y, &xy_distance, peep)){
invalidate_sprite_2((rct_sprite*)peep);
@ -3416,7 +3416,7 @@ static void peep_update_ride_sub_state_9(rct_peep* peep){
*/
static void peep_update_ride_sub_state_12(rct_peep* peep){
sint16 x, y, xy_distance;
rct_ride* ride = get_ride(peep->current_ride);
Ride* ride = get_ride(peep->current_ride);
if (peep_update_action(&x, &y, &xy_distance, peep)){
sint16 z;
@ -3480,7 +3480,7 @@ static void peep_update_ride_sub_state_12(rct_peep* peep){
*/
static void peep_update_ride_sub_state_13(rct_peep* peep){
sint16 x, y, xy_distance;
rct_ride* ride = get_ride(peep->current_ride);
Ride* ride = get_ride(peep->current_ride);
if (peep_update_action(&x, &y, &xy_distance, peep)){
sint16 z;
@ -3580,7 +3580,7 @@ static void peep_update_ride_sub_state_13(rct_peep* peep){
*/
static void peep_update_ride_sub_state_14(rct_peep* peep){
sint16 x, y, xy_distance;
rct_ride* ride = get_ride(peep->current_ride);
Ride* ride = get_ride(peep->current_ride);
if (peep_update_action(&x, &y, &xy_distance, peep)){
invalidate_sprite_2((rct_sprite*)peep);
@ -3674,7 +3674,7 @@ static const rct_xy16 _981F1C[] = {
* rct2: 0x00692D83
*/
static void peep_update_ride_sub_state_15(rct_peep* peep){
rct_ride* ride = get_ride(peep->current_ride);
Ride* ride = get_ride(peep->current_ride);
if (ride->type != RIDE_TYPE_SPIRAL_SLIDE)
return;
@ -3772,7 +3772,7 @@ static void peep_update_ride_sub_state_16(rct_peep* peep){
return;
}
rct_ride* ride = get_ride(peep->current_ride);
Ride* ride = get_ride(peep->current_ride);
if ((peep->var_37 & 0x3) != 0){
if ((peep->var_37 & 0x3) == 3){
@ -3859,7 +3859,7 @@ static void peep_update_ride_sub_state_17(rct_peep* peep){
return;
}
rct_ride* ride = get_ride(peep->current_ride);
Ride* ride = get_ride(peep->current_ride);
if (peep->var_37 == 16){
peep_update_ride_prepare_for_state_9(peep);
return;
@ -3993,7 +3993,7 @@ static void peep_update_ride_sub_state_17(rct_peep* peep){
*/
static void peep_update_ride_sub_state_18(rct_peep* peep){
sint16 x, y, xy_distance;
rct_ride* ride = get_ride(peep->current_ride);
Ride* ride = get_ride(peep->current_ride);
if (peep_update_action(&x, &y, &xy_distance, peep)){
invalidate_sprite_2((rct_sprite*)peep);
@ -4065,7 +4065,7 @@ static void peep_update_ride_sub_state_19(rct_peep* peep){
*/
static void peep_update_ride_sub_state_20(rct_peep* peep){
sint16 x, y;
rct_ride* ride = get_ride(peep->current_ride);
Ride* ride = get_ride(peep->current_ride);
if (ride->type == RIDE_TYPE_FIRST_AID){
if (peep->nausea <= 35){
@ -4134,7 +4134,7 @@ static void peep_update_ride_sub_state_21(rct_peep* peep){
peep->state = PEEP_STATE_WALKING;
peep_window_state_update(peep);
rct_ride* ride = get_ride(peep->current_ride);
Ride* ride = get_ride(peep->current_ride);
ride->total_customers++;
ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_CUSTOMER;
@ -4247,7 +4247,7 @@ static const uint32 loc_992A18[9] = {
* Also used by inspecting.
*/
static void peep_update_fixing(sint32 steps, rct_peep* peep){
rct_ride* ride = get_ride(peep->current_ride);
Ride* ride = get_ride(peep->current_ride);
if (ride->type == RIDE_TYPE_NULL)
{
@ -4342,7 +4342,7 @@ static void peep_update_fixing(sint32 steps, rct_peep* peep){
/**
* rct2: 0x006C0EEC
*/
static bool peep_update_fixing_sub_state_0(rct_ride *ride) {
static bool peep_update_fixing_sub_state_0(Ride *ride) {
ride->mechanic_status = RIDE_MECHANIC_STATUS_FIXING;
ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAINTENANCE;
@ -4352,7 +4352,7 @@ static bool peep_update_fixing_sub_state_0(rct_ride *ride) {
/**
* rct2: 0x006C0F09
*/
static bool peep_update_fixing_sub_state_1(bool firstRun, rct_peep *peep, rct_ride *ride) {
static bool peep_update_fixing_sub_state_1(bool firstRun, rct_peep *peep, Ride *ride) {
sint16 x, y, tmp_xy_distance;
if (!firstRun) {
@ -4401,7 +4401,7 @@ static bool peep_update_fixing_sub_state_1(bool firstRun, rct_peep *peep, rct_ri
/**
* rct2: 0x006C0FD3
*/
static bool peep_update_fixing_sub_state_2345(bool firstRun, rct_peep *peep, rct_ride *ride) {
static bool peep_update_fixing_sub_state_2345(bool firstRun, rct_peep *peep, Ride *ride) {
sint16 tmp_x, tmp_y, tmp_distance;
if (!firstRun) {
@ -4438,7 +4438,7 @@ static bool peep_update_fixing_sub_state_2345(bool firstRun, rct_peep *peep, rct
/**
* rct2: 0x006C107B
*/
static bool peep_update_fixing_sub_state_6(bool firstRun, rct_peep *peep, rct_ride *ride) {
static bool peep_update_fixing_sub_state_6(bool firstRun, rct_peep *peep, Ride *ride) {
sint16 tmp_x, tmp_y, tmp_distance;
if (!firstRun) {
@ -4481,7 +4481,7 @@ static const rct_xy16 _992A3C[] = {
/**
* rct2: 0x006C1114
*/
static bool peep_update_fixing_sub_state_7(bool firstRun, rct_peep *peep, rct_ride *ride) {
static bool peep_update_fixing_sub_state_7(bool firstRun, rct_peep *peep, Ride *ride) {
sint16 x, y, tmp_distance;
if (!firstRun) {
@ -4561,7 +4561,7 @@ static bool peep_update_fixing_sub_state_8(bool firstRun, rct_peep *peep) {
/**
* rct2: 0x006C1239
*/
static bool peep_update_fixing_sub_state_9(bool firstRun, rct_peep *peep, rct_ride *ride) {
static bool peep_update_fixing_sub_state_9(bool firstRun, rct_peep *peep, Ride *ride) {
sint16 x, y, tmp_xy_distance;
if (!firstRun) {
@ -4636,7 +4636,7 @@ static bool peep_update_fixing_sub_state_9(bool firstRun, rct_peep *peep, rct_ri
/**
* rct2: 0x006C1368
*/
static bool peep_update_fixing_sub_state_10(bool firstRun, rct_peep *peep, rct_ride *ride) {
static bool peep_update_fixing_sub_state_10(bool firstRun, rct_peep *peep, Ride *ride) {
sint16 tmp_x, tmp_y, tmp_xy_distance;
if (!firstRun) {
@ -4666,7 +4666,7 @@ static bool peep_update_fixing_sub_state_10(bool firstRun, rct_peep *peep, rct_r
/**
* rct2: 0x006C13CE
*/
static bool peep_update_fixing_sub_state_11(bool firstRun, rct_peep *peep, rct_ride *ride) {
static bool peep_update_fixing_sub_state_11(bool firstRun, rct_peep *peep, Ride *ride) {
sint16 tmp_x, tmp_y, tmp_xy_distance;
if (!firstRun) {
@ -4704,7 +4704,7 @@ static bool peep_update_fixing_sub_state_11(bool firstRun, rct_peep *peep, rct_r
/**
* rct2: 0x006C1474
*/
static bool peep_update_fixing_sub_state_12(bool firstRun, rct_peep *peep, rct_ride *ride) {
static bool peep_update_fixing_sub_state_12(bool firstRun, rct_peep *peep, Ride *ride) {
sint16 x, y, tmp_xy_distance;
if (!firstRun) {
@ -4747,7 +4747,7 @@ static bool peep_update_fixing_sub_state_12(bool firstRun, rct_peep *peep, rct_r
/**
* rct2: 0x006C1504
*/
static bool peep_update_fixing_sub_state_13(bool firstRun, sint32 steps, rct_peep *peep, rct_ride *ride) {
static bool peep_update_fixing_sub_state_13(bool firstRun, sint32 steps, rct_peep *peep, Ride *ride) {
sint16 tmp_x, tmp_y, tmp_xy_distance;
if (!firstRun) {
@ -4785,7 +4785,7 @@ static bool peep_update_fixing_sub_state_13(bool firstRun, sint32 steps, rct_pee
/**
* rct2: 0x006C157E
*/
static bool peep_update_fixing_sub_state_14(bool firstRun, rct_peep *peep, rct_ride *ride) {
static bool peep_update_fixing_sub_state_14(bool firstRun, rct_peep *peep, Ride *ride) {
sint16 x, y, xy_distance;
if (!firstRun) {
@ -4841,7 +4841,7 @@ static bool peep_update_fixing_sub_state_14(bool firstRun, rct_peep *peep, rct_r
* rct2: 0x6B7588
*/
static void peep_update_ride_inspected(sint32 rideIndex) {
rct_ride *ride = get_ride(rideIndex);
Ride *ride = get_ride(rideIndex);
ride->lifecycle_flags &= ~RIDE_LIFECYCLE_DUE_INSPECTION;
ride->reliability += ((100 - ride->reliability_percentage) / 4) * (scenario_rand() & 0xFF);
@ -4858,7 +4858,7 @@ static void peep_update_queuing(rct_peep* peep){
remove_peep_from_queue(peep);
return;
}
rct_ride* ride = get_ride(peep->current_ride);
Ride* ride = get_ride(peep->current_ride);
if (ride->status == RIDE_STATUS_CLOSED || ride->status == RIDE_STATUS_TESTING){
remove_peep_from_queue(peep);
peep_decrement_num_riders(peep);
@ -5600,7 +5600,7 @@ static void peep_update_buying(rct_peep* peep)
{
if (!checkForPath(peep))return;
rct_ride* ride = get_ride(peep->current_ride);
Ride* ride = get_ride(peep->current_ride);
if (ride->type == RIDE_TYPE_NULL || ride->status != RIDE_STATUS_OPEN){
peep_decrement_num_riders(peep);
peep->state = PEEP_STATE_FALLING;
@ -5879,7 +5879,7 @@ static void peep_update_using_bin(rct_peep* peep){
* rct2: 0x006C16D7
*/
static void peep_update_heading_to_inspect(rct_peep* peep){
rct_ride* ride = get_ride(peep->current_ride);
Ride* ride = get_ride(peep->current_ride);
if (ride->type == RIDE_TYPE_NULL){
peep_decrement_num_riders(peep);
@ -5996,7 +5996,7 @@ static void peep_update_heading_to_inspect(rct_peep* peep){
* rct2: 0x006C0CB8
*/
static void peep_update_answering(rct_peep* peep){
rct_ride* ride = get_ride(peep->current_ride);
Ride* ride = get_ride(peep->current_ride);
if (ride->type == RIDE_TYPE_NULL ||
ride->mechanic_status != RIDE_MECHANIC_STATUS_HEADING){
@ -6795,7 +6795,7 @@ static void peep_update(rct_peep *peep)
void peep_problem_warnings_update()
{
rct_peep* peep;
rct_ride* ride;
Ride* ride;
uint16 spriteIndex;
uint16 guests_in_park = gNumGuestsInPark;
sint32 hunger_counter = 0, lost_counter = 0, noexit_counter = 0, thirst_counter = 0,
@ -7316,7 +7316,7 @@ rct_peep *peep_generate(sint32 x, sint32 y, sint32 z)
* argument_2 (edx)
*/
void get_arguments_from_action(rct_peep* peep, uint32 *argument_1, uint32* argument_2){
rct_ride *ride;
Ride *ride;
switch (peep->state){
case PEEP_STATE_FALLING:
@ -7452,7 +7452,7 @@ void peep_thought_set_format_args(rct_peep_thought *thought)
uint8 flags = PeepThoughtToActionMap[thought->type].flags;
if (flags & 1) {
rct_ride *ride = get_ride(thought->item);
Ride *ride = get_ride(thought->item);
set_format_arg(2, rct_string_id, ride->name);
set_format_arg(4, uint32, ride->name_arguments);
} else if (flags & 2) {
@ -8036,7 +8036,7 @@ static sint32 peep_interact_with_entrance(rct_peep* peep, sint16 x, sint16 y, rc
peep->action_sprite_image_offset = _unk_F1AEF0;
peep->interaction_ride_index = rideIndex;
rct_ride* ride = get_ride(rideIndex);
Ride* ride = get_ride(rideIndex);
uint16 previous_last = ride->last_peep_in_queue[stationNum];
ride->last_peep_in_queue[stationNum] = peep->sprite_index;
peep->next_in_queue = previous_last;
@ -8424,7 +8424,7 @@ static sint32 peep_interact_with_path(rct_peep* peep, sint16 x, sint16 y, rct_ma
// Peep has decided to go on the ride at the queue.
peep->interaction_ride_index = rideIndex;
rct_ride* ride = get_ride(rideIndex);
Ride* ride = get_ride(rideIndex);
// Add the peep to the ride queue.
uint16 old_last_peep = ride->last_peep_in_queue[stationNum];
@ -8472,7 +8472,7 @@ static sint32 peep_interact_with_path(rct_peep* peep, sint16 x, sint16 y, rct_ma
*/
static sint32 peep_interact_with_shop(rct_peep* peep, sint16 x, sint16 y, rct_map_element* map_element){
uint8 rideIndex = map_element->properties.track.ride_index;
rct_ride* ride = get_ride(rideIndex);
Ride* ride = get_ride(rideIndex);
if (!ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_IS_SHOP))
return 0;
@ -8772,7 +8772,7 @@ static uint8 footpath_element_dest_in_dir(
case MAP_ELEMENT_TYPE_TRACK:
if (z != mapElement->base_height) continue;
sint32 rideIndex = mapElement->properties.track.ride_index;
rct_ride *ride = get_ride(rideIndex);
Ride *ride = get_ride(rideIndex);
if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_IS_SHOP)) {
*outRideIndex = rideIndex;
return PATH_SEARCH_SHOP_ENTRANCE;
@ -9085,7 +9085,7 @@ static void peep_pathfind_heuristic_search(sint16 x, sint16 y, uint8 z, rct_peep
/* For peeps heading for a shop, the goal is the shop
* tile. */
rideIndex = mapElement->properties.track.ride_index;
rct_ride *ride = get_ride(rideIndex);
Ride *ride = get_ride(rideIndex);
if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_IS_SHOP)) {
found = true;
searchResult = PATH_SEARCH_SHOP_ENTRANCE;
@ -10332,7 +10332,7 @@ static sint32 guest_path_finding(rct_peep* peep)
// Peep is heading for a ride.
uint8 rideIndex = peep->guest_heading_to_ride_id;
rct_ride* ride = get_ride(rideIndex);
Ride* ride = get_ride(rideIndex);
if (ride->status != RIDE_STATUS_OPEN) {
#if defined(DEBUG_LEVEL_1) && DEBUG_LEVEL_1
@ -10591,7 +10591,7 @@ static void peep_spend_money(rct_peep *peep, money16 *peep_expend_type, money32
static void peep_set_has_ridden(rct_peep *peep, sint32 rideIndex)
{
peep->rides_been_on[rideIndex / 8] |= 1 << (rideIndex % 8);
rct_ride *ride = get_ride(rideIndex);
Ride *ride = get_ride(rideIndex);
peep_set_has_ridden_ride_type(peep, ride->type);
}
@ -10617,7 +10617,7 @@ static bool peep_has_ridden_ride_type(rct_peep *peep, sint32 rideType)
*/
static void peep_on_enter_ride(rct_peep *peep, sint32 rideIndex)
{
rct_ride *ride = get_ride(rideIndex);
Ride *ride = get_ride(rideIndex);
// Calculate how satisfying the ride is for the peep. Can range from -140 to +105.
sint16 satisfaction = peep_calculate_ride_satisfaction(peep, ride);
@ -10653,7 +10653,7 @@ static void peep_on_enter_ride(rct_peep *peep, sint32 rideIndex)
* the ride becomes the peep's favourite. (This doesn't happen right away, but will be updated once the peep
* exits the ride.)
*/
static void peep_update_favourite_ride(rct_peep *peep, rct_ride *ride)
static void peep_update_favourite_ride(rct_peep *peep, Ride *ride)
{
peep->peep_flags &= ~PEEP_FLAGS_RIDE_SHOULD_BE_MARKED_AS_FAVOURITE;
uint8 peepRideRating = clamp(0, (ride->excitement / 4) + peep->happiness, PEEP_MAX_HAPPINESS);
@ -10666,7 +10666,7 @@ static void peep_update_favourite_ride(rct_peep *peep, rct_ride *ride)
}
/* rct2: 0x00695555 */
static sint16 peep_calculate_ride_value_satisfaction(rct_peep* peep, rct_ride* ride) {
static sint16 peep_calculate_ride_value_satisfaction(rct_peep* peep, Ride* ride) {
if (gParkFlags & PARK_FLAGS_NO_MONEY){
return -30;
}
@ -10693,7 +10693,7 @@ static sint16 peep_calculate_ride_value_satisfaction(rct_peep* peep, rct_ride* r
* of the ride fall exactly within the peep's preferences, but lower scores can still be achieved
* if the peep's happiness is enough to offset it.
*/
static sint16 peep_calculate_ride_intensity_nausea_satisfaction(rct_peep * peep, rct_ride * ride)
static sint16 peep_calculate_ride_intensity_nausea_satisfaction(rct_peep * peep, Ride * ride)
{
if (!ride_has_ratings(ride)) {
return 70;
@ -10774,7 +10774,7 @@ static sint16 peep_calculate_ride_intensity_nausea_satisfaction(rct_peep * peep,
* - How long the peep was waiting in the queue
* - If the peep has been on the ride before, or on another ride of the same type
*/
static sint16 peep_calculate_ride_satisfaction(rct_peep *peep, rct_ride *ride)
static sint16 peep_calculate_ride_satisfaction(rct_peep *peep, Ride *ride)
{
sint16 satisfaction = peep_calculate_ride_value_satisfaction(peep, ride);
satisfaction += peep_calculate_ride_intensity_nausea_satisfaction(peep, ride);
@ -10807,7 +10807,7 @@ static sint16 peep_calculate_ride_satisfaction(rct_peep *peep, rct_ride *ride)
* - How hungry the peep is (+0% nausea at 50% hunger up to +100% nausea at 100% hunger)
* - The peep's nausea tolerance (Final modifier: none: 100%, low: 50%, average: 25%, high: 12.5%)
*/
static void peep_update_ride_nausea_growth(rct_peep *peep, rct_ride *ride)
static void peep_update_ride_nausea_growth(rct_peep *peep, Ride *ride)
{
uint32 nauseaMultiplier = clamp(64, 256 - peep->happiness_target, 200);
uint32 nauseaGrowthRateChange = (ride->nausea * nauseaMultiplier) / 512;
@ -10816,7 +10816,7 @@ static void peep_update_ride_nausea_growth(rct_peep *peep, rct_ride *ride)
peep->nausea_target = (uint8)clamp(0, peep->nausea_target + nauseaGrowthRateChange, 255);
}
static bool peep_should_go_on_ride_again(rct_peep *peep, rct_ride *ride)
static bool peep_should_go_on_ride_again(rct_peep *peep, Ride *ride)
{
if (!ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_PEEP_WILL_RIDE_AGAIN)) return false;
if (!ride_has_ratings(ride)) return false;
@ -10845,7 +10845,7 @@ static bool peep_should_preferred_intensity_increase(rct_peep *peep)
return (peep_rand() & 0xFF) >= peep->intensity;
}
static bool peep_really_liked_ride(rct_peep *peep, rct_ride *ride)
static bool peep_really_liked_ride(rct_peep *peep, Ride *ride)
{
if (peep->happiness < 215) return false;
if (peep->nausea > 120) return false;
@ -10860,7 +10860,7 @@ static bool peep_really_liked_ride(rct_peep *peep, rct_ride *ride)
*/
static void peep_on_exit_ride(rct_peep *peep, sint32 rideIndex)
{
rct_ride *ride = get_ride(rideIndex);
Ride *ride = get_ride(rideIndex);
if (peep->peep_flags & PEEP_FLAGS_RIDE_SHOULD_BE_MARKED_AS_FAVOURITE) {
peep->peep_flags &= ~PEEP_FLAGS_RIDE_SHOULD_BE_MARKED_AS_FAVOURITE;
@ -10934,7 +10934,7 @@ static void peep_on_enter_or_exit_ride(rct_peep *peep, sint32 rideIndex, sint32
*/
static bool peep_decide_and_buy_item(rct_peep *peep, sint32 rideIndex, sint32 shopItem, money32 price)
{
rct_ride* ride = get_ride(rideIndex);
Ride* ride = get_ride(rideIndex);
money32 value;
bool has_voucher = false;
@ -11178,7 +11178,7 @@ static bool peep_should_use_cash_machine(rct_peep *peep, sint32 rideIndex)
if (115 + (peep_rand() % 128) > peep->happiness) return false;
if (peep->energy < 80) return false;
rct_ride *ride = get_ride(rideIndex);
Ride *ride = get_ride(rideIndex);
ride_update_satisfaction(ride, peep->happiness >> 6);
ride->cur_num_customers++;
ride->total_customers++;
@ -11342,7 +11342,7 @@ static void peep_easter_egg_peep_interactions(rct_peep *peep)
* @return (CF)
*/
static bool peep_should_watch_ride(rct_map_element *mapElement) {
rct_ride *ride = get_ride(mapElement->properties.track.ride_index);
Ride *ride = get_ride(mapElement->properties.track.ride_index);
// Ghosts are purely this-client-side and should not cause any interaction,
// as that may lead to a desync.
@ -11647,7 +11647,7 @@ static bool peep_find_ride_to_look_at(rct_peep *peep, uint8 edge, uint8 *rideToV
}
bool loc_690FD0(rct_peep *peep, uint8 *rideToView, uint8 *rideSeatToView, rct_map_element *esi) {
rct_ride *ride = get_ride(esi->properties.track.ride_index);
Ride *ride = get_ride(esi->properties.track.ride_index);
*rideToView = esi->properties.track.ride_index;
if (ride->excitement == RIDE_RATING_UNDEFINED) {
@ -11720,7 +11720,7 @@ static void peep_reset_ride_heading(rct_peep *peep)
*/
static bool peep_should_go_on_ride(rct_peep *peep, sint32 rideIndex, sint32 entranceNum, sint32 flags)
{
rct_ride *ride = get_ride(rideIndex);
Ride *ride = get_ride(rideIndex);
// Indicates if the peep is about to enter a queue (as opposed to entering an entrance directly from a path)
bool peepAtQueue = flags & PEEP_RIDE_DECISION_AT_QUEUE;
@ -11968,7 +11968,7 @@ static bool peep_should_go_on_ride(rct_peep *peep, sint32 rideIndex, sint32 entr
static void peep_ride_is_too_intense(rct_peep *peep, sint32 rideIndex, bool peepAtRide)
{
rct_ride *ride = get_ride(rideIndex);
Ride *ride = get_ride(rideIndex);
if (peepAtRide) {
peep_insert_new_thought(peep, PEEP_THOUGHT_TYPE_INTENSE, rideIndex);
@ -11999,7 +11999,7 @@ static void peep_chose_not_to_go_on_ride(rct_peep *peep, sint32 rideIndex, bool
*/
static void peep_tried_to_enter_full_queue(rct_peep *peep, sint32 rideIndex)
{
rct_ride *ride = get_ride(rideIndex);
Ride *ride = get_ride(rideIndex);
ride->lifecycle_flags |= RIDE_LIFECYCLE_QUEUE_FULL;
peep->previous_ride = rideIndex;
@ -12012,7 +12012,7 @@ static void peep_tried_to_enter_full_queue(rct_peep *peep, sint32 rideIndex)
static bool peep_should_go_to_shop(rct_peep *peep, sint32 rideIndex, bool peepAtShop)
{
rct_ride *ride = get_ride(rideIndex);
Ride *ride = get_ride(rideIndex);
// Peeps won't go to the same shop twice in a row.
if (rideIndex == peep->previous_ride) {
@ -12077,7 +12077,7 @@ static bool peep_should_go_to_shop(rct_peep *peep, sint32 rideIndex, bool peepAt
*/
static void peep_pick_ride_to_go_on(rct_peep *peep)
{
rct_ride *ride;
Ride *ride;
if (peep->state != PEEP_STATE_WALKING) return;
if (peep->guest_heading_to_ride_id != 255) return;
@ -12184,7 +12184,7 @@ static void peep_pick_ride_to_go_on(rct_peep *peep)
*/
static void peep_head_for_nearest_ride_type(rct_peep *peep, sint32 rideType)
{
rct_ride *ride;
Ride *ride;
if (peep->state != PEEP_STATE_SITTING && peep->state != PEEP_STATE_WATCHING && peep->state != PEEP_STATE_WALKING) {
return;
@ -12287,7 +12287,7 @@ static void peep_head_for_nearest_ride_type(rct_peep *peep, sint32 rideType)
*/
static void peep_head_for_nearest_ride_with_flags(rct_peep *peep, sint32 rideTypeFlags)
{
rct_ride *ride;
Ride *ride;
if (peep->state != PEEP_STATE_SITTING && peep->state != PEEP_STATE_WATCHING && peep->state != PEEP_STATE_WALKING) {
return;

4
src/openrct2/peep/staff.c
View File

@ -1159,7 +1159,7 @@ static uint8 staff_mechanic_direction_surface(rct_peep* peep) {
if ((peep->state == PEEP_STATE_ANSWERING || peep->state == PEEP_STATE_HEADING_TO_INSPECTION) &&
scenario_rand() & 1) {
rct_ride* ride = get_ride(peep->current_ride);
Ride* ride = get_ride(peep->current_ride);
rct_xy8 location = ride->exits[peep->current_ride_station];
if (location.xy == RCT_XY8_UNDEFINED) {
@ -1243,7 +1243,7 @@ static uint8 staff_mechanic_direction_path(rct_peep* peep, uint8 validDirections
// Mechanic is heading to ride (either broken down or for inspection).
if (peep->state == PEEP_STATE_ANSWERING || peep->state == PEEP_STATE_HEADING_TO_INSPECTION) {
rct_ride* ride = get_ride(peep->current_ride);
Ride* ride = get_ride(peep->current_ride);
uint8 z = ride->station_heights[peep->current_ride_station];
gPeepPathFindGoalPosition.z = z;

16
src/openrct2/rct1/S4Importer.cpp
View File

@ -682,9 +682,9 @@ private:
}
}
void ImportRide(rct_ride * dst, rct1_ride * src)
void ImportRide(Ride * dst, rct1_ride * src)
{
memset(dst, 0, sizeof(rct_ride));
memset(dst, 0, sizeof(Ride));
// This is a peculiarity of this exact version number, which only Heide-Park seems to use.
if (_s4.game_version == 110018 && src->type == RCT1_RIDE_TYPE_INVERTED_ROLLER_COASTER)
@ -920,7 +920,7 @@ private:
dst->music_tune_id = 255;
}
void SetRideColourScheme(rct_ride * dst, rct1_ride * src)
void SetRideColourScheme(Ride * dst, rct1_ride * src)
{
// Colours
dst->colour_scheme_type = src->colour_scheme;
@ -1009,7 +1009,7 @@ private:
void FixRideVehicleLinks(const uint16 * spriteIndexMap)
{
uint8 i;
rct_ride * ride;
Ride * ride;
FOR_ALL_RIDES(i, ride)
{
for (uint8 j = 0; j < Util::CountOf(ride->vehicles); j++)
@ -1088,7 +1088,7 @@ private:
void ImportVehicle(rct_vehicle * dst, rct1_vehicle * src)
{
rct_ride * ride = get_ride(src->ride);
Ride * ride = get_ride(src->ride);
uint8 vehicleEntryIndex = RCT1::GetVehicleSubEntryIndex(src->vehicle_type);
dst->sprite_identifier = SPRITE_IDENTIFIER_VEHICLE;
@ -1282,7 +1282,7 @@ private:
}
int i;
rct_ride *ride;
Ride *ride;
rct_peep *peep;
FOR_ALL_RIDES(i, ride)
@ -1483,7 +1483,7 @@ private:
}
}
void FixRidePeepLinks(rct_ride * ride, const uint16 * spriteIndexMap)
void FixRidePeepLinks(Ride * ride, const uint16 * spriteIndexMap)
{
for (sint32 i = 0; i < RCT12_MAX_STATIONS_PER_RIDE; i++)
{
@ -2676,7 +2676,7 @@ private:
}
uint8 rideIndex = mapElement->properties.track.ride_index;
rct_ride * ride = get_ride(rideIndex);
Ride * ride = get_ride(rideIndex);
ride->num_block_brakes++;
}
}

217
src/openrct2/rct2.h
View File

@ -17,7 +17,10 @@
#ifndef _RCT2_H_
#define _RCT2_H_
#include "ride/ride_ratings.h"
#include "ride/vehicle.h"
#include "common.h"
#include "rct12.h"
#define RCT2_MAX_RIDES_IN_PARK 255
#define RCT2_MAX_STAFF 200
@ -42,6 +45,220 @@ typedef struct rct2_install_info {
#pragma pack(push, 1)
/**
* Ride structure.
* size: 0x0260
*/
typedef struct rct2_ride {
uint8 type; // 0x000
// pointer to static info. for example, wild mouse type is 0x36, subtype is
// 0x4c.
uint8 subtype; // 0x001
uint16 pad_002; // 0x002
uint8 mode; // 0x004
uint8 colour_scheme_type; // 0x005
rct_vehicle_colour vehicle_colours[RCT2_MAX_CARS_PER_TRAIN]; // 0x006
uint8 pad_046[0x03]; // 0x046, Used to be track colours in RCT1 without expansions
// 0 = closed, 1 = open, 2 = test
uint8 status; // 0x049
rct_string_id name; // 0x04A
union {
uint32 name_arguments; // 0x04C
struct {
rct_string_id name_arguments_type_name; // 0x04C
uint16 name_arguments_number; // 0x04E
};
};
rct_xy8 overall_view; // 0x050
rct_xy8 station_starts[RCT12_MAX_STATIONS_PER_RIDE]; // 0x052
uint8 station_heights[RCT12_MAX_STATIONS_PER_RIDE]; // 0x05A
uint8 station_length[RCT12_MAX_STATIONS_PER_RIDE]; // 0x05E
uint8 station_depart[RCT12_MAX_STATIONS_PER_RIDE]; // 0x062
// ride->vehicle index for current train waiting for passengers
// at station
uint8 train_at_station[RCT12_MAX_STATIONS_PER_RIDE]; // 0x066
rct_xy8 entrances[RCT12_MAX_STATIONS_PER_RIDE]; // 0x06A
rct_xy8 exits[RCT12_MAX_STATIONS_PER_RIDE]; // 0x072
uint16 last_peep_in_queue[RCT12_MAX_STATIONS_PER_RIDE]; // 0x07A
uint8 pad_082[RCT12_MAX_STATIONS_PER_RIDE]; // 0x082, Used to be number of peeps in queue in RCT1, but this has moved.
uint16 vehicles[RCT2_MAX_VEHICLES_PER_RIDE]; // 0x086, Points to the first car in the train
uint8 depart_flags; // 0x0C6
// Not sure if these should be uint or sint.
uint8 num_stations; // 0x0C7
uint8 num_vehicles; // 0x0C8
uint8 num_cars_per_train; // 0x0C9
uint8 proposed_num_vehicles; // 0x0CA
uint8 proposed_num_cars_per_train; // 0x0CB
uint8 max_trains; // 0x0CC
uint8 min_max_cars_per_train; // 0x0CD
uint8 min_waiting_time; // 0x0CE
uint8 max_waiting_time; // 0x0CF
union {
uint8 operation_option; // 0x0D0
uint8 time_limit; // 0x0D0
uint8 num_laps; // 0x0D0
uint8 launch_speed; // 0x0D0
uint8 speed; // 0x0D0
uint8 rotations; // 0x0D0
};
uint8 boat_hire_return_direction; // 0x0D1
rct_xy8 boat_hire_return_position; // 0x0D2
uint8 measurement_index; // 0x0D4
// bits 0 through 4 are the number of helix sections
// bit 5: spinning tunnel, water splash, or rapids
// bit 6: log reverser, waterfall
// bit 7: whirlpool
uint8 special_track_elements; // 0x0D5
uint8 pad_0D6[2]; // 0x0D6
// Divide this value by 29127 to get the human-readable max speed
// (in RCT2, display_speed = (max_speed * 9) >> 18)
sint32 max_speed; // 0x0D8
sint32 average_speed; // 0x0DC
uint8 current_test_segment; // 0x0E0
uint8 average_speed_test_timeout; // 0x0E1
uint8 pad_0E2[0x2]; // 0x0E2
sint32 length[RCT12_MAX_STATIONS_PER_RIDE]; // 0x0E4
uint16 time[RCT12_MAX_STATIONS_PER_RIDE]; // 0x0F4
fixed16_2dp max_positive_vertical_g; // 0x0FC
fixed16_2dp max_negative_vertical_g; // 0x0FE
fixed16_2dp max_lateral_g; // 0x100
fixed16_2dp previous_vertical_g; // 0x102
fixed16_2dp previous_lateral_g; // 0x104
uint8 pad_106[0x2]; // 0x106
uint32 testing_flags; // 0x108
// x y map location of the current track piece during a test
// this is to prevent counting special tracks multiple times
rct_xy8 cur_test_track_location; // 0x10C
// Next 3 variables are related (XXXX XYYY ZZZa aaaa)
uint16 turn_count_default; // 0x10E X = current turn count
uint16 turn_count_banked; // 0x110
uint16 turn_count_sloped; // 0x112 X = number turns > 3 elements
union {
uint8 inversions; // 0x114 (???X XXXX)
uint8 holes; // 0x114 (???X XXXX)
// This is a very rough approximation of how much of the ride is undercover.
// It reaches the maximum value of 7 at about 50% undercover and doesn't increase beyond that.
uint8 sheltered_eighths; // 0x114 (XXX?-????)
};
// Y is number of powered lifts, X is drops
uint8 drops; // 0x115 (YYXX XXXX)
uint8 start_drop_height; // 0x116
uint8 highest_drop_height; // 0x117
sint32 sheltered_length; // 0x118
// Unused always 0? Should affect nausea
uint16 var_11C; // 0x11C
uint8 num_sheltered_sections; // 0x11E (?abY YYYY)
// see cur_test_track_location
uint8 cur_test_track_z; // 0x11F
// Customer counter in the current 960 game tick (about 30 seconds) interval
uint16 cur_num_customers; // 0x120
// Counts ticks to update customer intervals, resets each 960 game ticks.
uint16 num_customers_timeout; // 0x122
// Customer count in the last 10 * 960 game ticks (sliding window)
uint16 num_customers[RCT2_CUSTOMER_HISTORY_SIZE]; // 0x124
money16 price; // 0x138
rct_xy8 chairlift_bullwheel_location[2]; // 0x13A
uint8 chairlift_bullwheel_z[2]; // 0x13E
union {
rating_tuple ratings; // 0x140
struct {
ride_rating excitement; // 0x140
ride_rating intensity; // 0x142
ride_rating nausea; // 0x144
};
};
uint16 value; // 0x146
uint16 chairlift_bullwheel_rotation; // 0x148
uint8 satisfaction; // 0x14A
uint8 satisfaction_time_out; // 0x14B
uint8 satisfaction_next; // 0x14C
// Various flags stating whether a window needs to be refreshed
uint8 window_invalidate_flags; // 0x14D
uint8 pad_14E[0x02]; // 0x14E
uint32 total_customers; // 0x150
money32 total_profit; // 0x154
uint8 popularity; // 0x158
uint8 popularity_time_out; // 0x159 Updated every purchase and ?possibly by time?
uint8 popularity_next; // 0x15A When timeout reached this will be the next popularity
uint8 num_riders; // 0x15B
uint8 music_tune_id; // 0x15C
uint8 slide_in_use; // 0x15D
union {
uint16 slide_peep; // 0x15E
uint16 maze_tiles; // 0x15E
};
uint8 pad_160[0xE]; // 0x160
uint8 slide_peep_t_shirt_colour; // 0x16E
uint8 pad_16F[0x7]; // 0x16F
uint8 spiral_slide_progress; // 0x176
uint8 pad_177[0x9]; // 0x177
sint16 build_date; // 0x180
money16 upkeep_cost; // 0x182
uint16 race_winner; // 0x184
uint8 pad_186[0x02]; // 0x186
uint32 music_position; // 0x188
uint8 breakdown_reason_pending; // 0x18C
uint8 mechanic_status; // 0x18D
uint16 mechanic; // 0x18E
uint8 inspection_station; // 0x190
uint8 broken_vehicle; // 0x191
uint8 broken_car; // 0x192
uint8 breakdown_reason; // 0x193
money16 price_secondary; // 0x194
union
{
struct
{
uint8 reliability_subvalue; // 0x196, 0 - 255, acts like the decimals for reliability_percentage
uint8 reliability_percentage; // 0x197, Starts at 100 and decreases from there.
};
uint16 reliability; // 0x196
};
// Small constant used to increase the unreliability as the game continues,
// making breakdowns more and more likely.
uint8 unreliability_factor; // 0x198
// Range from [0, 100]
uint8 downtime; // 0x199
uint8 inspection_interval; // 0x19A
uint8 last_inspection; // 0x19B
uint8 downtime_history[RCT2_DOWNTIME_HISTORY_SIZE]; // 0x19C
uint32 no_primary_items_sold; // 0x1A4
uint32 no_secondary_items_sold; // 0x1A8
uint8 breakdown_sound_modifier; // 0x1AC
// Used to oscillate the sound when ride breaks down.
// 0 = no change, 255 = max change
uint8 not_fixed_timeout; // 0x1AD
uint8 last_crash_type; // 0x1AE
uint8 connected_message_throttle; // 0x1AF
money32 income_per_hour; // 0x1B0
money32 profit; // 0x1B4
uint8 queue_time[RCT12_MAX_STATIONS_PER_RIDE]; // 0x1B8
uint8 track_colour_main[RCT12_NUM_COLOUR_SCHEMES]; // 0x1BC
uint8 track_colour_additional[RCT12_NUM_COLOUR_SCHEMES]; // 0x1C0
uint8 track_colour_supports[RCT12_NUM_COLOUR_SCHEMES]; // 0x1C4
uint8 music; // 0x1C8
uint8 entrance_style; // 0x1C9
uint16 vehicle_change_timeout; // 0x1CA
uint8 num_block_brakes; // 0x1CC
uint8 lift_hill_speed; // 0x1CD
uint16 guests_favourite; // 0x1CE
uint32 lifecycle_flags; // 0x1D0
uint8 vehicle_colours_extended[RCT2_MAX_CARS_PER_TRAIN]; // 0x1D4
uint16 total_air_time; // 0x1F4
uint8 current_test_station; // 0x1F6
uint8 num_circuits; // 0x1F7
sint16 cable_lift_x; // 0x1F8
sint16 cable_lift_y; // 0x1FA
uint8 cable_lift_z; // 0x1FC
uint8 pad_1FD; // 0x1FD
uint16 cable_lift; // 0x1FE
uint16 queue_length[RCT12_MAX_STATIONS_PER_RIDE]; // 0x200
uint8 pad_208[0x58]; // 0x208
} rct2_ride;
assert_struct_size(rct2_ride, 0x260);
#ifdef __cplusplus
/**

4
src/openrct2/rct2/S6Importer.cpp
View File

@ -440,9 +440,9 @@ public:
}
}
void ImportRide(rct_ride * dst, const rct_ride * src)
void ImportRide(Ride * dst, const rct2_ride * src)
{
memset(dst, 0, sizeof(rct_ride));
memset(dst, 0, sizeof(Ride));
dst->type = src->type;
dst->subtype = src->subtype;

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

@ -1747,7 +1747,7 @@ static bool track_design_place_preview(rct_track_td6 * td6, money32 * cost, uint
return false;
}
rct_ride * ride = get_ride(rideIndex);
Ride * ride = get_ride(rideIndex);
rct_string_id new_ride_name = user_string_allocate(USER_STRING_HIGH_ID_NUMBER | USER_STRING_DUPLICATION_PERMITTED,
"");
if (new_ride_name != 0)
@ -1895,7 +1895,7 @@ static money32 place_track_design(sint16 x, sint16 y, sint16 z, uint8 flags, uin
return MONEY32_UNDEFINED;
}
rct_ride * ride = get_ride(rideIndex);
Ride * ride = get_ride(rideIndex);
if (ride->type == RIDE_TYPE_NULL)
{
log_warning("Invalid game command for track placement, ride id = %d", rideIndex);
@ -2082,7 +2082,7 @@ static money32 place_maze_design(uint8 flags, uint8 rideIndex, uint16 mazeEntry,
}
}
rct_ride * ride = get_ride(rideIndex);
Ride * ride = get_ride(rideIndex);
// Calculate price
money32 price = 0;

6
src/openrct2/ride/cable_lift.c
View File

@ -30,7 +30,7 @@ static void cable_lift_update_arriving(rct_vehicle *vehicle);
rct_vehicle *cable_lift_segment_create(sint32 rideIndex, sint32 x, sint32 y, sint32 z, sint32 direction, uint16 var_44, sint32 remaining_distance, bool head)
{
rct_ride *ride = get_ride(rideIndex);
Ride *ride = get_ride(rideIndex);
rct_vehicle *current = &(create_sprite(1)->vehicle);
current->sprite_identifier = SPRITE_IDENTIFIER_VEHICLE;
current->ride = rideIndex;
@ -219,7 +219,7 @@ static void cable_lift_update_arriving(rct_vehicle *vehicle)
}
static bool sub_6DF01A_loop(rct_vehicle* vehicle) {
rct_ride* ride = get_ride(vehicle->ride);
Ride* ride = get_ride(vehicle->ride);
for (; vehicle->remaining_distance >= 13962; _vehicleUnkF64E10++) {
uint8 trackType = vehicle->track_type >> 2;
if (trackType == TRACK_ELEM_CABLE_LIFT_HILL &&
@ -304,7 +304,7 @@ static bool sub_6DF01A_loop(rct_vehicle* vehicle) {
}
static bool sub_6DF21B_loop(rct_vehicle* vehicle) {
rct_ride* ride = get_ride(vehicle->ride);
Ride* ride = get_ride(vehicle->ride);
for (; vehicle->remaining_distance < 0; _vehicleUnkF64E10++) {
uint16 trackProgress = vehicle->track_progress - 1;
const rct_vehicle_info *moveInfo;

2
src/openrct2/ride/coaster/air_powered_vertical_coaster.c
View File

@ -213,7 +213,7 @@ static void air_powered_vertical_rc_track_station(paint_session * session, uint8
wooden_a_supports_paint_setup(session, direction & 1, 0, height, gTrackColours[SCHEME_SUPPORTS], NULL);
rct_ride * ride = get_ride(rideIndex);
Ride * ride = get_ride(rideIndex);
track_paint_util_draw_station_platform(session, ride, direction, height, 5, mapElement);
paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_6);

2
src/openrct2/ride/coaster/bolliger_mabillard_track.c
View File

@ -84,7 +84,7 @@ void bolliger_mabillard_track_station(paint_session * session, uint8 rideIndex,
sub_98196C_rotated(session, direction, imageIds[direction][2] | gTrackColours[SCHEME_MISC], 0, 0, 32, 32, 1, height);
track_paint_util_draw_station_metal_supports_2(session, direction, height, gTrackColours[SCHEME_SUPPORTS], supportType);
rct_ride * ride = get_ride(rideIndex);
Ride * ride = get_ride(rideIndex);
track_paint_util_draw_station_platform(session, ride, direction, height, 9, mapElement);
paint_util_push_tunnel_rotated(session, direction, height, TUNNEL_6);

2
src/openrct2/ride/coaster/multi_dimension_roller_coaster.c
View File

@ -103,7 +103,7 @@ static void multi_dimension_rc_track_station(paint_session * session, uint8 ride
}
track_paint_util_draw_station_metal_supports_2(session, direction, height, gTrackColours[SCHEME_SUPPORTS], 11);
rct_ride * ride = get_ride(rideIndex);
Ride * ride = get_ride(rideIndex);
const rct_ride_entrance_definition * entranceStyle = &RideEntranceDefinitions[ride->entrance_style];
bool hasFence;
if (direction == 0 || direction == 2) {

2
src/openrct2/ride/coaster/reverse_freefall_coaster.c
View File

@ -223,7 +223,7 @@ static void paint_reverse_freefall_rc_flat(paint_session * session, uint8 rideIn
static void paint_reverse_freefall_rc_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_map_element *mapElement)
{
rct_ride * ride = get_ride(rideIndex);
Ride * ride = get_ride(rideIndex);
const rct_ride_entrance_definition * entranceStyle = &RideEntranceDefinitions[ride->entrance_style];
uint32 imageId = entranceStyle->base_image_id;
if (!(gTrackColours[SCHEME_MISC] & (1 << 29))) {

4
src/openrct2/ride/gentle/circus_show.c
View File

@ -27,7 +27,7 @@ static void paint_circus_show_tent(paint_session * session, uint8 rideIndex, uin
{
rct_map_element * savedMapElement = session->CurrentlyDrawnItem;
rct_ride * ride = get_ride(rideIndex);
Ride * ride = get_ride(rideIndex);
rct_ride_entry * rideEntry = get_ride_entry(ride->subtype);
if (ride->lifecycle_flags & RIDE_LIFECYCLE_ON_TRACK
@ -56,7 +56,7 @@ static void paint_circus_show(paint_session * session, uint8 rideIndex, uint8 tr
trackSequence = track_map_3x3[direction][trackSequence];
sint32 edges = edges_3x3[trackSequence];
rct_ride * ride = get_ride(rideIndex);
Ride * ride = get_ride(rideIndex);
rct_xy16 position = session->MapPosition;
wooden_a_supports_paint_setup(session, (direction & 1), 0, height, gTrackColours[SCHEME_MISC], NULL);

4
src/openrct2/ride/gentle/crooked_house.c
View File

@ -46,7 +46,7 @@ rct_crooked_house_bound_box crooked_house_data[] = {
static void paint_crooked_house_structure(paint_session * session, uint8 direction, uint8 x_offset, uint8 y_offset, uint32 segment, sint32 height) {
rct_map_element *original_map_element = session->CurrentlyDrawnItem;
rct_ride *ride = get_ride(original_map_element->properties.track.ride_index);
Ride *ride = get_ride(original_map_element->properties.track.ride_index);
rct_ride_entry *ride_type = get_ride_entry(ride->subtype);
@ -70,7 +70,7 @@ static void paint_crooked_house(paint_session * session, uint8 rideIndex, uint8
trackSequence = track_map_3x3[direction][trackSequence];
sint32 edges = edges_3x3[trackSequence];
rct_ride * ride = get_ride(rideIndex);
Ride * ride = get_ride(rideIndex);
rct_xy16 position = session->MapPosition;
wooden_a_supports_paint_setup(session, (direction & 1), 0, height, gTrackColours[SCHEME_MISC], NULL);

2
src/openrct2/ride/gentle/dodgems.c
View File

@ -51,7 +51,7 @@ static void paint_dodgems(paint_session * session, uint8 rideIndex, uint8 trackS
uint8 relativeTrackSequence = track_map_4x4[direction][trackSequence];
sint32 edges = edges_4x4[relativeTrackSequence];
rct_ride * ride = get_ride(rideIndex);
Ride * ride = get_ride(rideIndex);
rct_xy16 position = session->MapPosition;
wooden_a_supports_paint_setup(session, direction & 1, 0, height, gTrackColours[SCHEME_MISC], NULL);

4
src/openrct2/ride/gentle/ferris_wheel.c
View File

@ -60,7 +60,7 @@ static void paint_ferris_wheel_structure(paint_session * session, uint8 rideInde
rct_map_element * savedMapElement = session->CurrentlyDrawnItem;
rct_ride * ride = get_ride(rideIndex);
Ride * ride = get_ride(rideIndex);
rct_ride_entry * rideEntry = get_ride_entry(ride->subtype);
rct_vehicle * vehicle = NULL;
@ -139,7 +139,7 @@ static void paint_ferris_wheel(paint_session * session, uint8 rideIndex, uint8 t
edges = edges_1x4_ne_sw[relativeTrackSequence];
}
rct_ride * ride = get_ride(rideIndex);
Ride * ride = get_ride(rideIndex);
rct_xy16 position = session->MapPosition;
wooden_a_supports_paint_setup(session, direction & 1, 0, height, gTrackColours[SCHEME_MISC], NULL);

2
src/openrct2/ride/gentle/flying_saucers.c
View File

@ -44,7 +44,7 @@ static void paint_flying_saucers(paint_session * session, uint8 rideIndex, uint8
uint8 relativeTrackSequence = track_map_4x4[direction][trackSequence];
sint32 edges = edges_4x4[relativeTrackSequence];
rct_ride * ride = get_ride(rideIndex);
Ride * ride = get_ride(rideIndex);
rct_xy16 position = session->MapPosition;
wooden_a_supports_paint_setup(session, direction & 1, 0, height, gTrackColours[SCHEME_MISC], NULL);

4
src/openrct2/ride/gentle/haunted_house.c
View File

@ -48,7 +48,7 @@ static void paint_haunted_house_structure(paint_session * session, uint8 rideInd
uint8 frameNum = 0;
rct_ride * ride = get_ride(rideIndex);
Ride * ride = get_ride(rideIndex);
rct_ride_entry * ride_type = get_ride_entry(ride->subtype);
uint32 baseImageId = ride_type->vehicles[0].base_image_id;
@ -89,7 +89,7 @@ static void paint_haunted_house(paint_session * session, uint8 rideIndex, uint8
trackSequence = track_map_3x3[direction][trackSequence];
sint32 edges = edges_3x3[trackSequence];
rct_ride * ride = get_ride(rideIndex);
Ride * ride = get_ride(rideIndex);
rct_xy16 position = session->MapPosition;
wooden_a_supports_paint_setup(session, (direction & 1), 0, height, gTrackColours[SCHEME_MISC], NULL);

4
src/openrct2/ride/gentle/merry_go_round.c
View File

@ -38,7 +38,7 @@ static void paint_merry_go_round_structure(paint_session * session, uint8 rideIn
rct_map_element * savedMapElement = session->CurrentlyDrawnItem;
height += 7;
rct_ride * ride = get_ride(rideIndex);
Ride * ride = get_ride(rideIndex);
rct_ride_entry * rideEntry = get_ride_entry(ride->subtype);
rct_vehicle * vehicle = NULL;
@ -108,7 +108,7 @@ static void paint_merry_go_round(paint_session * session, uint8 rideIndex, uint8
trackSequence = track_map_3x3[direction][trackSequence];
sint32 edges = edges_3x3[trackSequence];
rct_ride * ride = get_ride(rideIndex);
Ride * ride = get_ride(rideIndex);
rct_xy16 position = session->MapPosition;
wooden_a_supports_paint_setup(session, (direction & 1), 0, height, gTrackColours[SCHEME_MISC], NULL);

4
src/openrct2/ride/gentle/mini_golf.c
View File

@ -625,7 +625,7 @@ static void paint_mini_golf_track_25_deg_down_to_flat(paint_session * session, u
static void paint_mini_golf_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_map_element * mapElement)
{
rct_xy16 position = session->MapPosition;
rct_ride * ride = get_ride(rideIndex);
Ride * ride = get_ride(rideIndex);
const rct_ride_entrance_definition * entranceStyle = &RideEntranceDefinitions[ride->entrance_style];
uint32 imageId;
bool hasFence;
@ -1067,7 +1067,7 @@ void vehicle_visual_mini_golf_ball(paint_session * session, sint32 x, sint32 ima
return;
}
rct_ride *ride = get_ride(vehicle->ride);
Ride *ride = get_ride(vehicle->ride);
rct_ride_entry *rideEntry = get_ride_entry(ride->subtype);
uint32 image_id = rideEntry->vehicles[0].base_image_id;

2
src/openrct2/ride/gentle/observation_tower.c
View File

@ -74,7 +74,7 @@ static void paint_observation_tower_base(paint_session * session, uint8 rideInde
trackSequence = track_map_3x3[direction][trackSequence];
sint32 edges = edges_3x3[trackSequence];
rct_ride * ride = get_ride(rideIndex);
Ride * ride = get_ride(rideIndex);
rct_xy16 position = session->MapPosition;
wooden_a_supports_paint_setup(session, (direction & 1), 0, height, gTrackColours[SCHEME_MISC], NULL);

4
src/openrct2/ride/gentle/space_rings.c
View File

@ -37,7 +37,7 @@ static const uint32 space_rings_fence_sprites[] = {
};
/** rct2: 0x00768A3B */
static void paint_space_rings_structure(paint_session * session, rct_ride * ride, uint8 direction, uint32 segment, sint32 height)
static void paint_space_rings_structure(paint_session * session, Ride * ride, uint8 direction, uint32 segment, sint32 height)
{
rct_map_element * savedMapElement = session->CurrentlyDrawnItem;
@ -89,7 +89,7 @@ static void paint_space_rings(paint_session * session, uint8 rideIndex, uint8 tr
trackSequence = track_map_3x3[direction][trackSequence];
sint32 edges = edges_3x3[trackSequence];
rct_ride * ride = get_ride(rideIndex);
Ride * ride = get_ride(rideIndex);
rct_xy16 position = session->MapPosition;
uint32 imageId;

4
src/openrct2/ride/gentle/spiral_slide.c
View File

@ -77,7 +77,7 @@ static void spiral_slide_paint_tile_left(paint_session * session, uint8 rideInde
static void spiral_slide_paint_tile_front(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_map_element * mapElement) {
uint32 image_id = 0;
rct_ride *ride = get_ride(rideIndex);
Ride *ride = get_ride(rideIndex);
if (direction == 1) {
image_id = SPIRAL_SLIDE_INSIDE_R1 | gTrackColours[SCHEME_TRACK];
@ -165,7 +165,7 @@ static void paint_spiral_slide(paint_session * session, uint8 rideIndex, uint8 t
trackSequence = track_map_2x2[direction][trackSequence];
sint32 edges = edges_2x2[trackSequence];
rct_ride * ride = get_ride(rideIndex);
Ride * ride = get_ride(rideIndex);
rct_xy16 position = session->MapPosition;
wooden_a_supports_paint_setup(session, direction & 1, 0, height, gTrackColours[SCHEME_MISC], NULL);

330
src/openrct2/ride/ride.c
View File

File diff suppressed because it is too large Load Diff

161
src/openrct2/ride/ride.h
View File

@ -22,6 +22,7 @@
#include "../rct12.h"
#include "../rct2.h"
#include "../world/map.h"
#include "ride_ratings.h"
#include "vehicle.h"
#define MAX_RIDE_TYPES_PER_RIDE_ENTRY 3
@ -34,24 +35,14 @@
#define MAX_CATEGORIES_PER_RIDE 2
#define DOWNTIME_HISTORY_SIZE 8
#define CUSTOMER_HISTORY_SIZE 10
typedef fixed16_2dp ride_rating;
// Convenience function for writing ride ratings. The result is a 16 bit signed
// integer. To create the ride rating 3.65 type RIDE_RATING(3,65)
#define RIDE_RATING(whole, fraction) FIXED_2DP(whole, fraction)
#define RIDE_RATING_UNDEFINED (ride_rating)(uint16)0xFFFF
#define MAX_RIDES_IN_PARK 255
#define MAX_STAFF 200
#define MAX_BANNERS_IN_PARK 250
#define MAX_CARS_PER_TRAIN 32
#define MAX_STATIONS 4
#pragma pack(push, 1)
// Used for return values, for functions that modify all three.
typedef struct rating_tuple {
ride_rating excitement;
ride_rating intensity;
ride_rating nausea;
} rating_tuple;
assert_struct_size(rating_tuple, 6);
/**
* Couples a ride type and subtype together.
*/
@ -148,7 +139,7 @@ assert_struct_size(rct_ride_entry, 0x1c2);
* Ride structure.
* size: 0x0260
*/
typedef struct rct_ride {
typedef struct Ride {
uint8 type; // 0x000
// pointer to static info. for example, wild mouse type is 0x36, subtype is
// 0x4c.
@ -156,7 +147,7 @@ typedef struct rct_ride {
uint16 pad_002; // 0x002
uint8 mode; // 0x004
uint8 colour_scheme_type; // 0x005
rct_vehicle_colour vehicle_colours[RCT2_MAX_CARS_PER_TRAIN]; // 0x006
rct_vehicle_colour vehicle_colours[MAX_CARS_PER_TRAIN]; // 0x006
uint8 pad_046[0x03]; // 0x046, Used to be track colours in RCT1 without expansions
// 0 = closed, 1 = open, 2 = test
uint8 status; // 0x049
@ -169,18 +160,18 @@ typedef struct rct_ride {
};
};
rct_xy8 overall_view; // 0x050
rct_xy8 station_starts[RCT12_MAX_STATIONS_PER_RIDE]; // 0x052
uint8 station_heights[RCT12_MAX_STATIONS_PER_RIDE]; // 0x05A
uint8 station_length[RCT12_MAX_STATIONS_PER_RIDE]; // 0x05E
uint8 station_depart[RCT12_MAX_STATIONS_PER_RIDE]; // 0x062
rct_xy8 station_starts[MAX_STATIONS]; // 0x052
uint8 station_heights[MAX_STATIONS]; // 0x05A
uint8 station_length[MAX_STATIONS]; // 0x05E
uint8 station_depart[MAX_STATIONS]; // 0x062
// ride->vehicle index for current train waiting for passengers
// at station
uint8 train_at_station[RCT12_MAX_STATIONS_PER_RIDE]; // 0x066
rct_xy8 entrances[RCT12_MAX_STATIONS_PER_RIDE]; // 0x06A
rct_xy8 exits[RCT12_MAX_STATIONS_PER_RIDE]; // 0x072
uint16 last_peep_in_queue[RCT12_MAX_STATIONS_PER_RIDE]; // 0x07A
uint8 pad_082[RCT12_MAX_STATIONS_PER_RIDE]; // 0x082, Used to be number of peeps in queue in RCT1, but this has moved.
uint16 vehicles[RCT2_MAX_VEHICLES_PER_RIDE]; // 0x086, Points to the first car in the train
uint8 train_at_station[MAX_STATIONS]; // 0x066
rct_xy8 entrances[MAX_STATIONS]; // 0x06A
rct_xy8 exits[MAX_STATIONS]; // 0x072
uint16 last_peep_in_queue[MAX_STATIONS]; // 0x07A
uint8 pad_082[MAX_STATIONS]; // 0x082, Used to be number of peeps in queue in RCT1, but this has moved.
uint16 vehicles[MAX_VEHICLES_PER_RIDE]; // 0x086, Points to the first car in the train
uint8 depart_flags; // 0x0C6
// Not sure if these should be uint or sint.
@ -218,8 +209,8 @@ typedef struct rct_ride {
uint8 current_test_segment; // 0x0E0
uint8 average_speed_test_timeout; // 0x0E1
uint8 pad_0E2[0x2]; // 0x0E2
sint32 length[RCT12_MAX_STATIONS_PER_RIDE]; // 0x0E4
uint16 time[RCT12_MAX_STATIONS_PER_RIDE]; // 0x0F4
sint32 length[MAX_STATIONS]; // 0x0E4
uint16 time[MAX_STATIONS]; // 0x0F4
fixed16_2dp max_positive_vertical_g; // 0x0FC
fixed16_2dp max_negative_vertical_g; // 0x0FE
fixed16_2dp max_lateral_g; // 0x100
@ -256,7 +247,7 @@ typedef struct rct_ride {
// Counts ticks to update customer intervals, resets each 960 game ticks.
uint16 num_customers_timeout; // 0x122
// Customer count in the last 10 * 960 game ticks (sliding window)
uint16 num_customers[RCT2_CUSTOMER_HISTORY_SIZE]; // 0x124
uint16 num_customers[CUSTOMER_HISTORY_SIZE]; // 0x124
money16 price; // 0x138
rct_xy8 chairlift_bullwheel_location[2]; // 0x13A
uint8 chairlift_bullwheel_z[2]; // 0x13E
@ -322,7 +313,7 @@ typedef struct rct_ride {
uint8 downtime; // 0x199
uint8 inspection_interval; // 0x19A
uint8 last_inspection; // 0x19B
uint8 downtime_history[RCT2_DOWNTIME_HISTORY_SIZE]; // 0x19C
uint8 downtime_history[DOWNTIME_HISTORY_SIZE]; // 0x19C
uint32 no_primary_items_sold; // 0x1A4
uint32 no_secondary_items_sold; // 0x1A8
uint8 breakdown_sound_modifier; // 0x1AC
@ -333,10 +324,10 @@ typedef struct rct_ride {
uint8 connected_message_throttle; // 0x1AF
money32 income_per_hour; // 0x1B0
money32 profit; // 0x1B4
uint8 queue_time[RCT12_MAX_STATIONS_PER_RIDE]; // 0x1B8
uint8 track_colour_main[RCT12_NUM_COLOUR_SCHEMES]; // 0x1BC
uint8 track_colour_additional[RCT12_NUM_COLOUR_SCHEMES]; // 0x1C0
uint8 track_colour_supports[RCT12_NUM_COLOUR_SCHEMES]; // 0x1C4
uint8 queue_time[MAX_STATIONS]; // 0x1B8
uint8 track_colour_main[NUM_COLOUR_SCHEMES]; // 0x1BC
uint8 track_colour_additional[NUM_COLOUR_SCHEMES]; // 0x1C0
uint8 track_colour_supports[NUM_COLOUR_SCHEMES]; // 0x1C4
uint8 music; // 0x1C8
uint8 entrance_style; // 0x1C9
uint16 vehicle_change_timeout; // 0x1CA
@ -344,7 +335,7 @@ typedef struct rct_ride {
uint8 lift_hill_speed; // 0x1CD
uint16 guests_favourite; // 0x1CE
uint32 lifecycle_flags; // 0x1D0
uint8 vehicle_colours_extended[RCT2_MAX_CARS_PER_TRAIN]; // 0x1D4
uint8 vehicle_colours_extended[MAX_CARS_PER_TRAIN]; // 0x1D4
uint16 total_air_time; // 0x1F4
uint8 current_test_station; // 0x1F6
uint8 num_circuits; // 0x1F7
@ -353,10 +344,10 @@ typedef struct rct_ride {
uint8 cable_lift_z; // 0x1FC
uint8 pad_1FD; // 0x1FD
uint16 cable_lift; // 0x1FE
uint16 queue_length[RCT12_MAX_STATIONS_PER_RIDE]; // 0x200
uint16 queue_length[MAX_STATIONS]; // 0x200
uint8 pad_208[0x58]; // 0x208
} rct_ride;
assert_struct_size(rct_ride, 0x260);
} Ride;
assert_struct_size(Ride, 0x260);
#define RIDE_MEASUREMENT_MAX_ITEMS 4800
@ -952,7 +943,7 @@ extern const rct_ride_properties RideProperties[RIDE_TYPE_COUNT];
#define CONSTRUCTION_LIFT_HILL_SELECTED 1
/** Helper macros until rides are stored in this module. */
rct_ride *get_ride(sint32 index);
Ride *get_ride(sint32 index);
rct_ride_entry *get_ride_entry(sint32 index);
void get_ride_entry_name(char *name, sint32 index);
rct_ride_measurement *get_ride_measurement(sint32 index);
@ -971,9 +962,9 @@ extern uint32 gSamePriceThroughoutParkB;
extern const uint8 gRideClassifications[255];
#ifdef NO_RCT2
extern rct_ride gRideList[255];
extern Ride gRideList[255];
#else
extern rct_ride *gRideList;
extern Ride *gRideList;
#endif
extern rct_ride_measurement gRideMeasurements[MAX_RIDE_MEASUREMENTS];
@ -1034,17 +1025,17 @@ extern sint32 gRideRemoveTrackPieceCallbackType;
extern uint8 gLastEntranceStyle;
sint32 ride_get_count();
sint32 ride_get_total_queue_length(rct_ride *ride);
sint32 ride_get_max_queue_time(rct_ride *ride);
rct_peep * ride_get_queue_head_guest(rct_ride * ride, sint32 stationIndex);
void ride_queue_insert_guest_at_front(rct_ride * ride, sint32 stationIndex, rct_peep * peep);
sint32 ride_get_total_queue_length(Ride *ride);
sint32 ride_get_max_queue_time(Ride *ride);
rct_peep * ride_get_queue_head_guest(Ride * ride, sint32 stationIndex);
void ride_queue_insert_guest_at_front(Ride * ride, sint32 stationIndex, rct_peep * peep);
void ride_init_all();
void reset_all_ride_build_dates();
void ride_update_favourited_stat();
void ride_update_all();
void ride_check_all_reachable();
void ride_update_satisfaction(rct_ride* ride, uint8 happiness);
void ride_update_popularity(rct_ride* ride, uint8 pop_amount);
void ride_update_satisfaction(Ride* ride, uint8 happiness);
void ride_update_popularity(Ride* ride, uint8 pop_amount);
money32 get_shop_item_cost(sint32 shopItem);
money16 get_shop_base_value(sint32 shopItem);
money16 get_shop_hot_value(sint32 shopItem);
@ -1056,20 +1047,20 @@ void ride_construct(sint32 rideIndex);
sint32 ride_modify(rct_xy_element *input);
void ride_remove_peeps(sint32 rideIndex);
void ride_get_status(sint32 rideIndex, rct_string_id *formatSecondary, sint32 *argument);
rct_peep *ride_get_assigned_mechanic(rct_ride *ride);
sint32 ride_get_total_length(rct_ride *ride);
sint32 ride_get_total_time(rct_ride *ride);
sint32 ride_can_have_multiple_circuits(rct_ride *ride);
track_colour ride_get_track_colour(rct_ride *ride, sint32 colourScheme);
vehicle_colour ride_get_vehicle_colour(rct_ride *ride, sint32 vehicleIndex);
rct_ride_entry *get_ride_entry_by_ride(rct_ride *ride);
rct_peep *ride_get_assigned_mechanic(Ride *ride);
sint32 ride_get_total_length(Ride *ride);
sint32 ride_get_total_time(Ride *ride);
sint32 ride_can_have_multiple_circuits(Ride *ride);
track_colour ride_get_track_colour(Ride *ride, sint32 colourScheme);
vehicle_colour ride_get_vehicle_colour(Ride *ride, sint32 vehicleIndex);
rct_ride_entry *get_ride_entry_by_ride(Ride *ride);
uint8 *get_ride_entry_indices_for_ride_type(uint8 rideType);
void reset_type_to_ride_entry_index_map();
void ride_measurement_clear(rct_ride *ride);
void ride_measurement_clear(Ride *ride);
void ride_measurements_update();
rct_ride_measurement *ride_get_measurement(sint32 rideIndex, rct_string_id *message);
void ride_breakdown_add_news_item(sint32 rideIndex);
rct_peep *ride_find_closest_mechanic(rct_ride *ride, sint32 forInspection);
rct_peep *ride_find_closest_mechanic(Ride *ride, sint32 forInspection);
sint32 ride_initialise_construction_window(sint32 rideIndex);
void ride_construction_invalidate_current_track();
sint32 sub_6C683D(sint32* x, sint32* y, sint32* z, sint32 direction, sint32 type, uint16 extra_params, rct_map_element** output_element, uint16 flags);
@ -1077,8 +1068,8 @@ void ride_set_map_tooltip(rct_map_element *mapElement);
sint32 ride_music_params_update(sint16 x, sint16 y, sint16 z, uint8 rideIndex, uint16 sampleRate, uint32 position, uint8 *tuneId);
void ride_music_update_final();
void ride_prepare_breakdown(sint32 rideIndex, sint32 breakdownReason);
rct_map_element *ride_get_station_start_track_element(rct_ride *ride, sint32 stationIndex);
rct_map_element *ride_get_station_exit_element(rct_ride *ride, sint32 x, sint32 y, sint32 z);
rct_map_element *ride_get_station_start_track_element(Ride *ride, sint32 stationIndex);
rct_map_element *ride_get_station_exit_element(Ride *ride, sint32 x, sint32 y, sint32 z);
void ride_set_status(sint32 rideIndex, sint32 status);
void game_command_set_ride_status(sint32 *eax, sint32 *ebx, sint32 *ecx, sint32 *edx, sint32 *esi, sint32 *edi, sint32 *ebp);
void ride_set_name(sint32 rideIndex, const char *name);
@ -1098,7 +1089,7 @@ void game_command_demolish_ride(sint32 *eax, sint32 *ebx, sint32 *ecx, sint32 *e
void game_command_set_ride_appearance(sint32 *eax, sint32 *ebx, sint32 *ecx, sint32 *edx, sint32 *esi, sint32 *edi, sint32 *ebp);
void game_command_set_ride_price(sint32 *eax, sint32 *ebx, sint32 *ecx, sint32 *edx, sint32 *esi, sint32 *edi, sint32 *ebp);
money32 ride_create_command(sint32 type, sint32 subType, sint32 flags, uint8 *outRideIndex, uint8 *outRideColour);
void ride_set_name_to_default(rct_ride * ride, rct_ride_entry * rideEntry);
void ride_set_name_to_default(Ride * ride, rct_ride_entry * rideEntry);
void ride_clear_for_construction(sint32 rideIndex);
void ride_entrance_exit_place_provisional_ghost();
@ -1111,26 +1102,26 @@ void invalidate_test_results(sint32 rideIndex);
void ride_select_next_section();
void ride_select_previous_section();
void increment_turn_count_1_element(rct_ride* ride, uint8 type);
void increment_turn_count_2_elements(rct_ride* ride, uint8 type);
void increment_turn_count_3_elements(rct_ride* ride, uint8 type);
void increment_turn_count_4_plus_elements(rct_ride* ride, uint8 type);
sint32 get_turn_count_1_element(rct_ride* ride, uint8 type);
sint32 get_turn_count_2_elements(rct_ride* ride, uint8 type);
sint32 get_turn_count_3_elements(rct_ride* ride, uint8 type);
sint32 get_turn_count_4_plus_elements(rct_ride* ride, uint8 type);
void increment_turn_count_1_element(Ride* ride, uint8 type);
void increment_turn_count_2_elements(Ride* ride, uint8 type);
void increment_turn_count_3_elements(Ride* ride, uint8 type);
void increment_turn_count_4_plus_elements(Ride* ride, uint8 type);
sint32 get_turn_count_1_element(Ride* ride, uint8 type);
sint32 get_turn_count_2_elements(Ride* ride, uint8 type);
sint32 get_turn_count_3_elements(Ride* ride, uint8 type);
sint32 get_turn_count_4_plus_elements(Ride* ride, uint8 type);
uint8 ride_get_helix_sections(rct_ride *ride);
bool ride_has_spinning_tunnel(rct_ride *ride);
bool ride_has_water_splash(rct_ride *ride);
bool ride_has_rapids(rct_ride *ride);
bool ride_has_log_reverser(rct_ride *ride);
bool ride_has_waterfall(rct_ride *ride);
bool ride_has_whirlpool(rct_ride *ride);
uint8 ride_get_helix_sections(Ride *ride);
bool ride_has_spinning_tunnel(Ride *ride);
bool ride_has_water_splash(Ride *ride);
bool ride_has_rapids(Ride *ride);
bool ride_has_log_reverser(Ride *ride);
bool ride_has_waterfall(Ride *ride);
bool ride_has_whirlpool(Ride *ride);
bool ride_type_has_flag(sint32 rideType, sint32 flag);
bool ride_is_powered_launched(rct_ride *ride);
bool ride_is_block_sectioned(rct_ride *ride);
bool ride_is_powered_launched(Ride *ride);
bool ride_is_block_sectioned(Ride *ride);
bool ride_has_any_track_elements(sint32 rideIndex);
void ride_all_has_any_track_elements(bool *rideIndexArray);
@ -1152,7 +1143,7 @@ bool ride_select_forwards_from_back();
money32 ride_remove_track_piece(sint32 x, sint32 y, sint32 z, sint32 direction, sint32 type, uint8 flags);
bool ride_are_all_possible_entrances_and_exits_built(rct_ride *ride);
bool ride_are_all_possible_entrances_and_exits_built(Ride *ride);
void ride_fix_breakdown(sint32 rideIndex, sint32 reliabilityIncreaseFactor);
void ride_entry_get_train_layout(sint32 rideEntryIndex, sint32 numCarsPerTrain, uint8 *trainLayout);
@ -1180,26 +1171,26 @@ bool shop_item_is_food(sint32 shopItem);
bool shop_item_is_drink(sint32 shopItem);
bool shop_item_is_souvenir(sint32 shopItem);
void ride_reset_all_names();
const uint8* ride_seek_available_modes(rct_ride *ride);
const uint8* ride_seek_available_modes(Ride *ride);
void window_ride_measurements_design_cancel();
void window_ride_construction_mouseup_demolish_next_piece(sint32 x, sint32 y, sint32 z, sint32 direction, sint32 type);
uint32 ride_customers_per_hour(const rct_ride *ride);
uint32 ride_customers_in_last_5_minutes(const rct_ride *ride);
uint32 ride_customers_per_hour(const Ride *ride);
uint32 ride_customers_in_last_5_minutes(const Ride *ride);
rct_vehicle * ride_get_broken_vehicle(rct_ride *ride);
rct_vehicle * ride_get_broken_vehicle(Ride *ride);
void window_ride_construction_do_station_check();
void window_ride_construction_do_entrance_exit_check();
void game_command_callback_place_ride_entrance_or_exit(sint32 eax, sint32 ebx, sint32 ecx, sint32 edx, sint32 esi, sint32 edi, sint32 ebp);
void ride_delete(uint8 rideIndex);
money16 ride_get_price(rct_ride * ride);
money16 ride_get_price(Ride * ride);
rct_map_element *get_station_platform(sint32 x, sint32 y, sint32 z, sint32 z_tolerance);
bool ride_has_adjacent_station(rct_ride *ride);
bool ride_has_ratings(const rct_ride * ride);
bool ride_has_adjacent_station(Ride *ride);
bool ride_has_ratings(const Ride * ride);
const char * ride_type_get_enum_name(sint32 rideType);

250
src/openrct2/ride/ride_ratings.c
View File

@ -64,7 +64,7 @@ enum {
PROXIMITY_COUNT
};
typedef void (*ride_ratings_calculation)(rct_ride *ride);
typedef void (*ride_ratings_calculation)(Ride *ride);
rct_ride_rating_calc_data gRideRatingsCalcData;
@ -78,8 +78,8 @@ static void ride_ratings_update_state_3();
static void ride_ratings_update_state_4();
static void ride_ratings_update_state_5();
static void ride_ratings_begin_proximity_loop();
static void ride_ratings_calculate(rct_ride *ride);
static void ride_ratings_calculate_value(rct_ride *ride);
static void ride_ratings_calculate(Ride *ride);
static void ride_ratings_calculate_value(Ride *ride);
static void ride_ratings_score_close_proximity(rct_map_element *mapElement);
static void ride_ratings_add(rating_tuple * rating, sint32 excitement, sint32 intensity, sint32 nausea);
@ -92,7 +92,7 @@ static void ride_ratings_add(rating_tuple * rating, sint32 excitement, sint32 in
*/
void ride_ratings_update_ride(int rideIndex)
{
rct_ride *ride = get_ride(rideIndex);
Ride *ride = get_ride(rideIndex);
if (ride->type != RIDE_TYPE_NULL && ride->status != RIDE_STATUS_CLOSED) {
gRideRatingsCalcData.current_ride = rideIndex;
gRideRatingsCalcData.state = RIDE_RATINGS_STATE_INITIALISE;
@ -152,7 +152,7 @@ static void ride_ratings_update_state_0()
currentRide = 0;
}
rct_ride *ride = get_ride(currentRide);
Ride *ride = get_ride(currentRide);
if (ride->type != RIDE_TYPE_NULL && ride->status != RIDE_STATUS_CLOSED) {
gRideRatingsCalcData.state = RIDE_RATINGS_STATE_INITIALISE;
}
@ -182,7 +182,7 @@ static void ride_ratings_update_state_1()
*/
static void ride_ratings_update_state_2()
{
rct_ride *ride = get_ride(gRideRatingsCalcData.current_ride);
Ride *ride = get_ride(gRideRatingsCalcData.current_ride);
if (ride->type == RIDE_TYPE_NULL || ride->status == RIDE_STATUS_CLOSED) {
gRideRatingsCalcData.state = RIDE_RATINGS_STATE_FIND_NEXT_RIDE;
return;
@ -250,7 +250,7 @@ static void ride_ratings_update_state_2()
*/
static void ride_ratings_update_state_3()
{
rct_ride *ride = get_ride(gRideRatingsCalcData.current_ride);
Ride *ride = get_ride(gRideRatingsCalcData.current_ride);
if (ride->type == RIDE_TYPE_NULL || ride->status == RIDE_STATUS_CLOSED) {
gRideRatingsCalcData.state = RIDE_RATINGS_STATE_FIND_NEXT_RIDE;
return;
@ -279,7 +279,7 @@ static void ride_ratings_update_state_4()
*/
static void ride_ratings_update_state_5()
{
rct_ride *ride = get_ride(gRideRatingsCalcData.current_ride);
Ride *ride = get_ride(gRideRatingsCalcData.current_ride);
if (ride->type == RIDE_TYPE_NULL || ride->status == RIDE_STATUS_CLOSED) {
gRideRatingsCalcData.state = RIDE_RATINGS_STATE_FIND_NEXT_RIDE;
return;
@ -332,7 +332,7 @@ static void ride_ratings_update_state_5()
*/
static void ride_ratings_begin_proximity_loop()
{
rct_ride *ride = get_ride(gRideRatingsCalcData.current_ride);
Ride *ride = get_ride(gRideRatingsCalcData.current_ride);
if (ride->type == RIDE_TYPE_NULL || ride->status == RIDE_STATUS_CLOSED) {
gRideRatingsCalcData.state = RIDE_RATINGS_STATE_FIND_NEXT_RIDE;
return;
@ -623,7 +623,7 @@ static void ride_ratings_score_close_proximity(rct_map_element *inputMapElement)
}
}
static void ride_ratings_calculate(rct_ride *ride)
static void ride_ratings_calculate(Ride *ride)
{
ride_ratings_calculation calcFunc = ride_ratings_calculate_func_table[ride->type];
if (calcFunc != NULL) {
@ -640,7 +640,7 @@ static void ride_ratings_calculate(rct_ride *ride)
#endif
}
static void ride_ratings_calculate_value(rct_ride *ride)
static void ride_ratings_calculate_value(Ride *ride)
{
typedef struct row {
sint32 months, multiplier, divisor, summand;
@ -718,7 +718,7 @@ static void ride_ratings_calculate_value(rct_ride *ride)
// Other ride of same type penalty
sint32 otherRidesOfSameType = 0;
rct_ride *ride2;
Ride *ride2;
sint32 i;
FOR_ALL_RIDES(i, ride2) {
if (ride2->type == ride->type && ride2->status == RIDE_STATUS_OPEN)
@ -736,7 +736,7 @@ static void ride_ratings_calculate_value(rct_ride *ride)
* inputs
* - edi: ride ptr
*/
static uint16 ride_compute_upkeep(rct_ride *ride)
static uint16 ride_compute_upkeep(Ride *ride)
{
// data stored at 0x0057E3A8, incrementing 18 bytes at a time
uint16 upkeep = initialUpkeepCosts[ride->type];
@ -819,7 +819,7 @@ static uint16 ride_compute_upkeep(rct_ride *ride)
* - bp: nausea
* - edi: ride ptr
*/
static void ride_ratings_apply_adjustments(rct_ride *ride, rating_tuple *ratings)
static void ride_ratings_apply_adjustments(Ride *ride, rating_tuple *ratings)
{
rct_ride_entry *rideEntry = get_ride_entry(ride->subtype);
@ -881,7 +881,7 @@ static void ride_ratings_apply_intensity_penalty(rating_tuple *ratings)
*
* rct2: 0x00655FD6
*/
static void set_unreliability_factor(rct_ride *ride)
static void set_unreliability_factor(Ride *ride)
{
// The bigger the difference in lift speed and minimum the higher the unreliability
uint8 lift_speed_adjustment = RideLiftData[ride->type].minimum_speed;
@ -947,7 +947,7 @@ static uint32 ride_ratings_get_proximity_score()
* Calculates how much of the track is sheltered in eighths.
* rct2: 0x0065E72D
*/
static sint32 get_num_of_sheltered_eighths(rct_ride *ride)
static sint32 get_num_of_sheltered_eighths(Ride *ride)
{
sint32 totalLength = ride_get_total_length(ride);
sint32 shelteredLength = ride->sheltered_length;
@ -969,7 +969,7 @@ static sint32 get_num_of_sheltered_eighths(rct_ride *ride)
return (dh << 8) | numShelteredEighths;
}
static rating_tuple get_flat_turns_rating(rct_ride* ride)
static rating_tuple get_flat_turns_rating(Ride* ride)
{
sint32 no_3_plus_turns = get_turn_count_3_elements(ride, 0);
sint32 no_2_turns = get_turn_count_2_elements(ride, 0);
@ -995,7 +995,7 @@ static rating_tuple get_flat_turns_rating(rct_ride* ride)
*
* rct2: 0x0065DF72
*/
static rating_tuple get_banked_turns_rating(rct_ride* ride)
static rating_tuple get_banked_turns_rating(Ride* ride)
{
sint32 no_3_plus_turns = get_turn_count_3_elements(ride, 1);
sint32 no_2_turns = get_turn_count_2_elements(ride, 1);
@ -1021,7 +1021,7 @@ static rating_tuple get_banked_turns_rating(rct_ride* ride)
*
* rct2: 0x0065E047
*/
static rating_tuple get_sloped_turns_rating(rct_ride* ride) {
static rating_tuple get_sloped_turns_rating(Ride* ride) {
rating_tuple rating;
sint32 no_4_plus_turns = get_turn_count_4_plus_elements(ride, 2);
@ -1053,7 +1053,7 @@ static rating_tuple get_inversions_ratings(uint8 inversions) {
return rating;
}
static rating_tuple get_special_track_elements_rating(uint8 type, rct_ride *ride) {
static rating_tuple get_special_track_elements_rating(uint8 type, Ride *ride) {
sint32 excitement = 0, intensity = 0, nausea = 0;
if (type == RIDE_TYPE_GHOST_TRAIN) {
if (ride_has_spinning_tunnel(ride)) {
@ -1103,7 +1103,7 @@ static rating_tuple get_special_track_elements_rating(uint8 type, rct_ride *ride
*
* rct2: 0x0065DDD1
*/
static rating_tuple ride_ratings_get_turns_ratings(rct_ride *ride)
static rating_tuple ride_ratings_get_turns_ratings(Ride *ride)
{
sint32 excitement = 0, intensity = 0, nausea = 0;
@ -1140,7 +1140,7 @@ static rating_tuple ride_ratings_get_turns_ratings(rct_ride *ride)
*
* rct2: 0x0065E1C2
*/
static rating_tuple ride_ratings_get_sheltered_ratings(rct_ride *ride)
static rating_tuple ride_ratings_get_sheltered_ratings(Ride *ride)
{
sint32 sheltered_length_shifted = (ride->sheltered_length) >> 16;
uint32 eax = min(sheltered_length_shifted, 1000);
@ -1177,7 +1177,7 @@ static rating_tuple ride_ratings_get_sheltered_ratings(rct_ride *ride)
*
* rct2: 0x0065DCDC
*/
static rating_tuple ride_ratings_get_gforce_ratings(rct_ride *ride)
static rating_tuple ride_ratings_get_gforce_ratings(Ride *ride)
{
rating_tuple result = {
.excitement = 0,
@ -1221,7 +1221,7 @@ static rating_tuple ride_ratings_get_gforce_ratings(rct_ride *ride)
*
* rct2: 0x0065E139
*/
static rating_tuple ride_ratings_get_drop_ratings(rct_ride *ride)
static rating_tuple ride_ratings_get_drop_ratings(Ride *ride)
{
rating_tuple result = {
.excitement = 0,
@ -1248,7 +1248,7 @@ static rating_tuple ride_ratings_get_drop_ratings(rct_ride *ride)
* Calculates a score based on the surrounding scenery.
* rct2: 0x0065E557
*/
static sint32 ride_ratings_get_scenery_score(rct_ride *ride)
static sint32 ride_ratings_get_scenery_score(Ride *ride)
{
sint8 i = ride_get_first_valid_station_start(ride);
rct_xy8 location;
@ -1318,7 +1318,7 @@ static void ride_ratings_add(rating_tuple * rating, sint32 excitement, sint32 in
rating->nausea = clamp(0, newNausea, INT16_MAX);
}
static void ride_ratings_apply_length(rating_tuple *ratings, rct_ride *ride, sint32 maxLength, sint32 excitementMultiplier)
static void ride_ratings_apply_length(rating_tuple *ratings, Ride *ride, sint32 maxLength, sint32 excitementMultiplier)
{
ride_ratings_add(ratings,
(min(ride_get_total_length(ride) >> 16, maxLength) * excitementMultiplier) >> 16,
@ -1326,7 +1326,7 @@ static void ride_ratings_apply_length(rating_tuple *ratings, rct_ride *ride, sin
0);
}
static void ride_ratings_apply_synchronisation(rating_tuple *ratings, rct_ride *ride, sint32 excitement, sint32 intensity)
static void ride_ratings_apply_synchronisation(rating_tuple *ratings, Ride *ride, sint32 excitement, sint32 intensity)
{
if ((ride->depart_flags & RIDE_DEPART_SYNCHRONISE_WITH_ADJACENT_STATIONS) &&
ride_has_adjacent_station(ride)
@ -1335,7 +1335,7 @@ static void ride_ratings_apply_synchronisation(rating_tuple *ratings, rct_ride *
}
}
static void ride_ratings_apply_train_length(rating_tuple *ratings, rct_ride *ride, sint32 excitementMultiplier)
static void ride_ratings_apply_train_length(rating_tuple *ratings, Ride *ride, sint32 excitementMultiplier)
{
ride_ratings_add(ratings,
((ride->num_cars_per_train - 1) * excitementMultiplier) >> 16,
@ -1343,7 +1343,7 @@ static void ride_ratings_apply_train_length(rating_tuple *ratings, rct_ride *rid
0);
}
static void ride_ratings_apply_max_speed(rating_tuple *ratings, rct_ride *ride, sint32 excitementMultiplier, sint32 intensityMultiplier, sint32 nauseaMultiplier)
static void ride_ratings_apply_max_speed(rating_tuple *ratings, Ride *ride, sint32 excitementMultiplier, sint32 intensityMultiplier, sint32 nauseaMultiplier)
{
sint32 modifier = ride->max_speed >> 16;
ride_ratings_add(ratings,
@ -1352,7 +1352,7 @@ static void ride_ratings_apply_max_speed(rating_tuple *ratings, rct_ride *ride,
(modifier * nauseaMultiplier) >> 16);
}
static void ride_ratings_apply_average_speed(rating_tuple *ratings, rct_ride *ride, sint32 excitementMultiplier, sint32 intensityMultiplier)
static void ride_ratings_apply_average_speed(rating_tuple *ratings, Ride *ride, sint32 excitementMultiplier, sint32 intensityMultiplier)
{
sint32 modifier = ride->average_speed >> 16;
ride_ratings_add(ratings,
@ -1361,7 +1361,7 @@ static void ride_ratings_apply_average_speed(rating_tuple *ratings, rct_ride *ri
0);
}
static void ride_ratings_apply_duration(rating_tuple *ratings, rct_ride *ride, sint32 maxDuration, sint32 excitementMultiplier)
static void ride_ratings_apply_duration(rating_tuple *ratings, Ride *ride, sint32 maxDuration, sint32 excitementMultiplier)
{
ride_ratings_add(ratings,
(min(ride_get_total_time(ride), maxDuration) * excitementMultiplier) >> 16,
@ -1369,7 +1369,7 @@ static void ride_ratings_apply_duration(rating_tuple *ratings, rct_ride *ride, s
0);
}
static void ride_ratings_apply_gforces(rating_tuple *ratings, rct_ride *ride, sint32 excitementMultiplier, sint32 intensityMultiplier, sint32 nauseaMultiplier)
static void ride_ratings_apply_gforces(rating_tuple *ratings, Ride *ride, sint32 excitementMultiplier, sint32 intensityMultiplier, sint32 nauseaMultiplier)
{
rating_tuple subRating = ride_ratings_get_gforce_ratings(ride);
ride_ratings_add(ratings,
@ -1378,7 +1378,7 @@ static void ride_ratings_apply_gforces(rating_tuple *ratings, rct_ride *ride, si
(subRating.nausea * nauseaMultiplier) >> 16);
}
static void ride_ratings_apply_turns(rating_tuple *ratings, rct_ride *ride, sint32 excitementMultiplier, sint32 intensityMultiplier, sint32 nauseaMultiplier)
static void ride_ratings_apply_turns(rating_tuple *ratings, Ride *ride, sint32 excitementMultiplier, sint32 intensityMultiplier, sint32 nauseaMultiplier)
{
rating_tuple subRating = ride_ratings_get_turns_ratings(ride);
ride_ratings_add(ratings,
@ -1387,7 +1387,7 @@ static void ride_ratings_apply_turns(rating_tuple *ratings, rct_ride *ride, sint
(subRating.nausea * nauseaMultiplier) >> 16);
}
static void ride_ratings_apply_drops(rating_tuple *ratings, rct_ride *ride, sint32 excitementMultiplier, sint32 intensityMultiplier, sint32 nauseaMultiplier)
static void ride_ratings_apply_drops(rating_tuple *ratings, Ride *ride, sint32 excitementMultiplier, sint32 intensityMultiplier, sint32 nauseaMultiplier)
{
rating_tuple subRating = ride_ratings_get_drop_ratings(ride);
ride_ratings_add(ratings,
@ -1396,7 +1396,7 @@ static void ride_ratings_apply_drops(rating_tuple *ratings, rct_ride *ride, sint
(subRating.nausea * nauseaMultiplier) >> 16);
}
static void ride_ratings_apply_sheltered_ratings(rating_tuple *ratings, rct_ride *ride, sint32 excitementMultiplier, sint32 intensityMultiplier, sint32 nauseaMultiplier)
static void ride_ratings_apply_sheltered_ratings(rating_tuple *ratings, Ride *ride, sint32 excitementMultiplier, sint32 intensityMultiplier, sint32 nauseaMultiplier)
{
rating_tuple subRating = ride_ratings_get_sheltered_ratings(ride);
ride_ratings_add(ratings,
@ -1405,7 +1405,7 @@ static void ride_ratings_apply_sheltered_ratings(rating_tuple *ratings, rct_ride
(subRating.nausea * nauseaMultiplier) >> 16);
}
static void ride_ratings_apply_operation_option(rating_tuple *ratings, rct_ride *ride, sint32 excitementMultiplier, sint32 intensityMultiplier, sint32 nauseaMultiplier)
static void ride_ratings_apply_operation_option(rating_tuple *ratings, Ride *ride, sint32 excitementMultiplier, sint32 intensityMultiplier, sint32 nauseaMultiplier)
{
ride_ratings_add(ratings,
(ride->operation_option * excitementMultiplier) >> 16,
@ -1413,7 +1413,7 @@ static void ride_ratings_apply_operation_option(rating_tuple *ratings, rct_ride
(ride->operation_option * nauseaMultiplier) >> 16);
}
static void ride_ratings_apply_rotations(rating_tuple *ratings, rct_ride *ride, sint32 excitementMultiplier, sint32 intensityMultiplier, sint32 nauseaMultiplier)
static void ride_ratings_apply_rotations(rating_tuple *ratings, Ride *ride, sint32 excitementMultiplier, sint32 intensityMultiplier, sint32 nauseaMultiplier)
{
ride_ratings_add(ratings,
ride->rotations * excitementMultiplier,
@ -1421,7 +1421,7 @@ static void ride_ratings_apply_rotations(rating_tuple *ratings, rct_ride *ride,
ride->rotations * nauseaMultiplier);
}
static void ride_ratings_apply_proximity(rating_tuple *ratings, rct_ride *ride, sint32 excitementMultiplier)
static void ride_ratings_apply_proximity(rating_tuple *ratings, Ride *ride, sint32 excitementMultiplier)
{
ride_ratings_add(ratings,
(ride_ratings_get_proximity_score() * excitementMultiplier) >> 16,
@ -1429,7 +1429,7 @@ static void ride_ratings_apply_proximity(rating_tuple *ratings, rct_ride *ride,
0);
}
static void ride_ratings_apply_scenery(rating_tuple *ratings, rct_ride *ride, sint32 excitementMultiplier)
static void ride_ratings_apply_scenery(rating_tuple *ratings, Ride *ride, sint32 excitementMultiplier)
{
ride_ratings_add(ratings,
(ride_ratings_get_scenery_score(ride) * excitementMultiplier) >> 16,
@ -1437,7 +1437,7 @@ static void ride_ratings_apply_scenery(rating_tuple *ratings, rct_ride *ride, si
0);
}
static void ride_ratings_apply_highest_drop_height_penalty(rating_tuple *ratings, rct_ride *ride, sint32 minHighestDropHeight, sint32 excitementPenalty, sint32 intensityPenalty, sint32 nauseaPenalty)
static void ride_ratings_apply_highest_drop_height_penalty(rating_tuple *ratings, Ride *ride, sint32 minHighestDropHeight, sint32 excitementPenalty, sint32 intensityPenalty, sint32 nauseaPenalty)
{
if (ride->highest_drop_height < minHighestDropHeight) {
ratings->excitement /= excitementPenalty;
@ -1446,7 +1446,7 @@ static void ride_ratings_apply_highest_drop_height_penalty(rating_tuple *ratings
}
}
static void ride_ratings_apply_max_speed_penalty(rating_tuple *ratings, rct_ride *ride, sint32 minMaxSpeed, sint32 excitementPenalty, sint32 intensityPenalty, sint32 nauseaPenalty)
static void ride_ratings_apply_max_speed_penalty(rating_tuple *ratings, Ride *ride, sint32 minMaxSpeed, sint32 excitementPenalty, sint32 intensityPenalty, sint32 nauseaPenalty)
{
if (ride->max_speed < minMaxSpeed) {
ratings->excitement /= excitementPenalty;
@ -1455,7 +1455,7 @@ static void ride_ratings_apply_max_speed_penalty(rating_tuple *ratings, rct_ride
}
}
static void ride_ratings_apply_num_drops_penalty(rating_tuple *ratings, rct_ride *ride, sint32 minNumDrops, sint32 excitementPenalty, sint32 intensityPenalty, sint32 nauseaPenalty)
static void ride_ratings_apply_num_drops_penalty(rating_tuple *ratings, Ride *ride, sint32 minNumDrops, sint32 excitementPenalty, sint32 intensityPenalty, sint32 nauseaPenalty)
{
if ((ride->drops & 0x3F) < minNumDrops) {
ratings->excitement /= excitementPenalty;
@ -1464,7 +1464,7 @@ static void ride_ratings_apply_num_drops_penalty(rating_tuple *ratings, rct_ride
}
}
static void ride_ratings_apply_max_negative_g_penalty(rating_tuple *ratings, rct_ride *ride, sint32 maxMaxNegativeVerticalG, sint32 excitementPenalty, sint32 intensityPenalty, sint32 nauseaPenalty)
static void ride_ratings_apply_max_negative_g_penalty(rating_tuple *ratings, Ride *ride, sint32 maxMaxNegativeVerticalG, sint32 excitementPenalty, sint32 intensityPenalty, sint32 nauseaPenalty)
{
if (ride->max_negative_vertical_g >= maxMaxNegativeVerticalG) {
ratings->excitement /= excitementPenalty;
@ -1473,7 +1473,7 @@ static void ride_ratings_apply_max_negative_g_penalty(rating_tuple *ratings, rct
}
}
static void ride_ratings_apply_max_lateral_g_penalty(rating_tuple *ratings, rct_ride *ride, sint32 minMaxLateralG, sint32 excitementPenalty, sint32 intensityPenalty, sint32 nauseaPenalty)
static void ride_ratings_apply_max_lateral_g_penalty(rating_tuple *ratings, Ride *ride, sint32 minMaxLateralG, sint32 excitementPenalty, sint32 intensityPenalty, sint32 nauseaPenalty)
{
if (ride->max_lateral_g < minMaxLateralG) {
ratings->excitement /= excitementPenalty;
@ -1482,7 +1482,7 @@ static void ride_ratings_apply_max_lateral_g_penalty(rating_tuple *ratings, rct_
}
}
static void ride_ratings_apply_excessive_lateral_g_penalty(rating_tuple *ratings, rct_ride *ride)
static void ride_ratings_apply_excessive_lateral_g_penalty(rating_tuple *ratings, Ride *ride)
{
#ifndef ORIGINAL_RATINGS
if (ride->max_lateral_g > FIXED_2DP(2,80)) {
@ -1495,7 +1495,7 @@ static void ride_ratings_apply_excessive_lateral_g_penalty(rating_tuple *ratings
#endif
}
static void ride_ratings_apply_first_length_penalty(rating_tuple *ratings, rct_ride *ride, sint32 minFirstLength, sint32 excitementPenalty, sint32 intensityPenalty, sint32 nauseaPenalty)
static void ride_ratings_apply_first_length_penalty(rating_tuple *ratings, Ride *ride, sint32 minFirstLength, sint32 excitementPenalty, sint32 intensityPenalty, sint32 nauseaPenalty)
{
if (ride->length[0] < minFirstLength) {
ratings->excitement /= excitementPenalty;
@ -1508,7 +1508,7 @@ static void ride_ratings_apply_first_length_penalty(rating_tuple *ratings, rct_r
#pragma region Ride rating calculation functions
static void ride_ratings_calculate_spiral_roller_coaster(rct_ride *ride)
static void ride_ratings_calculate_spiral_roller_coaster(Ride *ride)
{
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
return;
@ -1554,7 +1554,7 @@ static void ride_ratings_calculate_spiral_roller_coaster(rct_ride *ride)
ride->inversions |= get_num_of_sheltered_eighths(ride) << 5;
}
static void ride_ratings_calculate_stand_up_roller_coaster(rct_ride *ride)
static void ride_ratings_calculate_stand_up_roller_coaster(Ride *ride)
{
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
return;
@ -1593,7 +1593,7 @@ static void ride_ratings_calculate_stand_up_roller_coaster(rct_ride *ride)
ride->inversions |= get_num_of_sheltered_eighths(ride) << 5;
}
static void ride_ratings_calculate_suspended_swinging_coaster(rct_ride *ride)
static void ride_ratings_calculate_suspended_swinging_coaster(Ride *ride)
{
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
return;
@ -1634,7 +1634,7 @@ static void ride_ratings_calculate_suspended_swinging_coaster(rct_ride *ride)
ride->inversions |= get_num_of_sheltered_eighths(ride) << 5;
}
static void ride_ratings_calculate_inverted_roller_coaster(rct_ride *ride)
static void ride_ratings_calculate_inverted_roller_coaster(Ride *ride)
{
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
return;
@ -1678,7 +1678,7 @@ static void ride_ratings_calculate_inverted_roller_coaster(rct_ride *ride)
ride->inversions |= get_num_of_sheltered_eighths(ride) << 5;
}
static void ride_ratings_calculate_junior_roller_coaster(rct_ride *ride)
static void ride_ratings_calculate_junior_roller_coaster(Ride *ride)
{
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
return;
@ -1717,7 +1717,7 @@ static void ride_ratings_calculate_junior_roller_coaster(rct_ride *ride)
ride->inversions |= get_num_of_sheltered_eighths(ride) << 5;
}
static void ride_ratings_calculate_miniature_railway(rct_ride *ride)
static void ride_ratings_calculate_miniature_railway(Ride *ride)
{
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
return;
@ -1753,7 +1753,7 @@ static void ride_ratings_calculate_miniature_railway(rct_ride *ride)
ride->inversions |= get_num_of_sheltered_eighths(ride) << 5;
}
static void ride_ratings_calculate_monorail(rct_ride *ride)
static void ride_ratings_calculate_monorail(Ride *ride)
{
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
return;
@ -1789,7 +1789,7 @@ static void ride_ratings_calculate_monorail(rct_ride *ride)
ride->inversions |= get_num_of_sheltered_eighths(ride) << 5;
}
static void ride_ratings_calculate_mini_suspended_coaster(rct_ride *ride)
static void ride_ratings_calculate_mini_suspended_coaster(Ride *ride)
{
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
return;
@ -1829,7 +1829,7 @@ static void ride_ratings_calculate_mini_suspended_coaster(rct_ride *ride)
ride->inversions |= get_num_of_sheltered_eighths(ride) << 5;
}
static void ride_ratings_calculate_boat_ride(rct_ride *ride)
static void ride_ratings_calculate_boat_ride(Ride *ride)
{
ride->unreliability_factor = 7;
set_unreliability_factor(ride);
@ -1861,7 +1861,7 @@ static void ride_ratings_calculate_boat_ride(rct_ride *ride)
ride->inversions |= 0 << 5;
}
static void ride_ratings_calculate_wooden_wild_mouse(rct_ride *ride)
static void ride_ratings_calculate_wooden_wild_mouse(Ride *ride)
{
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
return;
@ -1903,7 +1903,7 @@ static void ride_ratings_calculate_wooden_wild_mouse(rct_ride *ride)
ride->inversions |= get_num_of_sheltered_eighths(ride) << 5;
}
static void ride_ratings_calculate_steeplechase(rct_ride *ride)
static void ride_ratings_calculate_steeplechase(Ride *ride)
{
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
return;
@ -1944,7 +1944,7 @@ static void ride_ratings_calculate_steeplechase(rct_ride *ride)
ride->inversions |= get_num_of_sheltered_eighths(ride) << 5;
}
static void ride_ratings_calculate_car_ride(rct_ride *ride)
static void ride_ratings_calculate_car_ride(Ride *ride)
{
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
return;
@ -1979,7 +1979,7 @@ static void ride_ratings_calculate_car_ride(rct_ride *ride)
ride->inversions |= get_num_of_sheltered_eighths(ride) << 5;
}
static void ride_ratings_calculate_launched_freefall(rct_ride *ride)
static void ride_ratings_calculate_launched_freefall(Ride *ride)
{
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
return;
@ -2030,7 +2030,7 @@ static void ride_ratings_calculate_launched_freefall(rct_ride *ride)
ride->inversions |= get_num_of_sheltered_eighths(ride) << 5;
}
static void ride_ratings_calculate_bobsleigh_coaster(rct_ride *ride)
static void ride_ratings_calculate_bobsleigh_coaster(Ride *ride)
{
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
return;
@ -2069,7 +2069,7 @@ static void ride_ratings_calculate_bobsleigh_coaster(rct_ride *ride)
ride->inversions |= get_num_of_sheltered_eighths(ride) << 5;
}
static void ride_ratings_calculate_observation_tower(rct_ride *ride)
static void ride_ratings_calculate_observation_tower(Ride *ride)
{
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
return;
@ -2102,7 +2102,7 @@ static void ride_ratings_calculate_observation_tower(rct_ride *ride)
ride->excitement /= 4;
}
static void ride_ratings_calculate_looping_roller_coaster(rct_ride *ride)
static void ride_ratings_calculate_looping_roller_coaster(Ride *ride)
{
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
return;
@ -2148,7 +2148,7 @@ static void ride_ratings_calculate_looping_roller_coaster(rct_ride *ride)
ride->inversions |= get_num_of_sheltered_eighths(ride) << 5;
}
static void ride_ratings_calculate_dinghy_slide(rct_ride *ride)
static void ride_ratings_calculate_dinghy_slide(Ride *ride)
{
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
return;
@ -2187,7 +2187,7 @@ static void ride_ratings_calculate_dinghy_slide(rct_ride *ride)
ride->inversions |= get_num_of_sheltered_eighths(ride) << 5;
}
static void ride_ratings_calculate_mine_train_coaster(rct_ride *ride)
static void ride_ratings_calculate_mine_train_coaster(Ride *ride)
{
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
return;
@ -2228,7 +2228,7 @@ static void ride_ratings_calculate_mine_train_coaster(rct_ride *ride)
ride->inversions |= get_num_of_sheltered_eighths(ride) << 5;
}
static void ride_ratings_calculate_chairlift(rct_ride *ride)
static void ride_ratings_calculate_chairlift(Ride *ride)
{
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
return;
@ -2270,7 +2270,7 @@ static void ride_ratings_calculate_chairlift(rct_ride *ride)
ride->inversions |= edx << 5;
}
static void ride_ratings_calculate_corkscrew_roller_coaster(rct_ride *ride)
static void ride_ratings_calculate_corkscrew_roller_coaster(Ride *ride)
{
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
return;
@ -2316,7 +2316,7 @@ static void ride_ratings_calculate_corkscrew_roller_coaster(rct_ride *ride)
ride->inversions |= get_num_of_sheltered_eighths(ride) << 5;
}
static void ride_ratings_calculate_maze(rct_ride *ride)
static void ride_ratings_calculate_maze(Ride *ride)
{
ride->lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
ride->lifecycle_flags |= RIDE_LIFECYCLE_NO_RAW_STATS;
@ -2346,7 +2346,7 @@ static void ride_ratings_calculate_maze(rct_ride *ride)
ride->inversions |= 0 << 5;
}
static void ride_ratings_calculate_spiral_slide(rct_ride *ride)
static void ride_ratings_calculate_spiral_slide(Ride *ride)
{
ride->lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
ride->lifecycle_flags |= RIDE_LIFECYCLE_NO_RAW_STATS;
@ -2378,7 +2378,7 @@ static void ride_ratings_calculate_spiral_slide(rct_ride *ride)
ride->inversions |= 2 << 5;
}
static void ride_ratings_calculate_go_karts(rct_ride *ride)
static void ride_ratings_calculate_go_karts(Ride *ride)
{
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
return;
@ -2426,7 +2426,7 @@ static void ride_ratings_calculate_go_karts(rct_ride *ride)
ride->excitement /= 2;
}
static void ride_ratings_calculate_log_flume(rct_ride *ride)
static void ride_ratings_calculate_log_flume(Ride *ride)
{
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
return;
@ -2459,7 +2459,7 @@ static void ride_ratings_calculate_log_flume(rct_ride *ride)
ride->inversions |= get_num_of_sheltered_eighths(ride) << 5;
}
static void ride_ratings_calculate_river_rapids(rct_ride *ride)
static void ride_ratings_calculate_river_rapids(Ride *ride)
{
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
return;
@ -2493,7 +2493,7 @@ static void ride_ratings_calculate_river_rapids(rct_ride *ride)
ride->inversions |= get_num_of_sheltered_eighths(ride) << 5;
}
static void ride_ratings_calculate_dodgems(rct_ride *ride)
static void ride_ratings_calculate_dodgems(Ride *ride)
{
ride->lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
ride->lifecycle_flags |= RIDE_LIFECYCLE_NO_RAW_STATS;
@ -2536,7 +2536,7 @@ static void ride_ratings_calculate_dodgems(rct_ride *ride)
ride->inversions |= 7 << 5;
}
static void ride_ratings_calculate_pirate_ship(rct_ride *ride)
static void ride_ratings_calculate_pirate_ship(Ride *ride)
{
ride->lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
ride->lifecycle_flags |= RIDE_LIFECYCLE_NO_RAW_STATS;
@ -2565,7 +2565,7 @@ static void ride_ratings_calculate_pirate_ship(rct_ride *ride)
ride->inversions |= 0 << 5;
}
static void ride_ratings_calculate_inverter_ship(rct_ride *ride)
static void ride_ratings_calculate_inverter_ship(Ride *ride)
{
ride->lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
ride->lifecycle_flags |= RIDE_LIFECYCLE_NO_RAW_STATS;
@ -2594,25 +2594,25 @@ static void ride_ratings_calculate_inverter_ship(rct_ride *ride)
ride->inversions |= 0 << 5;
}
static void ride_ratings_calculate_food_stall(rct_ride *ride)
static void ride_ratings_calculate_food_stall(Ride *ride)
{
ride->upkeep_cost = ride_compute_upkeep(ride);
ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
}
static void ride_ratings_calculate_drink_stall(rct_ride *ride)
static void ride_ratings_calculate_drink_stall(Ride *ride)
{
ride->upkeep_cost = ride_compute_upkeep(ride);
ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
}
static void ride_ratings_calculate_shop(rct_ride *ride)
static void ride_ratings_calculate_shop(Ride *ride)
{
ride->upkeep_cost = ride_compute_upkeep(ride);
ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
}
static void ride_ratings_calculate_merry_go_round(rct_ride *ride)
static void ride_ratings_calculate_merry_go_round(Ride *ride)
{
ride->lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
ride->lifecycle_flags |= RIDE_LIFECYCLE_NO_RAW_STATS;
@ -2635,19 +2635,19 @@ static void ride_ratings_calculate_merry_go_round(rct_ride *ride)
ride->inversions |= 7 << 5;
}
static void ride_ratings_calculate_information_kiosk(rct_ride *ride)
static void ride_ratings_calculate_information_kiosk(Ride *ride)
{
ride->upkeep_cost = ride_compute_upkeep(ride);
ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
}
static void ride_ratings_calculate_toilets(rct_ride *ride)
static void ride_ratings_calculate_toilets(Ride *ride)
{
ride->upkeep_cost = ride_compute_upkeep(ride);
ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
}
static void ride_ratings_calculate_ferris_wheel(rct_ride *ride)
static void ride_ratings_calculate_ferris_wheel(Ride *ride)
{
ride->lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
ride->lifecycle_flags |= RIDE_LIFECYCLE_NO_RAW_STATS;
@ -2670,7 +2670,7 @@ static void ride_ratings_calculate_ferris_wheel(rct_ride *ride)
ride->inversions |= 0 << 5;
}
static void ride_ratings_calculate_motion_simulator(rct_ride *ride)
static void ride_ratings_calculate_motion_simulator(Ride *ride)
{
ride->lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
ride->lifecycle_flags |= RIDE_LIFECYCLE_NO_RAW_STATS;
@ -2701,7 +2701,7 @@ static void ride_ratings_calculate_motion_simulator(rct_ride *ride)
ride->inversions |= 7 << 5;
}
static void ride_ratings_calculate_3d_cinema(rct_ride *ride)
static void ride_ratings_calculate_3d_cinema(Ride *ride)
{
ride->lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
ride->lifecycle_flags |= RIDE_LIFECYCLE_NO_RAW_STATS;
@ -2741,7 +2741,7 @@ static void ride_ratings_calculate_3d_cinema(rct_ride *ride)
ride->inversions |= 7 << 5;
}
static void ride_ratings_calculate_top_spin(rct_ride *ride)
static void ride_ratings_calculate_top_spin(Ride *ride)
{
ride->lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
ride->lifecycle_flags |= RIDE_LIFECYCLE_NO_RAW_STATS;
@ -2783,7 +2783,7 @@ static void ride_ratings_calculate_top_spin(rct_ride *ride)
ride->inversions |= 0 << 5;
}
static void ride_ratings_calculate_space_rings(rct_ride *ride)
static void ride_ratings_calculate_space_rings(Ride *ride)
{
ride->lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
ride->lifecycle_flags |= RIDE_LIFECYCLE_NO_RAW_STATS;
@ -2806,7 +2806,7 @@ static void ride_ratings_calculate_space_rings(rct_ride *ride)
ride->inversions |= 0 << 5;
}
static void ride_ratings_calculate_reverse_freefall_coaster(rct_ride *ride)
static void ride_ratings_calculate_reverse_freefall_coaster(Ride *ride)
{
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
return;
@ -2837,7 +2837,7 @@ static void ride_ratings_calculate_reverse_freefall_coaster(rct_ride *ride)
ride->inversions |= get_num_of_sheltered_eighths(ride) << 5;
}
static void ride_ratings_calculate_lift(rct_ride *ride)
static void ride_ratings_calculate_lift(Ride *ride)
{
sint32 totalLength;
@ -2874,7 +2874,7 @@ static void ride_ratings_calculate_lift(rct_ride *ride)
ride->excitement /= 4;
}
static void ride_ratings_calculate_vertical_drop_roller_coaster(rct_ride *ride)
static void ride_ratings_calculate_vertical_drop_roller_coaster(Ride *ride)
{
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
return;
@ -2913,13 +2913,13 @@ static void ride_ratings_calculate_vertical_drop_roller_coaster(rct_ride *ride)
ride->inversions |= get_num_of_sheltered_eighths(ride) << 5;
}
static void ride_ratings_calculate_cash_machine(rct_ride *ride)
static void ride_ratings_calculate_cash_machine(Ride *ride)
{
ride->upkeep_cost = ride_compute_upkeep(ride);
ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
}
static void ride_ratings_calculate_twist(rct_ride *ride)
static void ride_ratings_calculate_twist(Ride *ride)
{
ride->lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
ride->lifecycle_flags |= RIDE_LIFECYCLE_NO_RAW_STATS;
@ -2942,7 +2942,7 @@ static void ride_ratings_calculate_twist(rct_ride *ride)
ride->inversions |= 0 << 5;
}
static void ride_ratings_calculate_haunted_house(rct_ride *ride)
static void ride_ratings_calculate_haunted_house(Ride *ride)
{
ride->lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
ride->lifecycle_flags |= RIDE_LIFECYCLE_NO_RAW_STATS;
@ -2967,7 +2967,7 @@ static void ride_ratings_calculate_haunted_house(rct_ride *ride)
ride->inversions |= 0xE0;
}
static void ride_ratings_calculate_flying_roller_coaster(rct_ride *ride)
static void ride_ratings_calculate_flying_roller_coaster(Ride *ride)
{
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
return;
@ -3013,7 +3013,7 @@ static void ride_ratings_calculate_flying_roller_coaster(rct_ride *ride)
ride->inversions |= get_num_of_sheltered_eighths(ride) << 5;
}
static void ride_ratings_calculate_virginia_reel(rct_ride *ride)
static void ride_ratings_calculate_virginia_reel(Ride *ride)
{
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
return;
@ -3051,7 +3051,7 @@ static void ride_ratings_calculate_virginia_reel(rct_ride *ride)
ride->inversions |= get_num_of_sheltered_eighths(ride) << 5;
}
static void ride_ratings_calculate_splash_boats(rct_ride *ride)
static void ride_ratings_calculate_splash_boats(Ride *ride)
{
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
return;
@ -3084,7 +3084,7 @@ static void ride_ratings_calculate_splash_boats(rct_ride *ride)
ride->inversions |= get_num_of_sheltered_eighths(ride) << 5;
}
static void ride_ratings_calculate_mini_helicopters(rct_ride *ride)
static void ride_ratings_calculate_mini_helicopters(Ride *ride)
{
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
return;
@ -3119,7 +3119,7 @@ static void ride_ratings_calculate_mini_helicopters(rct_ride *ride)
ride->inversions |= 6 << 5;
}
static void ride_ratings_calculate_lay_down_roller_coaster(rct_ride *ride)
static void ride_ratings_calculate_lay_down_roller_coaster(Ride *ride)
{
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
return;
@ -3168,7 +3168,7 @@ static void ride_ratings_calculate_lay_down_roller_coaster(rct_ride *ride)
ride->inversions |= get_num_of_sheltered_eighths(ride) << 5;
}
static void ride_ratings_calculate_suspended_monorail(rct_ride *ride)
static void ride_ratings_calculate_suspended_monorail(Ride *ride)
{
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
return;
@ -3204,7 +3204,7 @@ static void ride_ratings_calculate_suspended_monorail(rct_ride *ride)
ride->inversions |= edx << 5;
}
static void ride_ratings_calculate_reverser_roller_coaster(rct_ride *ride)
static void ride_ratings_calculate_reverser_roller_coaster(Ride *ride)
{
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
return;
@ -3255,7 +3255,7 @@ static void ride_ratings_calculate_reverser_roller_coaster(rct_ride *ride)
ride->inversions |= get_num_of_sheltered_eighths(ride) << 5;
}
static void ride_ratings_calculate_heartline_twister_coaster(rct_ride *ride)
static void ride_ratings_calculate_heartline_twister_coaster(Ride *ride)
{
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
return;
@ -3296,7 +3296,7 @@ static void ride_ratings_calculate_heartline_twister_coaster(rct_ride *ride)
ride->inversions |= get_num_of_sheltered_eighths(ride) << 5;
}
static void ride_ratings_calculate_mini_golf(rct_ride *ride)
static void ride_ratings_calculate_mini_golf(Ride *ride)
{
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
return;
@ -3337,13 +3337,13 @@ static void ride_ratings_calculate_mini_golf(rct_ride *ride)
ride->inversions |= get_num_of_sheltered_eighths(ride) << 5;
}
static void ride_ratings_calculate_first_aid(rct_ride *ride)
static void ride_ratings_calculate_first_aid(Ride *ride)
{
ride->upkeep_cost = ride_compute_upkeep(ride);
ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_INCOME;
}
static void ride_ratings_calculate_circus_show(rct_ride *ride)
static void ride_ratings_calculate_circus_show(Ride *ride)
{
ride->lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
ride->lifecycle_flags |= RIDE_LIFECYCLE_NO_RAW_STATS;
@ -3368,7 +3368,7 @@ static void ride_ratings_calculate_circus_show(rct_ride *ride)
ride->inversions |= 7 << 5;
}
static void ride_ratings_calculate_ghost_train(rct_ride *ride)
static void ride_ratings_calculate_ghost_train(Ride *ride)
{
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
return;
@ -3402,7 +3402,7 @@ static void ride_ratings_calculate_ghost_train(rct_ride *ride)
ride->inversions |= get_num_of_sheltered_eighths(ride) << 5;
}
static void ride_ratings_calculate_twister_roller_coaster(rct_ride *ride)
static void ride_ratings_calculate_twister_roller_coaster(Ride *ride)
{
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
return;
@ -3448,7 +3448,7 @@ static void ride_ratings_calculate_twister_roller_coaster(rct_ride *ride)
ride->inversions |= get_num_of_sheltered_eighths(ride) << 5;
}
static void ride_ratings_calculate_wooden_roller_coaster(rct_ride *ride)
static void ride_ratings_calculate_wooden_roller_coaster(Ride *ride)
{
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
return;
@ -3489,7 +3489,7 @@ static void ride_ratings_calculate_wooden_roller_coaster(rct_ride *ride)
ride->inversions |= get_num_of_sheltered_eighths(ride) << 5;
}
static void ride_ratings_calculate_side_friction_roller_coaster(rct_ride *ride)
static void ride_ratings_calculate_side_friction_roller_coaster(Ride *ride)
{
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
return;
@ -3529,7 +3529,7 @@ static void ride_ratings_calculate_side_friction_roller_coaster(rct_ride *ride)
ride->inversions |= get_num_of_sheltered_eighths(ride) << 5;
}
static void ride_ratings_calculate_wild_mouse(rct_ride *ride)
static void ride_ratings_calculate_wild_mouse(Ride *ride)
{
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
return;
@ -3570,7 +3570,7 @@ static void ride_ratings_calculate_wild_mouse(rct_ride *ride)
ride->inversions |= get_num_of_sheltered_eighths(ride) << 5;
}
static void ride_ratings_calculate_multi_dimension_roller_coaster(rct_ride *ride)
static void ride_ratings_calculate_multi_dimension_roller_coaster(Ride *ride)
{
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
return;
@ -3616,7 +3616,7 @@ static void ride_ratings_calculate_multi_dimension_roller_coaster(rct_ride *ride
ride->inversions |= get_num_of_sheltered_eighths(ride) << 5;
}
static void ride_ratings_calculate_giga_coaster(rct_ride *ride)
static void ride_ratings_calculate_giga_coaster(Ride *ride)
{
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
return;
@ -3662,7 +3662,7 @@ static void ride_ratings_calculate_giga_coaster(rct_ride *ride)
ride->inversions |= get_num_of_sheltered_eighths(ride) << 5;
}
static void ride_ratings_calculate_roto_drop(rct_ride *ride)
static void ride_ratings_calculate_roto_drop(Ride *ride)
{
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
return;
@ -3694,7 +3694,7 @@ static void ride_ratings_calculate_roto_drop(rct_ride *ride)
ride->inversions |= get_num_of_sheltered_eighths(ride) << 5;
}
static void ride_ratings_calculate_flying_saucers(rct_ride *ride)
static void ride_ratings_calculate_flying_saucers(Ride *ride)
{
ride->lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
ride->lifecycle_flags |= RIDE_LIFECYCLE_NO_RAW_STATS;
@ -3740,7 +3740,7 @@ static void ride_ratings_calculate_flying_saucers(rct_ride *ride)
ride->inversions |= 0 << 5;
}
static void ride_ratings_calculate_crooked_house(rct_ride *ride)
static void ride_ratings_calculate_crooked_house(Ride *ride)
{
ride->lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
ride->lifecycle_flags |= RIDE_LIFECYCLE_NO_RAW_STATS;
@ -3765,7 +3765,7 @@ static void ride_ratings_calculate_crooked_house(rct_ride *ride)
ride->inversions |= 0xE0;
}
static void ride_ratings_calculate_monorail_cycles(rct_ride *ride)
static void ride_ratings_calculate_monorail_cycles(Ride *ride)
{
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
return;
@ -3800,7 +3800,7 @@ static void ride_ratings_calculate_monorail_cycles(rct_ride *ride)
ride->inversions |= get_num_of_sheltered_eighths(ride) << 5;
}
static void ride_ratings_calculate_compact_inverted_coaster(rct_ride *ride)
static void ride_ratings_calculate_compact_inverted_coaster(Ride *ride)
{
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
return;
@ -3844,7 +3844,7 @@ static void ride_ratings_calculate_compact_inverted_coaster(rct_ride *ride)
ride->inversions |= get_num_of_sheltered_eighths(ride) << 5;
}
static void ride_ratings_calculate_water_coaster(rct_ride *ride)
static void ride_ratings_calculate_water_coaster(Ride *ride)
{
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
return;
@ -3886,7 +3886,7 @@ static void ride_ratings_calculate_water_coaster(rct_ride *ride)
ride->inversions |= get_num_of_sheltered_eighths(ride) << 5;
}
static void ride_ratings_calculate_air_powered_vertical_coaster(rct_ride *ride)
static void ride_ratings_calculate_air_powered_vertical_coaster(Ride *ride)
{
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
return;
@ -3918,7 +3918,7 @@ static void ride_ratings_calculate_air_powered_vertical_coaster(rct_ride *ride)
ride->inversions |= get_num_of_sheltered_eighths(ride) << 5;
}
static void ride_ratings_calculate_inverted_hairpin_coaster(rct_ride *ride)
static void ride_ratings_calculate_inverted_hairpin_coaster(Ride *ride)
{
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
return;
@ -3960,7 +3960,7 @@ static void ride_ratings_calculate_inverted_hairpin_coaster(rct_ride *ride)
ride->inversions |= get_num_of_sheltered_eighths(ride) << 5;
}
static void ride_ratings_calculate_magic_carpet(rct_ride *ride)
static void ride_ratings_calculate_magic_carpet(Ride *ride)
{
ride->lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
ride->lifecycle_flags |= RIDE_LIFECYCLE_NO_RAW_STATS;
@ -3989,7 +3989,7 @@ static void ride_ratings_calculate_magic_carpet(rct_ride *ride)
ride->inversions |= 0 << 5;
}
static void ride_ratings_calculate_submarine_ride(rct_ride *ride)
static void ride_ratings_calculate_submarine_ride(Ride *ride)
{
ride->unreliability_factor = 7;
set_unreliability_factor(ride);
@ -4014,7 +4014,7 @@ static void ride_ratings_calculate_submarine_ride(rct_ride *ride)
ride->inversions |= 0 << 5;
}
static void ride_ratings_calculate_river_rafts(rct_ride *ride)
static void ride_ratings_calculate_river_rafts(Ride *ride)
{
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
return;
@ -4045,7 +4045,7 @@ static void ride_ratings_calculate_river_rafts(rct_ride *ride)
ride->inversions |= get_num_of_sheltered_eighths(ride) << 5;
}
static void ride_ratings_calculate_enterprise(rct_ride *ride)
static void ride_ratings_calculate_enterprise(Ride *ride)
{
ride->lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
ride->lifecycle_flags |= RIDE_LIFECYCLE_NO_RAW_STATS;
@ -4078,7 +4078,7 @@ static void ride_ratings_calculate_enterprise(rct_ride *ride)
ride->inversions |= 3 << 5;
}
static void ride_ratings_calculate_inverted_impulse_coaster(rct_ride *ride)
static void ride_ratings_calculate_inverted_impulse_coaster(Ride *ride)
{
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
return;
@ -4116,7 +4116,7 @@ static void ride_ratings_calculate_inverted_impulse_coaster(rct_ride *ride)
ride->inversions |= get_num_of_sheltered_eighths(ride) << 5;
}
static void ride_ratings_calculate_mini_roller_coaster(rct_ride *ride)
static void ride_ratings_calculate_mini_roller_coaster(Ride *ride)
{
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
return;
@ -4156,7 +4156,7 @@ static void ride_ratings_calculate_mini_roller_coaster(rct_ride *ride)
ride->inversions |= get_num_of_sheltered_eighths(ride) << 5;
}
static void ride_ratings_calculate_mine_ride(rct_ride *ride)
static void ride_ratings_calculate_mine_ride(Ride *ride)
{
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
return;
@ -4193,7 +4193,7 @@ static void ride_ratings_calculate_mine_ride(rct_ride *ride)
ride->inversions |= get_num_of_sheltered_eighths(ride) << 5;
}
static void ride_ratings_calculate_lim_launched_roller_coaster(rct_ride *ride)
static void ride_ratings_calculate_lim_launched_roller_coaster(Ride *ride)
{
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED))
return;

18
src/openrct2/ride/ride_ratings.h
View File

@ -18,7 +18,23 @@
#define _RIDE_RATINGS_H_
#include "../common.h"
#include "ride.h"
typedef fixed16_2dp ride_rating;
// Convenience function for writing ride ratings. The result is a 16 bit signed
// integer. To create the ride rating 3.65 type RIDE_RATING(3,65)
#define RIDE_RATING(whole, fraction) FIXED_2DP(whole, fraction)
#define RIDE_RATING_UNDEFINED (ride_rating)(uint16)0xFFFF
#pragma pack(push, 1)
// Used for return values, for functions that modify all three.
typedef struct rating_tuple {
ride_rating excitement;
ride_rating intensity;
ride_rating nausea;
} rating_tuple;
assert_struct_size(rating_tuple, 6);
enum {
RIDE_RATING_STATION_FLAG_NO_ENTRANCE = 1 << 0

2
src/openrct2/ride/shops/facility.c
View File

@ -33,7 +33,7 @@ static void facility_paint_setup(paint_session * session, uint8 rideIndex, uint8
{
bool hasSupports = wooden_a_supports_paint_setup(session, direction & 1, 0, height, gTrackColours[SCHEME_3], NULL);
rct_ride *ride = get_ride(rideIndex);
Ride *ride = get_ride(rideIndex);
rct_ride_entry *rideEntry = get_ride_entry(ride->subtype);
rct_ride_entry_vehicle *firstVehicleEntry = &rideEntry->vehicles[0];

2
src/openrct2/ride/shops/shop.c
View File

@ -33,7 +33,7 @@ static void shop_paint_setup(paint_session * session, uint8 rideIndex, uint8 tra
{
bool hasSupports = wooden_a_supports_paint_setup(session, direction & 1, 0, height, gTrackColours[SCHEME_3], NULL);
rct_ride *ride = get_ride(rideIndex);
Ride *ride = get_ride(rideIndex);
rct_ride_entry *rideEntry = get_ride_entry(ride->subtype);
rct_ride_entry_vehicle *firstVehicleEntry = &rideEntry->vehicles[0];

36
src/openrct2/ride/station.c
View File

@ -19,18 +19,18 @@
#include "../world/sprite.h"
#include "station.h"
static void ride_update_station_blocksection(rct_ride *ride, sint32 stationIndex);
static void ride_update_station_bumpercar(rct_ride *ride, sint32 stationIndex);
static void ride_update_station_normal(rct_ride *ride, sint32 stationIndex);
static void ride_update_station_race(rct_ride *ride, sint32 stationIndex);
static void ride_race_init_vehicle_speeds(rct_ride *ride);
static void ride_invalidate_station_start(rct_ride *ride, sint32 stationIndex, bool greenLight);
static void ride_update_station_blocksection(Ride *ride, sint32 stationIndex);
static void ride_update_station_bumpercar(Ride *ride, sint32 stationIndex);
static void ride_update_station_normal(Ride *ride, sint32 stationIndex);
static void ride_update_station_race(Ride *ride, sint32 stationIndex);
static void ride_race_init_vehicle_speeds(Ride *ride);
static void ride_invalidate_station_start(Ride *ride, sint32 stationIndex, bool greenLight);
/**
*
* rct2: 0x006ABFFB
*/
void ride_update_station(rct_ride *ride, sint32 stationIndex)
void ride_update_station(Ride *ride, sint32 stationIndex)
{
if (ride->station_starts[stationIndex].xy == RCT_XY8_UNDEFINED)
return;
@ -56,7 +56,7 @@ void ride_update_station(rct_ride *ride, sint32 stationIndex)
*
* rct2: 0x006AC0A1
*/
static void ride_update_station_blocksection(rct_ride *ride, sint32 stationIndex)
static void ride_update_station_blocksection(Ride *ride, sint32 stationIndex)
{
rct_map_element *mapElement;
@ -81,7 +81,7 @@ static void ride_update_station_blocksection(rct_ride *ride, sint32 stationIndex
*
* rct2: 0x006AC12B
*/
static void ride_update_station_bumpercar(rct_ride *ride, sint32 stationIndex)
static void ride_update_station_bumpercar(Ride *ride, sint32 stationIndex)
{
// Change of station depart flag should really call invalidate_station_start
// but since dodgems do not have station lights there is no point.
@ -131,7 +131,7 @@ static void ride_update_station_bumpercar(rct_ride *ride, sint32 stationIndex)
*
* rct2: 0x006AC02C
*/
static void ride_update_station_normal(rct_ride *ride, sint32 stationIndex)
static void ride_update_station_normal(Ride *ride, sint32 stationIndex)
{
sint32 time;
@ -163,7 +163,7 @@ static void ride_update_station_normal(rct_ride *ride, sint32 stationIndex)
*
* rct2: 0x006AC1DF
*/
static void ride_update_station_race(rct_ride *ride, sint32 stationIndex)
static void ride_update_station_race(Ride *ride, sint32 stationIndex)
{
if (
ride->status == RIDE_STATUS_CLOSED ||
@ -230,7 +230,7 @@ static void ride_update_station_race(rct_ride *ride, sint32 stationIndex)
* set the speed of the go kart type vehicle at the start to a random value or alter if peep name is an easter egg
* @param ride (esi)
*/
static void ride_race_init_vehicle_speeds(rct_ride *ride)
static void ride_race_init_vehicle_speeds(Ride *ride)
{
for (sint32 i = 0; i < ride->num_vehicles; i++) {
rct_vehicle *vehicle = &get_sprite(ride->vehicles[i])->vehicle;
@ -268,7 +268,7 @@ static void ride_race_init_vehicle_speeds(rct_ride *ride)
*
* rct2: 0x006AC2C7
*/
static void ride_invalidate_station_start(rct_ride *ride, sint32 stationIndex, bool greenLight)
static void ride_invalidate_station_start(Ride *ride, sint32 stationIndex, bool greenLight)
{
sint32 x, y;
rct_map_element *mapElement;
@ -287,7 +287,7 @@ static void ride_invalidate_station_start(rct_ride *ride, sint32 stationIndex, b
map_invalidate_tile_zoom1(x, y, mapElement->base_height * 8, mapElement->clearance_height * 8);
}
rct_map_element *ride_get_station_start_track_element(rct_ride *ride, sint32 stationIndex)
rct_map_element *ride_get_station_start_track_element(Ride *ride, sint32 stationIndex)
{
sint32 x, y, z;
rct_map_element *mapElement;
@ -307,7 +307,7 @@ rct_map_element *ride_get_station_start_track_element(rct_ride *ride, sint32 sta
return NULL;
}
rct_map_element *ride_get_station_exit_element(rct_ride *ride, sint32 x, sint32 y, sint32 z)
rct_map_element *ride_get_station_exit_element(Ride *ride, sint32 x, sint32 y, sint32 z)
{
rct_map_element *mapElement;
@ -321,7 +321,7 @@ rct_map_element *ride_get_station_exit_element(rct_ride *ride, sint32 x, sint32
return NULL;
}
sint32 ride_get_first_valid_station_exit(rct_ride * ride)
sint32 ride_get_first_valid_station_exit(Ride * ride)
{
for (sint32 i = 0; i < MAX_STATIONS; i++)
{
@ -333,7 +333,7 @@ sint32 ride_get_first_valid_station_exit(rct_ride * ride)
return -1;
}
sint8 ride_get_first_valid_station_start(const rct_ride *ride)
sint8 ride_get_first_valid_station_start(const Ride *ride)
{
for (sint32 i = 0; i < MAX_STATIONS; i++)
{
@ -345,7 +345,7 @@ sint8 ride_get_first_valid_station_start(const rct_ride *ride)
return -1;
}
sint8 ride_get_first_empty_station_start(const rct_ride *ride)
sint8 ride_get_first_empty_station_start(const Ride *ride)
{
for (sint32 i = 0; i < MAX_STATIONS; i++)
{

10
src/openrct2/ride/station.h
View File

@ -21,12 +21,10 @@
#include "../world/map.h"
#include "ride.h"
#define MAX_STATIONS 4
void ride_update_station(rct_ride *ride, sint32 stationIndex);
sint32 ride_get_first_valid_station_exit(rct_ride * ride);
sint8 ride_get_first_valid_station_start(const rct_ride *ride);
sint8 ride_get_first_empty_station_start(const rct_ride *ride);
void ride_update_station(Ride *ride, sint32 stationIndex);
sint32 ride_get_first_valid_station_exit(Ride * ride);
sint8 ride_get_first_valid_station_start(const Ride *ride);
sint8 ride_get_first_empty_station_start(const Ride *ride);
#endif

4
src/openrct2/ride/thrill/3d_cinema.c
View File

@ -27,7 +27,7 @@ static void paint_3d_cinema_structure(paint_session * session, uint8 rideIndex,
{
rct_map_element * savedMapElement = session->CurrentlyDrawnItem;
rct_ride * ride = get_ride(rideIndex);
Ride * ride = get_ride(rideIndex);
rct_ride_entry * rideEntry = get_ride_entry(ride->subtype);
if (ride->lifecycle_flags & RIDE_LIFECYCLE_ON_TRACK
@ -57,7 +57,7 @@ static void paint_3d_cinema(paint_session * session, uint8 rideIndex, uint8 trac
trackSequence = track_map_3x3[direction][trackSequence];
sint32 edges = edges_3x3[trackSequence];
rct_ride * ride = get_ride(rideIndex);
Ride * ride = get_ride(rideIndex);
rct_xy16 position = session->MapPosition;
wooden_a_supports_paint_setup(session, (direction & 1), 0, height, gTrackColours[SCHEME_MISC], NULL);

4
src/openrct2/ride/thrill/enterprise.c
View File

@ -22,7 +22,7 @@
#include "../track.h"
/** rct2: 0x008A2ABC */
static void paint_enterprise_structure(paint_session * session, rct_ride * ride, sint8 xOffset, sint8 yOffset, uint16 height, rct_map_element * mapElement)
static void paint_enterprise_structure(paint_session * session, Ride * ride, sint8 xOffset, sint8 yOffset, uint16 height, rct_map_element * mapElement)
{
height += 7;
@ -80,7 +80,7 @@ static void paint_enterprise(paint_session * session, uint8 rideIndex, uint8 tra
trackSequence = track_map_4x4[direction][trackSequence];
sint32 edges = edges_4x4[trackSequence];
rct_ride * ride = get_ride(rideIndex);
Ride * ride = get_ride(rideIndex);
rct_xy16 position = session->MapPosition;
wooden_a_supports_paint_setup(session, direction & 1, 0, height, gTrackColours[SCHEME_MISC], NULL);

2
src/openrct2/ride/thrill/go_karts.c
View File

@ -315,7 +315,7 @@ static void paint_go_karts_track_25_deg_down_to_flat(paint_session * session, ui
static void paint_go_karts_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_map_element * mapElement)
{
rct_xy16 position = session->MapPosition;
rct_ride * ride = get_ride(rideIndex);
Ride * ride = get_ride(rideIndex);
const rct_ride_entrance_definition * entranceStyle = &RideEntranceDefinitions[ride->entrance_style];
bool hasFence;

2
src/openrct2/ride/thrill/launched_freefall.c
View File

@ -89,7 +89,7 @@ static void paint_launched_freefall_base(paint_session * session, uint8 rideInde
trackSequence = track_map_3x3[direction][trackSequence];
sint32 edges = edges_3x3[trackSequence];
rct_ride * ride = get_ride(rideIndex);
Ride * ride = get_ride(rideIndex);
rct_xy16 position = session->MapPosition;
wooden_a_supports_paint_setup(session, (direction & 1), 0, height, gTrackColours[SCHEME_MISC], NULL);

8
src/openrct2/ride/thrill/magic_carpet.c
View File

@ -63,7 +63,7 @@ static const bound_box MagicCarpetBounds[] = {
{ 8, 0, 16, 32 }
};
static rct_vehicle *get_first_vehicle(rct_ride *ride)
static rct_vehicle *get_first_vehicle(Ride *ride)
{
if (ride->lifecycle_flags & RIDE_LIFECYCLE_ON_TRACK) {
uint16 vehicleSpriteIndex = ride->vehicles[0];
@ -111,7 +111,7 @@ static void paint_magic_carpet_pendulum(paint_session * session, uint8 plane, ui
sub_98199C(session, imageId, (sint8)offset.x, (sint8)offset.y, bbSize.x, bbSize.y, 127, offset.z, bbOffset.x, bbOffset.y, bbOffset.z, get_current_rotation());
}
static void paint_magic_carpet_vehicle(paint_session * session, rct_ride *ride, uint8 direction, uint32 swingImageId,
static void paint_magic_carpet_vehicle(paint_session * session, Ride *ride, uint8 direction, uint32 swingImageId,
rct_xyz16 offset, rct_xyz16 bbOffset, rct_xyz16 bbSize)
{
rct_ride_entry *rideEntry = get_ride_entry_by_ride(ride);
@ -152,7 +152,7 @@ static void paint_magic_carpet_vehicle(paint_session * session, rct_ride *ride,
}
/** rct2: 0x00899104 */
static void paint_magic_carpet_structure(paint_session * session, rct_ride *ride, uint8 direction, sint8 axisOffset, uint16 height)
static void paint_magic_carpet_structure(paint_session * session, Ride *ride, uint8 direction, sint8 axisOffset, uint16 height)
{
rct_map_element * savedMapElement = session->CurrentlyDrawnItem;
rct_vehicle *vehicle = get_first_vehicle(ride);
@ -208,7 +208,7 @@ static void paint_magic_carpet(paint_session * session, uint8 rideIndex, uint8 t
break;
}
rct_ride *ride = get_ride(rideIndex);
Ride *ride = get_ride(rideIndex);
switch (relativeTrackSequence) {
case 3: paint_magic_carpet_structure(session, ride, direction, -48, height); break;
case 0: paint_magic_carpet_structure(session, ride, direction, -16, height); break;

4
src/openrct2/ride/thrill/motion_simulator.c
View File

@ -37,7 +37,7 @@ enum {
*/
static void paint_motionsimulator_vehicle(paint_session * session, sint8 offsetX, sint8 offsetY, uint8 direction, sint32 height, rct_map_element* mapElement)
{
rct_ride *ride = get_ride(mapElement->properties.track.ride_index);
Ride *ride = get_ride(mapElement->properties.track.ride_index);
rct_ride_entry *rideEntry = get_ride_entry_by_ride(ride);
rct_map_element * savedMapElement = session->CurrentlyDrawnItem;
@ -128,7 +128,7 @@ static void paint_motionsimulator(paint_session * session, uint8 rideIndex, uint
trackSequence = track_map_2x2[direction][trackSequence];
sint32 edges = edges_2x2[trackSequence];
rct_ride *ride = get_ride(rideIndex);
Ride *ride = get_ride(rideIndex);
rct_xy16 position = { session->MapPosition.x, session->MapPosition.y };
wooden_a_supports_paint_setup(session, (direction & 1), 0, height, gTrackColours[SCHEME_MISC], NULL);

4
src/openrct2/ride/thrill/pirate_ship.c
View File

@ -66,7 +66,7 @@ static const uint32 pirate_ship_frame_sprites[][2] = {
};
/** rct2: 0x4AF254 */
static void paint_pirate_ship_structure(paint_session * session, rct_ride * ride, uint8 direction, sint8 axisOffset, uint16 height)
static void paint_pirate_ship_structure(paint_session * session, Ride * ride, uint8 direction, sint8 axisOffset, uint16 height)
{
uint32 imageId, baseImageId;
@ -160,7 +160,7 @@ static void paint_pirate_ship_structure(paint_session * session, rct_ride * ride
static void paint_pirate_ship(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_map_element * mapElement)
{
uint8 relativeTrackSequence = track_map_1x5[direction][trackSequence];
rct_ride * ride = get_ride(rideIndex);
Ride * ride = get_ride(rideIndex);
rct_xy16 position = session->MapPosition;
uint32 imageId;

2
src/openrct2/ride/thrill/roto_drop.c
View File

@ -89,7 +89,7 @@ static void paint_roto_drop_base(paint_session * session, uint8 rideIndex, uint8
trackSequence = track_map_3x3[direction][trackSequence];
sint32 edges = edges_3x3[trackSequence];
rct_ride * ride = get_ride(rideIndex);
Ride * ride = get_ride(rideIndex);
rct_xy16 position = session->MapPosition;
wooden_a_supports_paint_setup(session, (direction & 1), 0, height, gTrackColours[SCHEME_MISC], NULL);

4
src/openrct2/ride/thrill/swinging_inverter_ship.c
View File

@ -60,7 +60,7 @@ static const uint32 swinging_inverter_ship_frame_sprites[] = {
SPR_SWINGING_INVERTER_SHIP_FRAME_3
};
static void paint_swinging_inverter_ship_structure(paint_session * session, rct_ride * ride, uint8 direction, sint8 axisOffset, uint16 height)
static void paint_swinging_inverter_ship_structure(paint_session * session, Ride * ride, uint8 direction, sint8 axisOffset, uint16 height)
{
rct_map_element * savedMapElement = session->CurrentlyDrawnItem;
@ -121,7 +121,7 @@ static void paint_swinging_inverter_ship(paint_session * session, uint8 rideInde
{
uint8 relativeTrackSequence = track_map_1x4[direction][trackSequence];
rct_ride * ride = get_ride(rideIndex);
Ride * ride = get_ride(rideIndex);
uint32 imageId;

4
src/openrct2/ride/thrill/top_spin.c
View File

@ -56,7 +56,7 @@ static void top_spin_paint_vehicle(paint_session * session, sint8 al, sint8 cl,
height += 3;
rct_ride* ride = get_ride(rideIndex);
Ride* ride = get_ride(rideIndex);
rct_ride_entry* rideEntry = get_ride_entry(ride->subtype);
rct_vehicle* vehicle = NULL;
@ -230,7 +230,7 @@ static void paint_top_spin(paint_session * session, uint8 rideIndex, uint8 track
trackSequence = track_map_3x3[direction][trackSequence];
sint32 edges = edges_3x3[trackSequence];
rct_ride *ride = get_ride(rideIndex);
Ride *ride = get_ride(rideIndex);
rct_xy16 position = session->MapPosition;
wooden_a_supports_paint_setup(session, direction & 1, 0, height, gTrackColours[SCHEME_MISC], NULL);

4
src/openrct2/ride/thrill/twist.c
View File

@ -22,7 +22,7 @@
#include "../track.h"
/** rct2: 0x0076E5C9 */
static void paint_twist_structure(paint_session * session, rct_ride * ride, uint8 direction, sint8 xOffset, sint8 yOffset, uint16 height)
static void paint_twist_structure(paint_session * session, Ride * ride, uint8 direction, sint8 xOffset, sint8 yOffset, uint16 height)
{
rct_map_element * savedMapElement = session->CurrentlyDrawnItem;
@ -84,7 +84,7 @@ static void paint_twist(paint_session * session, uint8 rideIndex, uint8 trackSeq
trackSequence = track_map_3x3[direction][trackSequence];
const uint8 edges = edges_3x3[trackSequence];
rct_ride * ride = get_ride(rideIndex);
Ride * ride = get_ride(rideIndex);
rct_xy16 position = session->MapPosition;
uint32 imageId;

18
src/openrct2/ride/track.c
View File

@ -582,14 +582,14 @@ sint32 track_is_connected_by_shape(rct_map_element *a, rct_map_element *b)
return aBank == bBank && aAngle == bAngle;
}
const rct_preview_track *get_track_def_from_ride(rct_ride *ride, sint32 trackType)
const rct_preview_track *get_track_def_from_ride(Ride *ride, sint32 trackType)
{
return ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_FLAT_RIDE) ?
FlatRideTrackBlocks[trackType] :
TrackBlocks[trackType];
}
const rct_track_coordinates *get_track_coord_from_ride(rct_ride *ride, sint32 trackType){
const rct_track_coordinates *get_track_coord_from_ride(Ride *ride, sint32 trackType){
return ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_FLAT_RIDE) ?
&FlatTrackCoordinates[trackType] :
&TrackCoordinates[trackType];
@ -615,7 +615,7 @@ static rct_map_element *find_station_element(sint32 x, sint32 y, sint32 z, sint3
return NULL;
}
static void ride_remove_station(rct_ride *ride, sint32 x, sint32 y, sint32 z)
static void ride_remove_station(Ride *ride, sint32 x, sint32 y, sint32 z)
{
for (sint32 i = 0; i < MAX_STATIONS; i++)
{
@ -640,7 +640,7 @@ static bool track_add_station_element(sint32 x, sint32 y, sint32 z, sint32 direc
sint32 stationY1 = y;
sint32 stationLength = 1;
rct_ride *ride = get_ride(rideIndex);
Ride *ride = get_ride(rideIndex);
if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_3)) {
if (ride->num_stations >= MAX_STATIONS) {
gGameCommandErrorText = STR_NO_MORE_STATIONS_ALLOWED_ON_THIS_RIDE;
@ -774,7 +774,7 @@ static bool track_remove_station_element(sint32 x, sint32 y, sint32 z, sint32 di
sint32 stationLength = 0;
sint32 byte_F441D1 = -1;
rct_ride *ride = get_ride(rideIndex);
Ride *ride = get_ride(rideIndex);
if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_3)) {
rct_map_element *mapElement = map_get_track_element_at_with_direction_from_ride(x, y, z, direction, rideIndex);
if (mapElement != NULL) {
@ -900,7 +900,7 @@ static bool track_remove_station_element(sint32 x, sint32 y, sint32 z, sint32 di
static money32 track_place(sint32 rideIndex, sint32 type, sint32 originX, sint32 originY, sint32 originZ, sint32 direction, sint32 properties_1, sint32 properties_2, sint32 properties_3, sint32 liftHillAndAlternativeState, sint32 flags)
{
rct_ride *ride = get_ride(rideIndex);
Ride *ride = get_ride(rideIndex);
if (ride == NULL)
{
log_warning("Invalid ride for track placement, rideIndex = %d", rideIndex);
@ -1503,7 +1503,7 @@ static money32 track_remove(uint8 type, uint8 sequence, sint16 originX, sint16 o
type = mapElement->properties.track.type;
bool isLiftHill = track_element_is_lift_hill(mapElement);
rct_ride* ride = get_ride(rideIndex);
Ride* ride = get_ride(rideIndex);
const rct_preview_track* trackBlock = get_track_def_from_ride(ride, type);
trackBlock += map_element_get_track_sequence(mapElement);
@ -1831,7 +1831,7 @@ static money32 set_maze_track(uint16 x, uint8 flags, uint8 direction, uint16 y,
return MONEY32_UNDEFINED;
}
rct_ride *ride = get_ride(rideIndex);
Ride *ride = get_ride(rideIndex);
money32 price = (((RideTrackCosts[ride->type].track_price * TrackPricing[TRACK_ELEM_MAZE]) >> 16));
cost = price / 2 * 10;
@ -2181,7 +2181,7 @@ bool track_element_is_inverted(rct_map_element *trackElement)
sint32 track_get_actual_bank(rct_map_element *mapElement, sint32 bank)
{
rct_ride *ride = get_ride(mapElement->properties.track.ride_index);
Ride *ride = get_ride(mapElement->properties.track.ride_index);
sint32 trackColour = mapElement->properties.track.colour;
return track_get_actual_bank_2(ride->type, trackColour, bank);
}

4
src/openrct2/ride/track.h
View File

@ -519,9 +519,9 @@ extern uint8 gTrackGroundFlags;
sint32 track_is_connected_by_shape(rct_map_element *a, rct_map_element *b);
const rct_preview_track *get_track_def_from_ride(rct_ride *ride, sint32 trackType);
const rct_preview_track *get_track_def_from_ride(Ride *ride, sint32 trackType);
const rct_preview_track *get_track_def_from_ride_index(sint32 rideIndex, sint32 trackType);
const rct_track_coordinates *get_track_coord_from_ride(rct_ride *ride, sint32 trackType);
const rct_track_coordinates *get_track_coord_from_ride(Ride *ride, sint32 trackType);
void track_circuit_iterator_begin(track_circuit_iterator *it, rct_xy_element first);
bool track_circuit_iterator_previous(track_circuit_iterator *it);

8
src/openrct2/ride/track_design_save.c
View File

@ -145,7 +145,7 @@ static void track_design_save_callback(sint32 result, const utf8 * path)
*/
bool track_design_save(uint8 rideIndex)
{
rct_ride* ride = get_ride(rideIndex);
Ride* ride = get_ride(rideIndex);
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED)){
window_error_open(STR_CANT_SAVE_TRACK_DESIGN, gGameCommandErrorText);
@ -720,7 +720,7 @@ static bool track_design_save_copy_scenery_to_td6(rct_track_td6 *td6)
static rct_track_td6 *track_design_save_to_td6(uint8 rideIndex)
{
rct_track_td6 *td6 = calloc(1, sizeof(rct_track_td6));
rct_ride *ride = get_ride(rideIndex);
Ride *ride = get_ride(rideIndex);
td6->type = ride->type;
rct_object_entry_extended *object = &object_entry_groups[OBJECT_TYPE_RIDE].entries[ride->subtype];
@ -862,7 +862,7 @@ static bool track_design_save_to_td6_for_maze(uint8 rideIndex, rct_track_td6 *td
x = 0;
}
rct_ride *ride = get_ride(rideIndex);
Ride *ride = get_ride(rideIndex);
rct_xy8 location = ride->entrances[0];
if (location.xy == RCT_XY8_UNDEFINED) {
@ -945,7 +945,7 @@ static bool track_design_save_to_td6_for_maze(uint8 rideIndex, rct_track_td6 *td
*/
static bool track_design_save_to_td6_for_tracked_ride(uint8 rideIndex, rct_track_td6 *td6)
{
rct_ride *ride = get_ride(rideIndex);
Ride *ride = get_ride(rideIndex);
rct_xy_element trackElement;
track_begin_end trackBeginEnd;

16
src/openrct2/ride/track_paint.c
View File

@ -203,7 +203,7 @@ enum
bool gUseOriginalRidePaint = false;
bool track_paint_util_has_fence(enum edge_t edge, rct_xy16 position, rct_map_element * mapElement, rct_ride * ride, uint8 rotation)
bool track_paint_util_has_fence(enum edge_t edge, rct_xy16 position, rct_map_element * mapElement, Ride * ride, uint8 rotation)
{
rct_xy16 offset = { 0, 0 };
switch (edge) {
@ -247,7 +247,7 @@ void track_paint_util_paint_floor(paint_session * session, uint8 edges, uint32 c
sub_98197C(session, imageId | colourFlags, 0, 0, 32, 32, 1, height, 0, 0, height, rotation);
}
void track_paint_util_paint_fences(paint_session * session, uint8 edges, rct_xy16 position, rct_map_element * mapElement, rct_ride * ride, uint32 colourFlags, uint16 height, const uint32 fenceSprites[4], uint8 rotation)
void track_paint_util_paint_fences(paint_session * session, uint8 edges, rct_xy16 position, rct_map_element * mapElement, Ride * ride, uint32 colourFlags, uint16 height, const uint32 fenceSprites[4], uint8 rotation)
{
uint32 imageId;
@ -301,7 +301,7 @@ void track_paint_util_draw_station_3(paint_session * session, uint8 rideIndex, u
void track_paint_util_draw_station_impl(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, uint16 coverHeight, rct_map_element * mapElement, sint32 fenceOffsetA, sint32 fenceOffsetB)
{
rct_xy16 position = session->MapPosition;
rct_ride * ride = get_ride(rideIndex);
Ride * ride = get_ride(rideIndex);
const rct_ride_entrance_definition * entranceStyle = &RideEntranceDefinitions[ride->entrance_style];
const bool hasGreenLight = map_element_get_green_light(mapElement);
@ -435,7 +435,7 @@ void track_paint_util_draw_station_impl(paint_session * session, uint8 rideIndex
void track_paint_util_draw_station_inverted(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_map_element * mapElement, uint8 stationVariant)
{
rct_xy16 position = session->MapPosition;
rct_ride * ride = get_ride(rideIndex);
Ride * ride = get_ride(rideIndex);
const rct_ride_entrance_definition * entranceStyle = &RideEntranceDefinitions[ride->entrance_style];
const bool hasGreenLight = map_element_get_green_light(mapElement);
@ -641,7 +641,7 @@ bool track_paint_util_draw_station_covers_2(paint_session * session, enum edge_t
return true;
}
void track_paint_util_draw_station_platform(paint_session * session, rct_ride *ride, uint8 direction, sint32 height, sint32 zOffset, rct_map_element * mapElement)
void track_paint_util_draw_station_platform(paint_session * session, Ride *ride, uint8 direction, sint32 height, sint32 zOffset, rct_map_element * mapElement)
{
rct_xy16 position = session->MapPosition;
const rct_ride_entrance_definition * entranceStyle = &RideEntranceDefinitions[ride->entrance_style];
@ -678,7 +678,7 @@ void track_paint_util_draw_station_platform(paint_session * session, rct_ride *r
}
}
void track_paint_util_draw_pier(paint_session * session, rct_ride * ride, const rct_ride_entrance_definition * entranceStyle, rct_xy16 position, uint8 direction, sint32 height, rct_map_element * mapElement, uint8 rotation)
void track_paint_util_draw_pier(paint_session * session, Ride * ride, const rct_ride_entrance_definition * entranceStyle, rct_xy16 position, uint8 direction, sint32 height, rct_map_element * mapElement, uint8 rotation)
{
bool hasFence;
uint32 imageId;
@ -1736,7 +1736,7 @@ void track_paint_util_left_corkscrew_up_supports(paint_session * session, uint8
void track_paint(paint_session * session, uint8 direction, sint32 height, rct_map_element *mapElement)
{
sint32 rideIndex = mapElement->properties.track.ride_index;
rct_ride *ride = get_ride(rideIndex);
Ride *ride = get_ride(rideIndex);
if (ride->type == RIDE_TYPE_NULL) {
log_error("Attempted to paint invalid ride: %d", rideIndex);
return;
@ -1811,7 +1811,7 @@ void track_paint(paint_session * session, uint8 direction, sint32 height, rct_ma
direction,
height,
(sint32)mapElement,
rideIndex * sizeof(rct_ride),
rideIndex * sizeof(Ride),
trackSequence
);
}

8
src/openrct2/ride/track_paint.h
View File

@ -261,18 +261,18 @@ extern const uint8 mapLeftEighthTurnToOrthogonal[5];
extern bool gUseOriginalRidePaint;
bool track_paint_util_has_fence(enum edge_t edge, rct_xy16 position, rct_map_element * mapElement, rct_ride * ride, uint8 rotation);
bool track_paint_util_has_fence(enum edge_t edge, rct_xy16 position, rct_map_element * mapElement, Ride * ride, uint8 rotation);
void track_paint_util_paint_floor(paint_session * session, uint8 edges, uint32 colourFlags, uint16 height, const uint32 floorSprites[4], uint8 rotation);
void track_paint_util_paint_fences(paint_session * session, uint8 edges, rct_xy16 position, rct_map_element * mapElement, rct_ride * ride, uint32 colourFlags, uint16 height, const uint32 fenceSprites[4], uint8 rotation);
void track_paint_util_paint_fences(paint_session * session, uint8 edges, rct_xy16 position, rct_map_element * mapElement, Ride * ride, uint32 colourFlags, uint16 height, const uint32 fenceSprites[4], uint8 rotation);
bool track_paint_util_draw_station_covers(paint_session * session, enum edge_t edge, bool hasFence, const rct_ride_entrance_definition * entranceStyle, uint8 direction, uint16 height);
bool track_paint_util_draw_station_covers_2(paint_session * session, enum edge_t edge, bool hasFence, const rct_ride_entrance_definition * entranceStyle, uint8 direction, uint16 height, uint8 stationVariant);
void track_paint_util_draw_station_platform(paint_session * session, rct_ride *ride, uint8 direction, sint32 height, sint32 zOffset, rct_map_element * mapElement);
void track_paint_util_draw_station_platform(paint_session * session, Ride *ride, uint8 direction, sint32 height, sint32 zOffset, rct_map_element * mapElement);
void track_paint_util_draw_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_map_element * mapElement);
void track_paint_util_draw_station_2(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, rct_map_element * mapElement, sint32 fenceOffsetA, sint32 fenceOffsetB);
void track_paint_util_draw_station_3(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, uint16 height, uint16 coverHeight, rct_map_element * mapElement);
void track_paint_util_draw_station_inverted(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_map_element * mapElement, uint8 stationVariant);
bool track_paint_util_should_paint_supports(rct_xy16 position);
void track_paint_util_draw_pier(paint_session * session, rct_ride * ride, const rct_ride_entrance_definition * entranceStyle, rct_xy16 position, uint8 direction, sint32 height, rct_map_element * mapElement, uint8 rotation);
void track_paint_util_draw_pier(paint_session * session, Ride * ride, const rct_ride_entrance_definition * entranceStyle, rct_xy16 position, uint8 direction, sint32 height, rct_map_element * mapElement, uint8 rotation);
void track_paint_util_draw_station_metal_supports(paint_session * session, uint8 direction, uint16 height, uint32 colour);
void track_paint_util_draw_station_metal_supports_2(paint_session * session, uint8 direction, uint16 height, uint32 colour, uint8 type);

4
src/openrct2/ride/transport/chairlift.c
View File

@ -168,7 +168,7 @@ static void chairlift_paint_station_ne_sw(paint_session * session, uint8 rideInd
{
const rct_xy16 pos = session->MapPosition;
uint8 trackType = mapElement->properties.track.type;
rct_ride * ride = get_ride(rideIndex);
Ride * ride = get_ride(rideIndex);
uint32 imageId;
bool isStart = chairlift_paint_util_is_first_track(rideIndex, mapElement, pos, trackType);;
@ -247,7 +247,7 @@ static void chairlift_paint_station_se_nw(paint_session * session, uint8 rideInd
{
const rct_xy16 pos = session->MapPosition;
uint8 trackType = mapElement->properties.track.type;
rct_ride * ride = get_ride(rideIndex);
Ride * ride = get_ride(rideIndex);
uint32 imageId;
bool isStart = chairlift_paint_util_is_first_track(rideIndex, mapElement, pos, trackType);;

2
src/openrct2/ride/transport/lift.c
View File

@ -78,7 +78,7 @@ static void paint_lift_base(paint_session * session, uint8 rideIndex, uint8 trac
}
sint32 edges = edges_3x3[trackSequence];
rct_ride * ride = get_ride(rideIndex);
Ride * ride = get_ride(rideIndex);
rct_xy16 position = session->MapPosition;
uint32 imageId = SPR_FLOOR_METAL_B | gTrackColours[SCHEME_SUPPORTS];

94
src/openrct2/ride/vehicle.c
View File

@ -1090,7 +1090,7 @@ void vehicle_update_all()
* @returns 0 when all closed
*/
static sint32 vehicle_close_restraints(rct_vehicle* vehicle){
rct_ride* ride = get_ride(vehicle->ride);
Ride* ride = get_ride(vehicle->ride);
sint32 ebp = 0;
uint16 vehicle_id = vehicle->sprite_index;
@ -1152,7 +1152,7 @@ static sint32 vehicle_open_restraints(rct_vehicle* vehicle){
vehicle->var_4E = 0;
vehicle->var_4A = 0;
rct_ride* ride = get_ride(vehicle->ride);
Ride* ride = get_ride(vehicle->ride);
rct_ride_entry* rideEntry = get_ride_entry(vehicle->ride_subtype);
rct_ride_entry_vehicle* vehicleEntry = &rideEntry->vehicles[vehicle->vehicle_type];
@ -1241,7 +1241,7 @@ static sint32 vehicle_open_restraints(rct_vehicle* vehicle){
*/
static void vehicle_update_measurements(rct_vehicle *vehicle)
{
rct_ride *ride;
Ride *ride;
ride = get_ride(vehicle->ride);
@ -1589,7 +1589,7 @@ static uint16 sub_6D7AC0(sint32 currentSoundId, sint32 currentVolume, sint32 tar
*/
static void vehicle_update(rct_vehicle *vehicle)
{
rct_ride *ride;
Ride *ride;
rct_ride_entry *rideEntry;
// The cable lift uses the ride type of NULL
@ -1698,7 +1698,7 @@ static void vehicle_update(rct_vehicle *vehicle)
* rct2: 0x006D7BCC
*/
static void vehicle_update_moving_to_end_of_station(rct_vehicle *vehicle){
rct_ride* ride = get_ride(vehicle->ride);
Ride* ride = get_ride(vehicle->ride);
sint32 eax, ebx;
switch (ride->mode){
@ -1802,7 +1802,7 @@ static void train_ready_to_depart(rct_vehicle* vehicle, uint8 num_peeps_on_train
if (num_peeps_on_train != num_used_seats)
return;
rct_ride* ride = get_ride(vehicle->ride);
Ride* ride = get_ride(vehicle->ride);
if (ride->status == RIDE_STATUS_OPEN &&
!(ride->lifecycle_flags & RIDE_LIFECYCLE_BROKEN_DOWN) &&
@ -1849,7 +1849,7 @@ static void train_ready_to_depart(rct_vehicle* vehicle, uint8 num_peeps_on_train
vehicle_invalidate_window(vehicle);
}
static int ride_get_train_index_from_vehicle(rct_ride* ride, uint16 spriteIndex)
static int ride_get_train_index_from_vehicle(Ride* ride, uint16 spriteIndex)
{
int trainIndex = 0;
while (ride->vehicles[trainIndex] != spriteIndex)
@ -1877,7 +1877,7 @@ static int ride_get_train_index_from_vehicle(rct_ride* ride, uint16 spriteIndex)
static void vehicle_update_waiting_for_passengers(rct_vehicle* vehicle){
vehicle->velocity = 0;
rct_ride* ride = get_ride(vehicle->ride);
Ride* ride = get_ride(vehicle->ride);
if (vehicle->sub_state == 0){
if (vehicle_open_restraints(vehicle))
@ -2059,7 +2059,7 @@ static void vehicle_update_waiting_for_passengers(rct_vehicle* vehicle){
* rct2: 0x006D91BF
*/
static void vehicle_update_dodgems_mode(rct_vehicle *vehicle) {
rct_ride* ride = get_ride(vehicle->ride);
Ride* ride = get_ride(vehicle->ride);
rct_ride_entry* rideEntry = get_ride_entry(vehicle->ride_subtype);
rct_ride_entry_vehicle* vehicleEntry = &rideEntry->vehicles[vehicle->vehicle_type];
@ -2092,7 +2092,7 @@ static void vehicle_update_dodgems_mode(rct_vehicle *vehicle) {
* rct2: 0x006D80BE
*/
static void vehicle_update_waiting_to_depart(rct_vehicle* vehicle) {
rct_ride* ride = get_ride(vehicle->ride);
Ride* ride = get_ride(vehicle->ride);
bool shouldBreak = false;
if (ride->lifecycle_flags & RIDE_LIFECYCLE_BROKEN_DOWN) {
switch (ride->breakdown_reason_pending) {
@ -2340,7 +2340,7 @@ static bool try_add_synchronised_station(sint32 x, sint32 y, sint32 z)
}
sint32 rideIndex = mapElement->properties.track.ride_index;
rct_ride *ride = get_ride(rideIndex);
Ride *ride = get_ride(rideIndex);
if (!(ride->depart_flags & RIDE_DEPART_SYNCHRONISE_WITH_ADJACENT_STATIONS)) {
/* Ride is not set to synchronise with adjacent stations. */
return false;
@ -2405,7 +2405,7 @@ static bool try_add_synchronised_station(sint32 x, sint32 y, sint32 z)
*/
static bool vehicle_can_depart_synchronised(rct_vehicle *vehicle)
{
rct_ride *ride = get_ride(vehicle->ride);
Ride *ride = get_ride(vehicle->ride);
sint32 station = vehicle->current_station;
rct_xy8 location = ride->station_starts[station];
sint32 x = location.x * 32;
@ -2453,7 +2453,7 @@ static bool vehicle_can_depart_synchronised(rct_vehicle *vehicle)
}
for (rct_synchronised_vehicle *sv = _synchronisedVehicles; sv < _lastSynchronisedVehicle; sv++) {
rct_ride *sv_ride = get_ride(sv->ride_id);
Ride *sv_ride = get_ride(sv->ride_id);
if (!(sv_ride->lifecycle_flags & RIDE_LIFECYCLE_BROKEN_DOWN)) {
if (sv_ride->status != RIDE_STATUS_CLOSED) {
@ -2572,7 +2572,7 @@ void vehicle_peep_easteregg_here_we_are(rct_vehicle* vehicle) {
* rct2: 0x006D7338
*/
void vehicle_update_test_finish(rct_vehicle* vehicle) {
rct_ride* ride = get_ride(vehicle->ride);
Ride* ride = get_ride(vehicle->ride);
ride->lifecycle_flags &= ~RIDE_LIFECYCLE_TEST_IN_PROGRESS;
vehicle->update_flags &= ~VEHICLE_UPDATE_FLAG_TESTING;
ride->lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
@ -2608,7 +2608,7 @@ void vehicle_update_test_finish(rct_vehicle* vehicle) {
void vehicle_test_reset(rct_vehicle* vehicle) {
vehicle->update_flags |= VEHICLE_UPDATE_FLAG_TESTING;
rct_ride* ride = get_ride(vehicle->ride);
Ride* ride = get_ride(vehicle->ride);
ride->lifecycle_flags |= RIDE_LIFECYCLE_TEST_IN_PROGRESS;
ride->lifecycle_flags &= ~RIDE_LIFECYCLE_NO_RAW_STATS;
ride->max_speed = 0;
@ -2701,7 +2701,7 @@ static void vehicle_update_travelling_boat_hire_setup(rct_vehicle* vehicle) {
*/
static void vehicle_update_departing_boat_hire(rct_vehicle* vehicle) {
vehicle->lost_time_out = 0;
rct_ride* ride = get_ride(vehicle->ride);
Ride* ride = get_ride(vehicle->ride);
ride->station_depart[vehicle->current_station] &= STATION_DEPART_FLAG;
uint8 waitingTime = max(ride->min_waiting_time, 3);
@ -2715,7 +2715,7 @@ static void vehicle_update_departing_boat_hire(rct_vehicle* vehicle) {
* rct2: 0x006D845B
*/
static void vehicle_update_departing(rct_vehicle* vehicle) {
rct_ride* ride = get_ride(vehicle->ride);
Ride* ride = get_ride(vehicle->ride);
rct_ride_entry* rideEntry = get_ride_entry(vehicle->ride_subtype);
if (vehicle->sub_state == 0) {
@ -2925,7 +2925,7 @@ static void vehicle_update_departing(rct_vehicle* vehicle) {
* rct2: 0x006D8858
*/
static void vehicle_finish_departing(rct_vehicle* vehicle) {
rct_ride* ride = get_ride(vehicle->ride);
Ride* ride = get_ride(vehicle->ride);
if (ride->mode == RIDE_MODE_DOWNWARD_LAUNCH ) {
if (vehicle->var_CE >= 1 && (14 << 16) > vehicle->velocity)
@ -2977,7 +2977,7 @@ static void vehicle_finish_departing(rct_vehicle* vehicle) {
* rct2: 0x006DE5CB
*/
static void vehicle_check_if_missing(rct_vehicle* vehicle) {
rct_ride* ride = get_ride(vehicle->ride);
Ride* ride = get_ride(vehicle->ride);
if (ride->lifecycle_flags & (RIDE_LIFECYCLE_BROKEN_DOWN | RIDE_LIFECYCLE_CRASHED))
return;
@ -3025,7 +3025,7 @@ static void vehicle_update_collision_setup(rct_vehicle* vehicle) {
vehicle->status = VEHICLE_STATUS_CRASHED;
vehicle_invalidate_window(vehicle);
rct_ride* ride = get_ride(vehicle->ride);
Ride* ride = get_ride(vehicle->ride);
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_CRASHED)) {
rct_vehicle* frontVehicle = vehicle;
while (frontVehicle->is_child != 0)frontVehicle = GET_VEHICLE(frontVehicle->prev_vehicle_on_ride);
@ -3184,7 +3184,7 @@ static void vehicle_update_crash_setup(rct_vehicle* vehicle) {
static void vehicle_update_travelling(rct_vehicle* vehicle) {
vehicle_check_if_missing(vehicle);
rct_ride* ride = get_ride(vehicle->ride);
Ride* ride = get_ride(vehicle->ride);
if (_vehicleBreakdown == 0 && ride->mode == RIDE_MODE_ROTATING_LIFT)
return;
@ -3343,7 +3343,7 @@ static void vehicle_update_travelling(rct_vehicle* vehicle) {
static void vehicle_update_arriving(rct_vehicle* vehicle)
{
uint8 unkF64E35 = 1;
rct_ride* ride = get_ride(vehicle->ride);
Ride* ride = get_ride(vehicle->ride);
switch (ride->mode) {
case RIDE_MODE_SWING:
@ -3565,7 +3565,7 @@ static void vehicle_update_unloading_passengers(rct_vehicle* vehicle) {
}
}
rct_ride* ride = get_ride(vehicle->ride);
Ride* ride = get_ride(vehicle->ride);
if (ride->mode == RIDE_MODE_FORWARD_ROTATION ||
ride->mode == RIDE_MODE_BACKWARD_ROTATION) {
uint8 seat = ((-vehicle->vehicle_sprite_type) >> 3) & 0xF;
@ -3652,7 +3652,7 @@ static void vehicle_update_unloading_passengers(rct_vehicle* vehicle) {
*/
static void vehicle_update_waiting_for_cable_lift(rct_vehicle *vehicle)
{
rct_ride* ride = get_ride(vehicle->ride);
Ride* ride = get_ride(vehicle->ride);
rct_vehicle* cableLift = GET_VEHICLE(ride->cable_lift);
@ -3668,7 +3668,7 @@ static void vehicle_update_waiting_for_cable_lift(rct_vehicle *vehicle)
* rct2: 0x006D9D21
*/
static void vehicle_update_travelling_cable_lift(rct_vehicle* vehicle) {
rct_ride* ride = get_ride(vehicle->ride);
Ride* ride = get_ride(vehicle->ride);
if (vehicle->sub_state == 0) {
if (vehicle->update_flags & VEHICLE_UPDATE_FLAG_BROKEN_TRAIN) {
@ -3766,7 +3766,7 @@ static void loc_6DA9F9(rct_vehicle *vehicle, sint32 x, sint32 y, sint32 bx, sint
vehicle->track_z >> 3
);
rct_ride *ride = get_ride(vehicle->ride);
Ride *ride = get_ride(vehicle->ride);
vehicle->track_type =
(mapElement->properties.track.type << 2) |
(ride->boat_hire_return_direction & 3);
@ -3905,7 +3905,7 @@ static void vehicle_update_motion_boat_hire(rct_vehicle *vehicle)
if (flooredX != vehicle->track_x || flooredY != vehicle->track_y) {
if (vehicle_is_boat_on_water(vehicle, x, y)) {
// loc_6DA939:
rct_ride *ride = get_ride(vehicle->ride);
Ride *ride = get_ride(vehicle->ride);
bool do_loc_6DAA97 = false;
if (vehicle->sub_state != 1) {
@ -4021,7 +4021,7 @@ static void vehicle_update_motion_boat_hire(rct_vehicle *vehicle)
*/
static void vehicle_update_boat_location(rct_vehicle *vehicle)
{
rct_ride *ride = get_ride(vehicle->ride);
Ride *ride = get_ride(vehicle->ride);
rct_xy8 returnPosition = ride->boat_hire_return_position;
uint8 returnDirection = ride->boat_hire_return_direction & 3;
@ -4110,7 +4110,7 @@ static bool vehicle_is_boat_on_water(rct_vehicle *vehicle, sint32 x, sint32 y)
* rct2: 0x006D9249
*/
static void vehicle_update_swinging(rct_vehicle* vehicle) {
rct_ride* ride = get_ride(vehicle->ride);
Ride* ride = get_ride(vehicle->ride);
rct_ride_entry* rideEntry = get_ride_entry(vehicle->ride_subtype);
// SubState for this ride means swinging state
@ -4176,7 +4176,7 @@ static void vehicle_update_ferris_wheel_rotating(rct_vehicle* vehicle) {
if (_vehicleBreakdown == 0)
return;
rct_ride* ride = get_ride(vehicle->ride);
Ride* ride = get_ride(vehicle->ride);
if ((vehicle->ferris_wheel_var_1 -= 1) != 0)
return;
@ -4286,7 +4286,7 @@ static void vehicle_update_rotating(rct_vehicle* vehicle) {
if (_vehicleBreakdown == 0)
return;
rct_ride* ride = get_ride(vehicle->ride);
Ride* ride = get_ride(vehicle->ride);
rct_ride_entry* rideEntry = get_ride_entry(vehicle->ride_subtype);
const uint8* timeToSpriteMap;
@ -4592,7 +4592,7 @@ static void vehicle_kill_all_passengers(rct_vehicle* vehicle) {
numFatalities += curVehicle->num_peeps;
}
rct_ride* ride = get_ride(vehicle->ride);
Ride* ride = get_ride(vehicle->ride);
set_format_arg(0, uint16, numFatalities);
uint8 crashType = numFatalities == 0 ?
@ -4642,7 +4642,7 @@ static void vehicle_crash_on_land(rct_vehicle* vehicle) {
vehicle->status = VEHICLE_STATUS_CRASHED;
vehicle_invalidate_window(vehicle);
rct_ride* ride = get_ride(vehicle->ride);
Ride* ride = get_ride(vehicle->ride);
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_CRASHED)) {
rct_vehicle* frontVehicle = vehicle;
@ -4695,7 +4695,7 @@ static void vehicle_crash_on_water(rct_vehicle* vehicle) {
vehicle->status = VEHICLE_STATUS_CRASHED;
vehicle_invalidate_window(vehicle);
rct_ride* ride = get_ride(vehicle->ride);
Ride* ride = get_ride(vehicle->ride);
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_CRASHED)) {
rct_vehicle* frontVehicle = vehicle;
@ -4837,7 +4837,7 @@ static void vehicle_update_crash(rct_vehicle *vehicle){
*/
static void vehicle_update_sound(rct_vehicle *vehicle)
{
rct_ride *ride;
Ride *ride;
rct_ride_entry *rideEntry;
// frictionVolume (bl) should be set before hand
uint8 frictionVolume = 255, frictionId = 255;
@ -5541,7 +5541,7 @@ void vehicle_get_g_forces(rct_vehicle *vehicle, sint32 *verticalG, sint32 *later
void vehicle_set_map_toolbar(rct_vehicle *vehicle)
{
rct_ride *ride;
Ride *ride;
sint32 vehicleIndex;
ride = get_ride(vehicle->ride);
@ -5605,7 +5605,7 @@ sint32 vehicle_is_used_in_pairs(rct_vehicle *vehicle)
*/
static sint32 vehicle_update_motion_dodgems(rct_vehicle* vehicle) {
_vehicleMotionTrackFlags = 0;
rct_ride* ride = get_ride(vehicle->ride);
Ride* ride = get_ride(vehicle->ride);
sint32 nextVelocity = vehicle->velocity + vehicle->acceleration;
if (ride->lifecycle_flags & (RIDE_LIFECYCLE_BREAKDOWN_PENDING | RIDE_LIFECYCLE_BROKEN_DOWN) &&
@ -5943,7 +5943,7 @@ static void apply_block_brakes(rct_vehicle *vehicle, bool is_block_brake_closed)
*/
static void check_and_apply_block_section_stop_site(rct_vehicle *vehicle)
{
rct_ride *ride = get_ride(vehicle->ride);
Ride *ride = get_ride(vehicle->ride);
rct_ride_entry_vehicle *vehicleEntry = vehicle_get_vehicle_entry(vehicle);
// Is chair lift type
@ -6078,7 +6078,7 @@ static void vehicle_update_block_brakes_open_previous_section(rct_vehicle *vehic
sint32 trackType = mapElement->properties.track.type;
if (trackType == TRACK_ELEM_BLOCK_BRAKES || trackType == TRACK_ELEM_END_STATION) {
rct_ride *ride = get_ride(vehicle->ride);
Ride *ride = get_ride(vehicle->ride);
if (ride_is_block_sectioned(ride)) {
audio_play_sound_at_location(SOUND_48, x, y, z);
}
@ -6728,7 +6728,7 @@ static void sub_6D63D4(rct_vehicle *vehicle)
al &= 0x02;
ah &= 0x02;
if (al != ah) {
rct_ride *ride = get_ride(vehicle->ride);
Ride *ride = get_ride(vehicle->ride);
if (ride->entrance_style == RIDE_ENTRANCE_STYLE_PLAIN ||
(vehicle->status != VEHICLE_STATUS_MOVING_TO_END_OF_STATION &&
vehicle->status != VEHICLE_STATUS_ARRIVING)
@ -7332,7 +7332,7 @@ static void sub_6DBF3E(rct_vehicle *vehicle)
*
* rct2: 0x006DB08C
*/
static bool vehicle_update_track_motion_forwards_get_new_track(rct_vehicle *vehicle, uint16 trackType, rct_ride* ride, rct_ride_entry* rideEntry) {
static bool vehicle_update_track_motion_forwards_get_new_track(rct_vehicle *vehicle, uint16 trackType, Ride* ride, rct_ride_entry* rideEntry) {
registers regs = { 0 };
_vehicleVAngleEndF64E36 = TrackDefinitions[trackType].vangle_end;
@ -7505,7 +7505,7 @@ loc_6DB41D:
*
* rct2: 0x006DAEB9
*/
static bool vehicle_update_track_motion_forwards(rct_vehicle *vehicle, rct_ride_entry_vehicle* vehicleEntry, rct_ride* ride, rct_ride_entry* rideEntry) {
static bool vehicle_update_track_motion_forwards(rct_vehicle *vehicle, rct_ride_entry_vehicle* vehicleEntry, Ride* ride, rct_ride_entry* rideEntry) {
registers regs = { 0 };
loc_6DAEB9:
regs.edi = vehicle->track_type;
@ -7718,7 +7718,7 @@ loc_6DB967:
*
* rct2: 0x006DBAA6
*/
static bool vehicle_update_track_motion_backwards_get_new_track(rct_vehicle *vehicle, uint16 trackType, rct_ride* ride, rct_ride_entry* rideEntry, uint16* progress) {
static bool vehicle_update_track_motion_backwards_get_new_track(rct_vehicle *vehicle, uint16 trackType, Ride* ride, rct_ride_entry* rideEntry, uint16* progress) {
_vehicleVAngleEndF64E36 = TrackDefinitions[trackType].vangle_start;
_vehicleBankEndF64E37 = TrackDefinitions[trackType].bank_start;
rct_map_element* mapElement = map_get_track_element_at_of_type_seq(
@ -7875,7 +7875,7 @@ static bool vehicle_update_track_motion_backwards_get_new_track(rct_vehicle *veh
*
* rct2: 0x006DBA33
*/
static bool vehicle_update_track_motion_backwards(rct_vehicle *vehicle, rct_ride_entry_vehicle* vehicleEntry, rct_ride* ride, rct_ride_entry* rideEntry) {
static bool vehicle_update_track_motion_backwards(rct_vehicle *vehicle, rct_ride_entry_vehicle* vehicleEntry, Ride* ride, rct_ride_entry* rideEntry) {
registers regs = { 0 };
loc_6DBA33:;
@ -8011,7 +8011,7 @@ extern const uint8 mini_golf_peep_animation_lengths[];
static sint32 vehicle_update_track_motion_mini_golf(rct_vehicle *vehicle, sint32* outStation) {
registers regs = { 0 };
rct_ride *ride = get_ride(vehicle->ride);
Ride *ride = get_ride(vehicle->ride);
rct_ride_entry *rideEntry = get_ride_entry(vehicle->ride_subtype);
rct_ride_entry_vehicle *vehicleEntry = vehicle_get_vehicle_entry(vehicle);
@ -8648,7 +8648,7 @@ sint32 vehicle_update_track_motion(rct_vehicle *vehicle, sint32 *outStation)
{
registers regs = { 0 };
rct_ride *ride = get_ride(vehicle->ride);
Ride *ride = get_ride(vehicle->ride);
rct_ride_entry *rideEntry = get_ride_entry(vehicle->ride_subtype);
rct_ride_entry_vehicle *vehicleEntry = vehicle_get_vehicle_entry(vehicle);
@ -8993,7 +8993,7 @@ sint32 vehicle_get_total_num_peeps(rct_vehicle *vehicle)
void vehicle_invalidate_window(rct_vehicle *vehicle)
{
sint32 viewVehicleIndex;
rct_ride *ride;
Ride *ride;
rct_window *w;
w = window_find_by_number(WC_RIDE, vehicle->ride);

2
src/openrct2/ride/water/boat_ride.c
View File

@ -63,7 +63,7 @@ static void paint_boat_ride_track_flat(paint_session * session, uint8 rideIndex,
static void paint_boat_ride_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_map_element * mapElement)
{
rct_xy16 position = session->MapPosition;
rct_ride * ride = get_ride(rideIndex);
Ride * ride = get_ride(rideIndex);
const rct_ride_entrance_definition * entranceStyle = &RideEntranceDefinitions[ride->entrance_style];
if (direction & 1) {

2
src/openrct2/ride/water/river_rapids.c
View File

@ -286,7 +286,7 @@ static void paint_river_rapids_track_flat(paint_session * session, uint8 rideInd
/** rct2: 0x007576C0 */
static void paint_river_rapids_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_map_element * mapElement)
{
rct_ride *ride = get_ride(rideIndex);
Ride *ride = get_ride(rideIndex);
paint_river_rapids_track_flat(session, rideIndex, trackSequence, direction, height, mapElement);
track_paint_util_draw_station_platform(session, ride, direction, height, 12, mapElement);

2
src/openrct2/ride/water/splash_boats.c
View File

@ -722,7 +722,7 @@ static void paint_splash_boats_track_flat(paint_session * session, uint8 rideInd
/** rct2: 0x0089B1A0 */
static void paint_splash_boats_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_map_element * mapElement)
{
rct_ride *ride = get_ride(rideIndex);
Ride *ride = get_ride(rideIndex);
if (direction & 1) {
uint32 imageId = (direction == 1 ? SPR_SPLASH_BOATS_FLAT_TOP_NW_SE : SPR_SPLASH_BOATS_FLAT_TOP_SE_NW) | gTrackColours[SCHEME_TRACK];

2
src/openrct2/ride/water/submarine_ride.c
View File

@ -71,7 +71,7 @@ void vehicle_visual_submarine(paint_session * session, sint32 x, sint32 imageDir
static void submarine_ride_paint_track_station(paint_session * session, uint8 rideIndex, uint8 trackSequence, uint8 direction, sint32 height, rct_map_element * mapElement)
{
rct_xy16 position = session->MapPosition;
rct_ride * ride = get_ride(rideIndex);
Ride * ride = get_ride(rideIndex);
const rct_ride_entrance_definition * entranceStyle = &RideEntranceDefinitions[ride->entrance_style];
sint32 heightLower = height - 16;
uint32 imageId;

10
src/openrct2/scenario/scenario.c
View File

@ -578,7 +578,7 @@ static bool scenario_prepare_rides_for_save()
{
sint32 isFiveCoasterObjective = gScenarioObjectiveType == OBJECTIVE_FINISH_5_ROLLERCOASTERS;
sint32 i;
rct_ride * ride;
Ride * ride;
uint8 rcs = 0;
FOR_ALL_RIDES(i, ride)
@ -766,7 +766,7 @@ void scenario_remove_trackless_rides(rct_s6_data *s6)
bool rideHasTrack[MAX_RIDES];
ride_all_has_any_track_elements(rideHasTrack);
for (sint32 i = 0; i < MAX_RIDES; i++) {
rct_ride *ride = &s6->rides[i];
rct2_ride * ride = &s6->rides[i];
if (rideHasTrack[i] || ride->type == RIDE_TYPE_NULL) {
continue;
@ -819,7 +819,7 @@ static void scenario_objective_check_10_rollercoasters()
{
sint32 i, rcs = 0;
uint8 type_already_counted[256];
rct_ride* ride;
Ride* ride;
memset(type_already_counted, 0, 256);
@ -901,7 +901,7 @@ static void scenario_objective_check_10_rollercoasters_length()
sint32 i, rcs = 0;
uint8 type_already_counted[256];
sint16 objective_length = gScenarioObjectiveNumGuests;
rct_ride* ride;
Ride* ride;
memset(type_already_counted, 0, 256);
@ -933,7 +933,7 @@ static void scenario_objective_check_finish_5_rollercoasters()
// Originally, this did not check for null rides, neither did it check if
// the rides are even rollercoasters, never mind the right rollercoasters to be finished.
sint32 i;
rct_ride * ride;
Ride * ride;
sint32 rcs = 0;
FOR_ALL_RIDES(i, ride)
{

2
src/openrct2/scenario/scenario.h
View File

@ -256,7 +256,7 @@ typedef struct rct_s6_data {
rct_banner banners[RCT2_MAX_BANNERS_IN_PARK];
char custom_strings[0x8000];
uint32 game_ticks_1;
rct_ride rides[RCT2_MAX_RIDES_IN_PARK];
rct2_ride rides[RCT2_MAX_RIDES_IN_PARK];
uint16 saved_age;
uint16 saved_view_x;
uint16 saved_view_y;

2
src/openrct2/windows/DemolishRidePrompt.cpp
View File

@ -128,7 +128,7 @@ static void window_ride_demolish_paint(rct_window *w, rct_drawpixelinfo *dpi)
{
window_draw_widgets(w, dpi);
rct_ride* ride = get_ride(w->number);
Ride* ride = get_ride(w->number);
set_format_arg(0, rct_string_id, ride->name);
set_format_arg(2, uint32, ride->name_arguments);

2
src/openrct2/windows/EditorObjectSelection.cpp
View File

@ -575,7 +575,7 @@ static void setup_in_use_selection_flags()
} while (map_element_iterator_next(&iter));
for (uint8 ride_index = 0; ride_index < 0xFF; ride_index++) {
rct_ride* ride = get_ride(ride_index);
Ride* ride = get_ride(ride_index);
if (ride->type != RIDE_TYPE_NULL) {
uint8 type = ride->subtype;
gEditorSelectedObjects[OBJECT_TYPE_RIDE][type] |= (1 << 0);

2
src/openrct2/windows/Finances.cpp
View File

@ -1162,7 +1162,7 @@ static void window_finances_marketing_invalidate(rct_window *w)
static void window_finances_marketing_paint(rct_window *w, rct_drawpixelinfo *dpi)
{
sint32 i, x, y, weeksRemaining;
rct_ride *ride;
Ride *ride;
window_draw_widgets(w, dpi);
window_finances_draw_tab_images(dpi, w);

12
src/openrct2/windows/Guest.cpp
View File

@ -723,7 +723,7 @@ void window_guest_viewport_init(rct_window* w){
|| peep->state == PEEP_STATE_ENTERING_RIDE
|| (peep->state == PEEP_STATE_LEAVING_RIDE && peep->x == SPRITE_LOCATION_NULL)){
rct_ride *ride = get_ride(peep->current_ride);
Ride *ride = get_ride(peep->current_ride);
if (ride->lifecycle_flags & RIDE_LIFECYCLE_ON_TRACK){
rct_vehicle* train = GET_VEHICLE(ride->vehicles[peep->current_train]);
sint32 car = peep->current_car;
@ -737,7 +737,7 @@ void window_guest_viewport_init(rct_window* w){
}
}
if (peep->x == SPRITE_LOCATION_NULL && final_check){
rct_ride *ride = get_ride(peep->current_ride);
Ride *ride = get_ride(peep->current_ride);
sint32 x = ride->overall_view.x * 32 + 16;
sint32 y = ride->overall_view.y * 32 + 16;
sint32 height = map_element_height(x, y);
@ -1540,7 +1540,7 @@ void window_guest_rides_update(rct_window *w)
uint8 ride_id_bit = ride_id % 8;
uint8 ride_id_offset = ride_id / 8;
if (peep->rides_been_on[ride_id_offset] & (1 << ride_id_bit)){
rct_ride* ride = get_ride(ride_id);
Ride* ride = get_ride(ride_id);
if (gRideClassifications[ride->type] == RIDE_CLASS_RIDE){
w->list_item_positions[curr_list_position] = ride_id;
curr_list_position++;
@ -1682,7 +1682,7 @@ void window_guest_rides_paint(rct_window *w, rct_drawpixelinfo *dpi)
sint32 ride_string_id = STR_PEEP_FAVOURITE_RIDE_NOT_AVAILABLE;
sint32 ride_string_arguments = 0;
if (peep->favourite_ride != 0xFF){
rct_ride* ride = get_ride(peep->favourite_ride);
Ride* ride = get_ride(peep->favourite_ride);
ride_string_arguments = ride->name_arguments;
ride_string_id = ride->name;
}
@ -1717,7 +1717,7 @@ void window_guest_rides_scroll_paint(rct_window *w, rct_drawpixelinfo *dpi, sint
gfx_filter_rect(dpi, 0, y, 800, y + 9, PALETTE_DARKEN_1);
string_format = STR_WINDOW_COLOUR_2_STRINGID;
}
rct_ride* ride = get_ride(w->list_item_positions[list_index]);
Ride* ride = get_ride(w->list_item_positions[list_index]);
gfx_draw_string_left(dpi, string_format, (void*)&ride->name, COLOUR_BLACK, 0, y - 1);
}
@ -2019,7 +2019,7 @@ void window_guest_inventory_invalidate(rct_window *w)
static rct_string_id window_guest_inventory_format_item(rct_peep *peep, sint32 item)
{
rct_ride *ride;
Ride *ride;
// Default arguments
set_format_arg(0, uint32, ShopItemImage[item]);

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

@ -241,7 +241,7 @@ void window_guest_list_open_with_filter(sint32 type, sint32 index)
switch(type) {
case GLFT_GUESTS_ON_RIDE:
{
rct_ride *ride = get_ride(index & 0x000000FF);
Ride *ride = get_ride(index & 0x000000FF);
_window_guest_list_filter_arguments[0] = STR_ON_RIDE;
if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_IN_RIDE)) {
_window_guest_list_filter_arguments[0] = STR_IN_RIDE;
@ -258,7 +258,7 @@ void window_guest_list_open_with_filter(sint32 type, sint32 index)
}
case GLFT_GUESTS_IN_QUEUE:
{
rct_ride *ride = get_ride(index & 0x000000FF);
Ride *ride = get_ride(index & 0x000000FF);
_window_guest_list_filter_arguments[0] = STR_QUEUING_FOR;
_window_guest_list_filter_arguments[1] = ride->name;
_window_guest_list_filter_arguments[2] = ride->name_arguments_type_name;
@ -272,7 +272,7 @@ void window_guest_list_open_with_filter(sint32 type, sint32 index)
}
case GLFT_GUESTS_THINKING_ABOUT_RIDE:
{
rct_ride *ride = get_ride(index & 0x000000FF);
Ride *ride = get_ride(index & 0x000000FF);
_window_guest_list_filter_arguments[0] = STR_NONE;
_window_guest_list_filter_arguments[1] = ride->name;
_window_guest_list_filter_arguments[2] = ride->name_arguments_type_name;

2
src/openrct2/windows/Map.cpp
View File

@ -1613,7 +1613,7 @@ static uint16 map_window_get_pixel_colour_peep(sint32 x, sint32 y)
static uint16 map_window_get_pixel_colour_ride(sint32 x, sint32 y)
{
rct_map_element *mapElement;
rct_ride *ride;
Ride *ride;
uint32 colour;
colour = FALLBACK_COLOUR(PALETTE_INDEX_13);

8
src/openrct2/windows/MazeConstruction.cpp
View File

@ -181,7 +181,7 @@ static void window_maze_construction_close(rct_window *w)
hide_gridlines();
uint8 rideIndex = _currentRideIndex;
rct_ride* ride = get_ride(rideIndex);
Ride* ride = get_ride(rideIndex);
if (ride->overall_view.xy == RCT_XY8_UNDEFINED) {
sint32 savedPausedState = gGamePaused;
gGamePaused = 0;
@ -296,7 +296,7 @@ static void window_maze_construction_mousedown(rct_window *w, rct_widgetindex wi
*/
static void window_maze_construction_update(rct_window *w)
{
rct_ride *ride = get_ride(_currentRideIndex);
Ride *ride = get_ride(_currentRideIndex);
if (ride == nullptr || ride->status != RIDE_STATUS_CLOSED) {
window_close(w);
return;
@ -393,7 +393,7 @@ static void window_maze_construction_entrance_tooldown(sint32 x, sint32 y, rct_w
gCommandPosition.y,
gCommandPosition.z);
rct_ride* ride = get_ride(rideIndex);
Ride* ride = get_ride(rideIndex);
if (ride_are_all_possible_entrances_and_exits_built(ride)){
tool_cancel();
if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_HAS_NO_TRACK))
@ -429,7 +429,7 @@ static void window_maze_construction_tooldown(rct_window* w, rct_widgetindex wid
*/
static void window_maze_construction_invalidate(rct_window *w)
{
rct_ride *ride = get_ride(_currentRideIndex);
Ride *ride = get_ride(_currentRideIndex);
// Set window title arguments
set_format_arg(4, rct_string_id, ride->name);

12
src/openrct2/windows/NewCampaign.cpp
View File

@ -100,7 +100,7 @@ uint8 window_new_campaign_shop_items[64];
static sint32 ride_value_compare(const void *a, const void *b)
{
rct_ride *rideA, *rideB;
Ride *rideA, *rideB;
rideA = get_ride(*((uint8*)a));
rideB = get_ride(*((uint8*)b));
@ -110,7 +110,7 @@ static sint32 ride_value_compare(const void *a, const void *b)
static sint32 ride_name_compare(const void *a, const void *b)
{
char rideAName[256], rideBName[256];
rct_ride *rideA, *rideB;
Ride *rideA, *rideB;
rideA = get_ride(*((uint8*)a));
rideB = get_ride(*((uint8*)b));
@ -128,7 +128,7 @@ static sint32 ride_name_compare(const void *a, const void *b)
void window_new_campaign_open(sint16 campaignType)
{
rct_window *w;
rct_ride *ride;
Ride *ride;
sint32 i, numApplicableRides;
w = window_bring_to_front_by_class(WC_NEW_CAMPAIGN);
@ -201,7 +201,7 @@ void window_new_campaign_open(sint16 campaignType)
static void window_new_campaign_get_shop_items()
{
sint32 i, numItems;
rct_ride *ride;
Ride *ride;
uint64 items = 0;
FOR_ALL_RIDES(i, ride) {
@ -287,7 +287,7 @@ static void window_new_campaign_mousedown(rct_window *w, rct_widgetindex widgetI
if (window_new_campaign_rides[i] == 255)
break;
rct_ride *ride = get_ride(window_new_campaign_rides[i]);
Ride *ride = get_ride(window_new_campaign_rides[i]);
gDropdownItemsFormat[i] = STR_DROPDOWN_MENU_LABEL;
gDropdownItemsArgs[i] = ((uint64)ride->name_arguments << 16ULL) | ride->name;
numItems++;
@ -356,7 +356,7 @@ static void window_new_campaign_invalidate(rct_window *w)
window_new_campaign_widgets[WIDX_RIDE_DROPDOWN_BUTTON].type = WWT_DROPDOWN_BUTTON;
window_new_campaign_widgets[WIDX_RIDE_LABEL].text = STR_MARKETING_RIDE;
if (w->campaign.ride_id != SELECTED_RIDE_UNDEFINED) {
rct_ride *ride = get_ride(w->campaign.ride_id);
Ride *ride = get_ride(w->campaign.ride_id);
window_new_campaign_widgets[WIDX_RIDE_DROPDOWN].text = ride->name;
set_format_arg(0, uint32, ride->name_arguments);
}

124
src/openrct2/windows/Ride.cpp
View File

@ -1297,7 +1297,7 @@ static void window_ride_draw_tab_vehicle(rct_drawpixelinfo *dpi, rct_window *w)
x = (widget->right - widget->left) / 2;
y = (widget->bottom - widget->top) - 12;
rct_ride *ride = get_ride(w->number);
Ride *ride = get_ride(w->number);
rct_ride_entry *rideEntry = get_ride_entry_by_ride(ride);
if (rideEntry->flags & RIDE_ENTRY_FLAG_VEHICLE_TAB_SCALE_HALF) {
@ -1387,7 +1387,7 @@ static void window_ride_draw_tab_images(rct_drawpixelinfo *dpi, rct_window *w)
static void window_ride_disable_tabs(rct_window *w)
{
uint32 disabled_tabs = 0;
rct_ride *ride = get_ride(w->number & 0xFF);
Ride *ride = get_ride(w->number & 0xFF);
uint8 ride_type = ride->type; // ecx
@ -1491,7 +1491,7 @@ static void window_ride_update_overall_view(uint8 ride_index) {
static rct_window *window_ride_open(sint32 rideIndex)
{
rct_window *w;
rct_ride *ride;
Ride *ride;
w = window_create_auto_pos(316, 207, window_ride_page_events[0], WC_RIDE, WF_10 | WF_RESIZABLE);
w->widgets = window_ride_page_widgets[WINDOW_RIDE_PAGE_MAIN];
@ -1557,7 +1557,7 @@ rct_window *window_ride_main_open(sint32 rideIndex)
rct_window *window_ride_open_station(sint32 rideIndex, sint32 stationIndex)
{
sint32 i;
rct_ride *ride;
Ride *ride;
rct_window *w;
ride = get_ride(rideIndex);
@ -1632,7 +1632,7 @@ rct_window *window_ride_open_vehicle(rct_vehicle *vehicle)
rct_vehicle *headVehicle = vehicle_get_head(vehicle);
uint16 headVehicleSpriteIndex = headVehicle->sprite_index;
sint32 rideIndex = headVehicle->ride;
rct_ride *ride = get_ride(rideIndex);
Ride *ride = get_ride(rideIndex);
// Get view index
sint32 view = 1;
@ -1784,7 +1784,7 @@ static void window_ride_init_viewport(rct_window *w)
{
if (w->page != WINDOW_RIDE_PAGE_MAIN) return;
rct_ride* ride = get_ride(w->number);
Ride* ride = get_ride(w->number);
sint32 eax = w->viewport_focus_coordinates.var_480 - 1;
union{
@ -1917,7 +1917,7 @@ static void window_ride_init_viewport(rct_window *w)
*/
static void window_ride_rename(rct_window *w)
{
rct_ride *ride;
Ride *ride;
ride = get_ride(w->number);
set_format_arg(16, uint32, ride->name_arguments);
@ -1931,7 +1931,7 @@ static void window_ride_rename(rct_window *w)
static void window_ride_main_mouseup(rct_window *w, rct_widgetindex widgetIndex)
{
uint8 rideIndex;
rct_ride *ride;
Ride *ride;
sint32 status;
switch (widgetIndex) {
@ -2017,7 +2017,7 @@ static void window_ride_main_resize(rct_window *w)
static void window_ride_show_view_dropdown(rct_window *w, rct_widget *widget)
{
rct_widget *dropdownWidget = widget - 1;
rct_ride *ride = get_ride(w->number);
Ride *ride = get_ride(w->number);
sint32 numItems = 1;
if (!ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_NO_VEHICLES)) {
@ -2077,7 +2077,7 @@ static void window_ride_show_view_dropdown(rct_window *w, rct_widget *widget)
*/
static void window_ride_show_open_dropdown(rct_window *w, rct_widget *widget)
{
rct_ride *ride;
Ride *ride;
sint32 numItems, highlightedIndex = 0, checkedIndex;
ride = get_ride(w->number);
@ -2210,7 +2210,7 @@ static void window_ride_main_mousedown(rct_window *w, rct_widgetindex widgetInde
*/
static void window_ride_main_dropdown(rct_window *w, rct_widgetindex widgetIndex, sint32 dropdownIndex)
{
rct_ride *ride;
Ride *ride;
sint32 status = 0;
switch (widgetIndex) {
@ -2277,7 +2277,7 @@ static void window_ride_main_update(rct_window *w)
widget_invalidate(w, WIDX_TAB_1);
// Update status
rct_ride *ride = get_ride(w->number);
Ride *ride = get_ride(w->number);
if (!(ride->window_invalidate_flags & RIDE_INVALIDATE_RIDE_MAIN)) {
if (w->ride.view == 0)
return;
@ -2342,7 +2342,7 @@ static void window_ride_main_invalidate(rct_window *w)
window_ride_set_pressed_tab(w);
rct_ride *ride = get_ride(w->number);
Ride *ride = get_ride(w->number);
w->disabled_widgets &= ~((1 << WIDX_DEMOLISH) | (1 << WIDX_CONSTRUCTION));
if (ride->lifecycle_flags & (RIDE_LIFECYCLE_INDESTRUCTIBLE | RIDE_LIFECYCLE_INDESTRUCTIBLE_TRACK))
w->disabled_widgets |= (1 << WIDX_DEMOLISH);
@ -2467,7 +2467,7 @@ static rct_string_id window_ride_get_status_overall_view(rct_window *w, void *ar
*/
static rct_string_id window_ride_get_status_vehicle(rct_window *w, void *arguments)
{
rct_ride *ride;
Ride *ride;
rct_vehicle *vehicle;
sint32 vehicleIndex;
uint16 vehicleSpriteIndex;
@ -2521,7 +2521,7 @@ static rct_string_id window_ride_get_status_vehicle(rct_window *w, void *argumen
*/
static rct_string_id window_ride_get_status_station(rct_window *w, void *arguments)
{
rct_ride *ride = get_ride(w->number);
Ride *ride = get_ride(w->number);
sint32 count = w->ride.view - ride->num_vehicles - 1;
sint32 stationIndex = -1;
rct_string_id stringId = 0;
@ -2564,7 +2564,7 @@ static rct_string_id window_ride_get_status_station(rct_window *w, void *argumen
*/
static rct_string_id window_ride_get_status(rct_window *w, void *arguments)
{
rct_ride *ride = get_ride(w->number);
Ride *ride = get_ride(w->number);
if (w->ride.view == 0)
return window_ride_get_status_overall_view(w, arguments);
@ -2581,7 +2581,7 @@ static rct_string_id window_ride_get_status(rct_window *w, void *arguments)
*/
static void window_ride_main_paint(rct_window *w, rct_drawpixelinfo *dpi)
{
rct_ride *ride;
Ride *ride;
rct_widget *widget;
rct_string_id stringId;
@ -2677,7 +2677,7 @@ static void window_ride_vehicle_resize(rct_window *w)
static void window_ride_vehicle_mousedown(rct_window *w, rct_widgetindex widgetIndex, rct_widget *widget)
{
rct_widget *dropdownWidget = widget - 1;
rct_ride *ride;
Ride *ride;
rct_ride_entry *rideEntry, *currentRideEntry;
const ride_group * rideGroup, * currentRideGroup;
sint32 numItems, rideEntryIndex, selectedIndex, rideTypeIterator, rideTypeIteratorMax;
@ -2811,7 +2811,7 @@ static void window_ride_vehicle_update(rct_window *w)
static void window_ride_vehicle_invalidate(rct_window *w)
{
rct_widget *widgets;
rct_ride *ride;
Ride *ride;
rct_ride_entry *rideEntry;
rct_string_id stringId;
sint32 carsPerTrain;
@ -2911,7 +2911,7 @@ static void window_ride_vehicle_invalidate(rct_window *w)
*/
static void window_ride_vehicle_paint(rct_window *w, rct_drawpixelinfo *dpi)
{
rct_ride *ride;
Ride *ride;
rct_ride_entry *rideEntry;
sint32 x, y;
sint16 factor;
@ -2979,7 +2979,7 @@ static rct_vehichle_paintinfo _sprites_to_draw[144];
*/
static void window_ride_vehicle_scrollpaint(rct_window *w, rct_drawpixelinfo *dpi, sint32 scrollIndex)
{
rct_ride *ride = get_ride(w->number);
Ride *ride = get_ride(w->number);
rct_ride_entry *rideEntry = get_ride_entry_by_ride(ride);
// Background
@ -3065,7 +3065,7 @@ static void set_operating_setting(sint32 rideNumber, uint8 setting, uint8 value)
static void window_ride_mode_tweak_set(rct_window *w, uint8 value)
{
rct_ride *ride = get_ride(w->number);
Ride *ride = get_ride(w->number);
gGameCommandErrorTitle = STR_CANT_CHANGE_LAUNCH_SPEED;
if (ride->mode == RIDE_MODE_STATION_TO_STATION)
@ -3094,7 +3094,7 @@ static void window_ride_mode_tweak_set(rct_window *w, uint8 value)
*/
static void window_ride_mode_tweak_increase(rct_window *w)
{
rct_ride *ride = get_ride(w->number);
Ride *ride = get_ride(w->number);
uint8 maxValue = RideProperties[ride->type].max_value;
uint8 minValue = gCheatsFastLiftHill ? 0 : RideProperties[ride->type].min_value;
@ -3114,7 +3114,7 @@ static void window_ride_mode_tweak_increase(rct_window *w)
*/
static void window_ride_mode_tweak_decrease(rct_window *w)
{
rct_ride *ride = get_ride(w->number);
Ride *ride = get_ride(w->number);
uint8 maxValue = RideProperties[ride->type].max_value;
uint8 minValue = gCheatsFastLiftHill ? 0 : RideProperties[ride->type].min_value;
@ -3135,7 +3135,7 @@ static void window_ride_mode_dropdown(rct_window *w, rct_widget *widget)
{
rct_ride_entry *rideEntry;
rct_widget *dropdownWidget;
rct_ride *ride;
Ride *ride;
const uint8 *availableModes, *mode;
sint32 i, numAvailableModes;
@ -3200,7 +3200,7 @@ static void window_ride_load_dropdown(rct_window *w, rct_widget *widget)
sint32 i;
dropdownWidget = widget - 1;
rct_ride *ride = get_ride(w->number);
Ride *ride = get_ride(w->number);
for (i = 0; i < 5; i++) {
gDropdownItemsFormat[i] = STR_DROPDOWN_MENU_LABEL;
@ -3226,7 +3226,7 @@ static void window_ride_load_dropdown(rct_window *w, rct_widget *widget)
*/
static void window_ride_operating_mouseup(rct_window *w, rct_widgetindex widgetIndex)
{
rct_ride *ride;
Ride *ride;
ride = get_ride(w->number);
@ -3279,7 +3279,7 @@ static void window_ride_operating_resize(rct_window *w)
*/
static void window_ride_operating_mousedown(rct_window *w, rct_widgetindex widgetIndex, rct_widget *widget)
{
rct_ride *ride = get_ride(w->number);
Ride *ride = get_ride(w->number);
uint8 upper_bound, lower_bound;
switch (widgetIndex) {
@ -3344,7 +3344,7 @@ static void window_ride_operating_mousedown(rct_window *w, rct_widgetindex widge
*/
static void window_ride_operating_dropdown(rct_window *w, rct_widgetindex widgetIndex, sint32 dropdownIndex)
{
rct_ride *ride;
Ride *ride;
const uint8 *availableModes;
if (dropdownIndex == -1)
@ -3371,7 +3371,7 @@ static void window_ride_operating_dropdown(rct_window *w, rct_widgetindex widget
*/
static void window_ride_operating_update(rct_window *w)
{
rct_ride *ride;
Ride *ride;
w->frame_no++;
window_event_invalidate_call(w);
@ -3391,7 +3391,7 @@ static void window_ride_operating_update(rct_window *w)
static void window_ride_operating_invalidate(rct_window *w)
{
rct_widget *widgets;
rct_ride *ride;
Ride *ride;
rct_ride_entry *rideEntry;
rct_string_id format, caption, tooltip;
@ -3606,7 +3606,7 @@ static void window_ride_operating_invalidate(rct_window *w)
*/
static void window_ride_operating_paint(rct_window *w, rct_drawpixelinfo *dpi)
{
rct_ride *ride;
Ride *ride;
uint16 blockSections;
window_draw_widgets(w, dpi);
@ -3643,7 +3643,7 @@ static void window_ride_operating_paint(rct_window *w, rct_drawpixelinfo *dpi)
*/
static void window_ride_locate_mechanic(rct_window *w)
{
rct_ride *ride;
Ride *ride;
rct_peep *mechanic;
ride = get_ride(w->number);
@ -3723,7 +3723,7 @@ static void window_ride_maintenance_resize(rct_window *w)
*/
static void window_ride_maintenance_mousedown(rct_window *w, rct_widgetindex widgetIndex, rct_widget *widget)
{
rct_ride *ride = get_ride(w->number);
Ride *ride = get_ride(w->number);
rct_ride_entry *ride_type = get_ride_entry(ride->subtype);
if (ride_type == nullptr) {
return;
@ -3825,7 +3825,7 @@ static void window_ride_maintenance_dropdown(rct_window *w, rct_widgetindex widg
return;
rct_vehicle *vehicle;
rct_ride *ride = get_ride(w->number);
Ride *ride = get_ride(w->number);
rct_ride_entry *ride_type = get_ride_entry(ride->subtype);
switch (widgetIndex) {
@ -3908,7 +3908,7 @@ static void window_ride_maintenance_dropdown(rct_window *w, rct_widgetindex widg
*/
static void window_ride_maintenance_update(rct_window *w)
{
rct_ride *ride;
Ride *ride;
w->frame_no++;
window_event_invalidate_call(w);
@ -3937,7 +3937,7 @@ static void window_ride_maintenance_invalidate(rct_window *w)
window_ride_set_pressed_tab(w);
rct_ride *ride = get_ride(w->number);
Ride *ride = get_ride(w->number);
set_format_arg(0, rct_string_id, ride->name);
set_format_arg(2, uint32, ride->name_arguments);
@ -3964,7 +3964,7 @@ static void window_ride_maintenance_paint(rct_window *w, rct_drawpixelinfo *dpi)
window_draw_widgets(w, dpi);
window_ride_draw_tab_images(dpi, w);
rct_ride *ride = get_ride(w->number);
Ride *ride = get_ride(w->number);
// Locate mechanic button image
rct_widget *widget = &window_ride_maintenance_widgets[WIDX_LOCATE_MECHANIC];
@ -4087,7 +4087,7 @@ static uint32 window_ride_get_colour_button_image(sint32 colour)
return IMAGE_TYPE_TRANSPARENT | SPRITE_ID_PALETTE_COLOUR_1(colour) | SPR_PALETTE_BTN;
}
static sint32 window_ride_has_track_colour(rct_ride *ride, sint32 trackColour)
static sint32 window_ride_has_track_colour(Ride *ride, sint32 trackColour)
{
uint16 colourUse = RideEntranceDefinitions[ride->entrance_style].colour_use_flags;
@ -4185,7 +4185,7 @@ static void window_ride_colour_resize(rct_window *w)
*/
static void window_ride_colour_mousedown(rct_window *w, rct_widgetindex widgetIndex, rct_widget *widget)
{
rct_ride *ride;
Ride *ride;
uint16 colourSchemeIndex;
vehicle_colour vehicleColour;
rct_widget *dropdownWidget;
@ -4421,7 +4421,7 @@ static void window_ride_colour_invalidate(rct_window *w)
{
rct_widget *widgets;
rct_ride_entry *rideEntry;
rct_ride *ride;
Ride *ride;
track_colour trackColour;
vehicle_colour vehicleColour;
@ -4597,7 +4597,7 @@ static void window_ride_colour_paint(rct_window *w, rct_drawpixelinfo *dpi)
// TODO: This should use lists and identified sprites
rct_drawpixelinfo clippedDpi;
rct_widget *widget;
rct_ride *ride;
Ride *ride;
rct_ride_entry *rideEntry;
ride = get_ride(w->number);
@ -4692,7 +4692,7 @@ static void window_ride_colour_paint(rct_window *w, rct_drawpixelinfo *dpi)
*/
static void window_ride_colour_scrollpaint(rct_window *w, rct_drawpixelinfo *dpi, sint32 scrollIndex)
{
rct_ride *ride;
Ride *ride;
rct_ride_entry *rideEntry;
rct_widget *vehiclePreviewWidget;
sint32 trainCarIndex, x, y, spriteIndex;
@ -4772,7 +4772,7 @@ static uint8 window_ride_current_music_style_order[42];
*/
static void window_ride_toggle_music(rct_window *w)
{
rct_ride *ride = get_ride(w->number);
Ride *ride = get_ride(w->number);
sint32 activateMusic = (ride->lifecycle_flags & RIDE_LIFECYCLE_MUSIC) ? 0 : 1;
@ -4831,7 +4831,7 @@ static void window_ride_music_mousedown(rct_window *w, rct_widgetindex widgetInd
return;
dropdownWidget = widget - 1;
rct_ride *ride = get_ride(w->number);
Ride *ride = get_ride(w->number);
sint32 numItems = 0;
if (ride->type == RIDE_TYPE_MERRY_GO_ROUND) {
@ -4913,7 +4913,7 @@ static void window_ride_music_invalidate(rct_window *w)
window_ride_set_pressed_tab(w);
rct_ride *ride = get_ride(w->number);
Ride *ride = get_ride(w->number);
set_format_arg(0, rct_string_id, ride->name);
set_format_arg(2, uint32, ride->name_arguments);
@ -5226,7 +5226,7 @@ static void window_ride_measurements_invalidate(rct_window *w)
window_ride_set_pressed_tab(w);
rct_ride *ride = get_ride(w->number);
Ride *ride = get_ride(w->number);
set_format_arg(0, rct_string_id, ride->name);
set_format_arg(2, uint32, ride->name_arguments);
@ -5282,7 +5282,7 @@ static void window_ride_measurements_paint(rct_window *w, rct_drawpixelinfo *dpi
y = w->y + window_ride_measurements_widgets[WIDX_SELECT_NEARBY_SCENERY].bottom + 17;
gfx_fill_rect_inset(dpi, x, y, w->x + 312, y + 1, w->colours[1], INSET_RECT_FLAG_BORDER_INSET);
} else {
rct_ride *ride = get_ride(w->number);
Ride *ride = get_ride(w->number);
sint32 x = w->x + window_ride_measurements_widgets[WIDX_PAGE_BACKGROUND].left + 4;
sint32 y = w->y + window_ride_measurements_widgets[WIDX_PAGE_BACKGROUND].top + 4;
@ -5597,7 +5597,7 @@ static void window_ride_graphs_tooltip(rct_window* w, rct_widgetindex widgetInde
rct_ride_measurement *measurement = ride_get_measurement(w->number, &message);
if (measurement != nullptr && (measurement->flags & RIDE_MEASUREMENT_FLAG_RUNNING)) {
set_format_arg(4, uint16, measurement->vehicle_index + 1);
rct_ride *ride = get_ride(w->number);
Ride *ride = get_ride(w->number);
set_format_arg(2, rct_string_id, RideComponentNames[RideNameConvention[ride->type].vehicle].count);
} else {
*stringId = message;
@ -5614,7 +5614,7 @@ static void window_ride_graphs_tooltip(rct_window* w, rct_widgetindex widgetInde
static void window_ride_graphs_invalidate(rct_window *w)
{
rct_widget *widgets;
rct_ride *ride;
Ride *ride;
sint32 x, y;
widgets = window_ride_page_widgets[w->page];
@ -5825,7 +5825,7 @@ static void update_same_price_throughout_flags(uint32 shop_item)
*/
static void window_ride_income_toggle_primary_price(rct_window *w)
{
rct_ride *ride;
Ride *ride;
rct_ride_entry *ride_type;
uint32 shop_item;
money16 price;
@ -5854,7 +5854,7 @@ static void window_ride_income_toggle_primary_price(rct_window *w)
*/
static void window_ride_income_toggle_secondary_price(rct_window *w)
{
rct_ride *ride;
Ride *ride;
rct_ride_entry *ride_type;
uint32 shop_item;
money16 price;
@ -5878,7 +5878,7 @@ static void window_ride_income_toggle_secondary_price(rct_window *w)
*/
static void window_ride_income_increase_primary_price(rct_window *w)
{
rct_ride *ride;
Ride *ride;
rct_ride_entry *ride_type;
ride = get_ride(w->number);
@ -5903,7 +5903,7 @@ static void window_ride_income_increase_primary_price(rct_window *w)
*/
static void window_ride_income_decrease_primary_price(rct_window *w)
{
rct_ride *ride;
Ride *ride;
rct_ride_entry *ride_type;
ride = get_ride(w->number);
@ -5928,7 +5928,7 @@ static void window_ride_income_decrease_primary_price(rct_window *w)
*/
static void window_ride_income_increase_secondary_price(rct_window *w)
{
rct_ride *ride;
Ride *ride;
ride = get_ride(w->number);
@ -5945,7 +5945,7 @@ static void window_ride_income_increase_secondary_price(rct_window *w)
*/
static void window_ride_income_decrease_secondary_price(rct_window *w)
{
rct_ride *ride;
Ride *ride;
ride = get_ride(w->number);
@ -6024,7 +6024,7 @@ static void window_ride_income_mousedown(rct_window *w, rct_widgetindex widgetIn
*/
static void window_ride_income_update(rct_window *w)
{
rct_ride *ride;
Ride *ride;
w->frame_no++;
window_event_invalidate_call(w);
@ -6055,7 +6055,7 @@ static void window_ride_income_invalidate(rct_window *w)
window_ride_set_pressed_tab(w);
rct_ride *ride = get_ride(w->number);
Ride *ride = get_ride(w->number);
set_format_arg(0, rct_string_id, ride->name);
set_format_arg(2, uint32, ride->name_arguments);
@ -6142,7 +6142,7 @@ static void window_ride_income_invalidate(rct_window *w)
*/
static void window_ride_income_paint(rct_window *w, rct_drawpixelinfo *dpi)
{
rct_ride *ride;
Ride *ride;
rct_ride_entry *rideEntry;
rct_string_id stringId;
money32 profit, costPerHour;
@ -6269,7 +6269,7 @@ static void window_ride_customer_resize(rct_window *w)
*/
static void window_ride_customer_update(rct_window *w)
{
rct_ride *ride;
Ride *ride;
w->var_492++;
if (w->var_492 >= 24)
@ -6301,7 +6301,7 @@ static void window_ride_customer_invalidate(rct_window *w)
window_ride_set_pressed_tab(w);
rct_ride *ride = get_ride(w->number);
Ride *ride = get_ride(w->number);
set_format_arg(0, rct_string_id, ride->name);
set_format_arg(2, uint32, ride->name_arguments);
@ -6324,7 +6324,7 @@ static void window_ride_customer_invalidate(rct_window *w)
*/
static void window_ride_customer_paint(rct_window *w, rct_drawpixelinfo *dpi)
{
rct_ride *ride;
Ride *ride;
sint32 x, y;
uint8 shopItem;
sint16 popularity, satisfaction, queueTime, age;

48
src/openrct2/windows/RideConstruction.cpp
View File

@ -485,7 +485,7 @@ static void sub_6CBCE2(
static void window_ride_construction_update_map_selection();
static void window_ride_construction_update_possible_ride_configurations();
static void window_ride_construction_update_widgets(rct_window *w);
static void window_ride_construction_select_map_tiles(rct_ride *ride, sint32 trackType, sint32 trackDirection, sint32 x, sint32 y);
static void window_ride_construction_select_map_tiles(Ride *ride, sint32 trackType, sint32 trackDirection, sint32 x, sint32 y);
static money32 _place_provisional_track_piece(sint32 rideIndex, sint32 trackType, sint32 trackDirection, sint32 liftHillAndAlternativeState, sint32 x, sint32 y, sint32 z);
static void window_ride_construction_show_special_track_dropdown(rct_window *w, rct_widget *widget);
static void ride_selected_track_set_seat_rotation(sint32 seatRotation);
@ -519,7 +519,7 @@ static bool is_track_enabled(sint32 trackFlagIndex)
return (_enabledRidePieces & (1ULL << trackFlagIndex)) != 0;
}
static sint32 ride_get_alternative_type(rct_ride *ride)
static sint32 ride_get_alternative_type(Ride *ride)
{
return (_currentTrackAlternative & RIDE_TYPE_ALTERNATIVE_TRACK_TYPE) ?
RideData4[ride->type].alternate_type :
@ -544,7 +544,7 @@ rct_window *window_ride_construction_open()
close_ride_window_for_construction(rideIndex);
rct_window *w;
rct_ride* ride = get_ride(rideIndex);
Ride* ride = get_ride(rideIndex);
_stationConstructed = ride->num_stations != 0;
_deferClose = false;
@ -654,7 +654,7 @@ static void window_ride_construction_close(rct_window *w)
uint8 rideIndex = _currentRideIndex;
if (ride_try_get_origin_element(rideIndex, nullptr)) {
rct_ride *ride = get_ride(rideIndex);
Ride *ride = get_ride(rideIndex);
// Auto open shops if required.
if (ride->mode == RIDE_MODE_SHOP_STALL && gConfigGeneral.auto_open_shops) {
// HACK: Until we find a good a way to defer the game command for opening the shop, stop this
@ -728,7 +728,7 @@ static void window_ride_construction_resize(rct_window *w)
w->enabled_widgets |= (1 << WIDX_CONSTRUCT);
}
rct_ride *ride = get_ride(_currentRideIndex);
Ride *ride = get_ride(_currentRideIndex);
sint32 rideType = ride_get_alternative_type(ride);
uint64 disabledWidgets = 0;
@ -1299,7 +1299,7 @@ static void window_ride_construction_resize(rct_window *w)
*/
static void window_ride_construction_mousedown(rct_window *w, rct_widgetindex widgetIndex, rct_widget *widget)
{
rct_ride *ride = get_ride(_currentRideIndex);
Ride *ride = get_ride(_currentRideIndex);
window_ride_construction_update_enabled_track_pieces();
switch (widgetIndex) {
@ -2002,7 +2002,7 @@ static void window_ride_construction_exit_click(rct_window *w)
*/
static void window_ride_construction_update(rct_window *w)
{
rct_ride *ride = get_ride(_currentRideIndex);
Ride *ride = get_ride(_currentRideIndex);
// Close construction window if ride is not closed,
// editing ride while open will cause many issues until properly handled
@ -2162,7 +2162,7 @@ static void window_ride_construction_tooldown(rct_window* w, rct_widgetindex wid
*/
static void window_ride_construction_invalidate(rct_window *w)
{
rct_ride *ride;
Ride *ride;
rct_string_id stringId;
ride = get_ride(_currentRideIndex);
@ -2250,7 +2250,7 @@ static void window_ride_construction_draw_track_piece(
sint32 width, sint32 height
) {
const rct_preview_track *trackBlock;
rct_ride *ride;
Ride *ride;
ride = get_ride(rideIndex);
@ -2339,7 +2339,7 @@ static void sub_6CBCE2(
sint32 rideIndex, sint32 trackType, sint32 trackDirection, sint32 edx,
sint32 originX, sint32 originY, sint32 originZ
) {
rct_ride *ride;
Ride *ride;
const rct_preview_track *trackBlock;
sint32 preserve_current_viewport_flags;
sint32 offsetX, offsetY;
@ -2603,7 +2603,7 @@ bool _sub_6CA2DF(sint32 *_trackType, sint32 *_trackDirection, sint32 *_rideIndex
liftHillAndAlternativeState |= RIDE_TYPE_ALTERNATIVE_TRACK_TYPE;
}
rct_ride *ride = get_ride(rideIndex);
Ride *ride = get_ride(rideIndex);
if (_enabledRidePieces & (1ULL << TRACK_SLOPE_STEEP_LONG)) {
switch (trackType) {
@ -2730,7 +2730,7 @@ bool _sub_6CA2DF(sint32 *_trackType, sint32 *_trackDirection, sint32 *_rideIndex
*/
static void window_ride_construction_update_enabled_track_pieces()
{
rct_ride *ride = get_ride(_currentRideIndex);
Ride *ride = get_ride(_currentRideIndex);
rct_ride_entry *rideEntry = get_ride_entry_by_ride(ride);
if (rideEntry == nullptr)
@ -2763,7 +2763,7 @@ static void window_ride_construction_update_enabled_track_pieces()
*/
money32 _place_provisional_track_piece(sint32 rideIndex, sint32 trackType, sint32 trackDirection, sint32 liftHillAndAlternativeState, sint32 x, sint32 y, sint32 z)
{
rct_ride *ride;
Ride *ride;
money32 result;
ride_construction_remove_ghosts();
@ -2910,7 +2910,7 @@ void sub_6C94D8()
*/
static void window_ride_construction_update_map_selection()
{
rct_ride *ride;
Ride *ride;
sint32 trackType, trackDirection, x, y;
map_invalidate_map_selection_tiles();
@ -2951,7 +2951,7 @@ static void window_ride_construction_update_map_selection()
*/
static void window_ride_construction_update_possible_ride_configurations()
{
rct_ride *ride;
Ride *ride;
sint32 trackType;
sint32 edi;
@ -3043,7 +3043,7 @@ static void window_ride_construction_update_possible_ride_configurations()
static void window_ride_construction_update_widgets(rct_window *w)
{
uint8 rideIndex = _currentRideIndex;
rct_ride *ride = get_ride(rideIndex);
Ride *ride = get_ride(rideIndex);
sint32 rideType = ride_get_alternative_type(ride);
w->hold_down_widgets = 0;
@ -3507,7 +3507,7 @@ static void window_ride_construction_update_widgets(rct_window *w)
window_invalidate(w);
}
static void window_ride_construction_select_map_tiles(rct_ride *ride, sint32 trackType, sint32 trackDirection, sint32 x, sint32 y)
static void window_ride_construction_select_map_tiles(Ride *ride, sint32 trackType, sint32 trackDirection, sint32 x, sint32 y)
{
const rct_preview_track *trackBlock;
sint32 offsetX, offsetY;
@ -3555,13 +3555,13 @@ static void window_ride_construction_show_special_track_dropdown(rct_window *w,
uint8 trackPiece = _currentPossibleRideConfigurations[i];
rct_string_id trackPieceStringId = RideConfigurationStringIds[trackPiece];
if (trackPieceStringId == STR_RAPIDS) {
rct_ride *ride = get_ride(_currentRideIndex);
Ride *ride = get_ride(_currentRideIndex);
if (ride->type == RIDE_TYPE_CAR_RIDE)
trackPieceStringId = STR_LOG_BUMPS;
}
if (trackPieceStringId == STR_SPINNING_CONTROL_TOGGLE_TRACK) {
rct_ride *ride = get_ride(_currentRideIndex);
Ride *ride = get_ride(_currentRideIndex);
if (ride->type != RIDE_TYPE_WILD_MOUSE)
trackPieceStringId = STR_BOOSTER;
}
@ -3655,7 +3655,7 @@ static void ride_construction_set_brakes_speed(sint32 brakesSpeed)
void ride_construction_toolupdate_construct(sint32 screenX, sint32 screenY)
{
sint32 x, y, z;
rct_ride *ride;
Ride *ride;
const rct_preview_track *trackBlock;
map_invalidate_map_selection_tiles();
@ -3883,7 +3883,7 @@ void ride_construction_tooldown_construct(sint32 screenX, sint32 screenY)
tool_cancel();
rct_ride *ride = get_ride(_currentRideIndex);
Ride *ride = get_ride(_currentRideIndex);
if (_trackPlaceZ == 0) {
const rct_preview_track *trackBlock = get_track_def_from_ride(ride, _currentTrackPieceType);
sint32 bx = 0;
@ -4079,7 +4079,7 @@ void game_command_callback_place_ride_entrance_or_exit(sint32 eax, sint32 ebx, s
gCommandPosition.z
);
rct_ride *ride = get_ride(gRideEntranceExitPlaceRideIndex);
Ride *ride = get_ride(gRideEntranceExitPlaceRideIndex);
if (ride_are_all_possible_entrances_and_exits_built(ride)) {
tool_cancel();
if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_HAS_NO_TRACK)) {
@ -4094,7 +4094,7 @@ void game_command_callback_place_ride_entrance_or_exit(sint32 eax, sint32 ebx, s
void window_ride_construction_do_station_check()
{
rct_ride *ride = get_ride(_currentRideIndex);
Ride *ride = get_ride(_currentRideIndex);
if (ride != nullptr) {
_stationConstructed = ride->num_stations != 0;
}
@ -4103,7 +4103,7 @@ void window_ride_construction_do_station_check()
void window_ride_construction_do_entrance_exit_check()
{
rct_window *w = window_find_by_class(WC_RIDE_CONSTRUCTION);
rct_ride *ride = get_ride(_currentRideIndex);
Ride *ride = get_ride(_currentRideIndex);
if (w == nullptr || ride == nullptr) {
return;

10
src/openrct2/windows/RideList.cpp
View File

@ -518,7 +518,7 @@ static void window_ride_list_invalidate(rct_window *w)
sint8 allClosed = -1;
sint8 allOpen = -1;
sint32 i;
rct_ride *ride;
Ride *ride;
FOR_ALL_RIDES(i, ride) {
if (w->page != gRideClassifications[ride->type])
continue;
@ -566,7 +566,7 @@ static void window_ride_list_scrollpaint(rct_window *w, rct_drawpixelinfo *dpi,
{
sint32 i, y, argument;
rct_string_id format, formatSecondary;
rct_ride *ride;
Ride *ride;
gfx_fill_rect(dpi, dpi->x, dpi->y, dpi->x + dpi->width, dpi->y + dpi->height, ColourMapA[w->colours[1]].mid_light);
@ -741,7 +741,7 @@ static void window_ride_list_draw_tab_images(rct_drawpixelinfo *dpi, rct_window
void window_ride_list_refresh_list(rct_window *w)
{
sint32 i;
rct_ride *ride, *otherRide;
Ride *ride, *otherRide;
char bufferA[128], bufferB[128];
sint32 list_index = 0;
@ -906,7 +906,7 @@ void window_ride_list_refresh_list(rct_window *w)
static void window_ride_list_close_all(rct_window *w)
{
sint32 i;
rct_ride *ride;
Ride *ride;
FOR_ALL_RIDES(i, ride) {
if (w->page != gRideClassifications[ride->type])
@ -925,7 +925,7 @@ static void window_ride_list_close_all(rct_window *w)
static void window_ride_list_open_all(rct_window *w)
{
sint32 i;
rct_ride *ride;
Ride *ride;
FOR_ALL_RIDES(i, ride) {
if (w->page != gRideClassifications[ride->type])

4
src/openrct2/windows/Sign.cpp
View File

@ -250,7 +250,7 @@ static void window_sign_mouseup(rct_window *w, rct_widgetindex widgetIndex)
break;
case WIDX_SIGN_TEXT:
if (banner->flags & BANNER_FLAG_LINKED_TO_RIDE){
rct_ride* ride = get_ride(banner->colour);
Ride* ride = get_ride(banner->colour);
set_format_arg(16, uint32, ride->name_arguments);
string_id = ride->name;
}
@ -511,7 +511,7 @@ static void window_sign_small_mouseup(rct_window *w, rct_widgetindex widgetIndex
break;
case WIDX_SIGN_TEXT:
if (banner->flags & BANNER_FLAG_LINKED_TO_RIDE){
rct_ride* ride = get_ride(banner->colour);
Ride* ride = get_ride(banner->colour);
set_format_arg(16, uint32, ride->name_arguments);
string_id = ride->name;
}

2
src/openrct2/windows/TileInspector.cpp
View File

@ -1724,7 +1724,7 @@ static void window_tile_inspector_paint(rct_window *w, rct_drawpixelinfo *dpi)
// Details
// Ride
sint16 rideId = mapElement->properties.track.ride_index;
rct_ride *ride = get_ride(rideId);
Ride *ride = get_ride(rideId);
rct_string_id rideType = RideNaming[ride->type].name;
gfx_draw_string_left(dpi, STR_TILE_INSPECTOR_TRACK_RIDE_TYPE, &rideType, COLOUR_DARK_GREEN, x, y);
gfx_draw_string_left(dpi, STR_TILE_INSPECTOR_TRACK_RIDE_ID, &rideId, COLOUR_DARK_GREEN, x, y + 11);

4
src/openrct2/world/Banner.cpp
View File

@ -41,7 +41,7 @@ rct_banner gBanners[MAX_BANNERS];
static sint32 banner_get_ride_index_at(sint32 x, sint32 y, sint32 z)
{
rct_map_element *mapElement;
rct_ride *ride;
Ride *ride;
sint32 rideIndex, resultRideIndex;
resultRideIndex = -1;
@ -491,7 +491,7 @@ extern "C"
sint32 banner_get_closest_ride_index(sint32 x, sint32 y, sint32 z)
{
sint32 i, rideIndex;
rct_ride *ride;
Ride *ride;
static const rct_xy16 NeighbourCheckOrder[] =
{

4
src/openrct2/world/Entrance.cpp
View File

@ -291,7 +291,7 @@ static money32 RideEntranceExitPlace(sint16 x,
return MONEY32_UNDEFINED;
}
rct_ride* ride = get_ride(rideIndex);
Ride* ride = get_ride(rideIndex);
if (ride->type == RIDE_TYPE_NULL)
{
log_warning("Invalid game command for ride %u", rideIndex);
@ -460,7 +460,7 @@ static money32 RideEntranceExitRemove(sint16 x, sint16 y, uint8 rideIndex, uint8
return MONEY32_UNDEFINED;
}
rct_ride* ride = get_ride(rideIndex);
Ride* ride = get_ride(rideIndex);
if (ride->type == RIDE_TYPE_NULL)
{
log_warning("Invalid ride id %u for entrance/exit removal", rideIndex);

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

@ -72,7 +72,7 @@ static bool WallCheckObstructionWithTrack(rct_scenery_entry * wall,
sint32 trackType = trackElement->properties.track.type;
sint32 sequence = map_element_get_track_sequence(trackElement);
sint32 direction = (edge - map_element_get_direction(trackElement)) & MAP_ELEMENT_DIRECTION_MASK;
rct_ride * ride = get_ride(trackElement->properties.track.ride_index);
Ride * ride = get_ride(trackElement->properties.track.ride_index);
if (TrackIsAllowedWallEdges(ride->type, trackType, sequence, direction))
{

8
src/openrct2/world/footpath.c
View File

@ -1205,7 +1205,7 @@ static void loc_6A6D7E(
break;
case MAP_ELEMENT_TYPE_TRACK:
if (z == mapElement->base_height) {
rct_ride *ride = get_ride(mapElement->properties.track.ride_index);
Ride *ride = get_ride(mapElement->properties.track.ride_index);
if (!ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_FLAT_RIDE)) {
continue;
}
@ -1298,7 +1298,7 @@ static void loc_6A6C85(
}
if (map_element_get_type(mapElement) == MAP_ELEMENT_TYPE_TRACK) {
rct_ride *ride = get_ride(mapElement->properties.track.ride_index);
Ride *ride = get_ride(mapElement->properties.track.ride_index);
if (!ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_FLAT_RIDE)) {
return;
}
@ -1513,7 +1513,7 @@ void footpath_update_queue_chains()
{
for (uint8 *queueChainPtr = _footpathQueueChain; queueChainPtr < _footpathQueueChainNext; queueChainPtr++) {
uint8 rideIndex = *queueChainPtr;
rct_ride *ride = get_ride(rideIndex);
Ride *ride = get_ride(rideIndex);
if (ride->type == RIDE_TYPE_NULL) {
continue;
}
@ -2116,7 +2116,7 @@ void footpath_remove_edges_at(sint32 x, sint32 y, rct_map_element *mapElement)
{
if (map_element_get_type(mapElement) == MAP_ELEMENT_TYPE_TRACK) {
sint32 rideIndex = mapElement->properties.track.ride_index;
rct_ride *ride = get_ride(rideIndex);
Ride *ride = get_ride(rideIndex);
if (!ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_FLAT_RIDE))
return;
}

2
src/openrct2/world/map.c
View File

@ -3210,7 +3210,7 @@ bool map_element_check_address(const rct_map_element * const element)
void map_obstruction_set_error_text(rct_map_element *mapElement)
{
rct_string_id errorStringId;
rct_ride *ride;
Ride *ride;
rct_scenery_entry *sceneryEntry;
errorStringId = STR_OBJECT_IN_THE_WAY;

2
src/openrct2/world/map_animation.c
View File

@ -110,7 +110,7 @@ static bool map_animation_invalidate(rct_map_animation *obj)
static bool map_animation_invalidate_ride_entrance(sint32 x, sint32 y, sint32 baseZ)
{
rct_map_element *mapElement;
rct_ride *ride;
Ride *ride;
const rct_ride_entrance_definition *entranceDefinition;
mapElement = map_get_first_element_at(x >> 5, y >> 5);

8
src/openrct2/world/park.c
View File

@ -233,7 +233,7 @@ sint32 calculate_park_rating()
sint32 i;
sint16 total_ride_uptime = 0, total_ride_intensity = 0, total_ride_excitement = 0;
sint32 num_rides, num_exciting_rides = 0;
rct_ride* ride;
Ride* ride;
num_rides = 0;
FOR_ALL_RIDES(i, ride) {
@ -298,7 +298,7 @@ sint32 calculate_park_rating()
return result;
}
static money32 calculate_ride_value(rct_ride *ride)
static money32 calculate_ride_value(Ride *ride)
{
if (ride->type == RIDE_TYPE_NULL)
return 0;
@ -319,7 +319,7 @@ money32 calculate_park_value()
// Sum ride values
money32 result = 0;
for (sint32 i = 0; i < 255; i++) {
rct_ride* ride = get_ride(i);
Ride* ride = get_ride(i);
result += calculate_ride_value(ride);
}
@ -368,7 +368,7 @@ static sint32 park_calculate_guest_generation_probability()
uint32 probability;
sint32 i, suggestedMaxGuests;
money16 totalRideValue;
rct_ride *ride;
Ride *ride;
// Calculate suggested guest maximum (based on ride type) and total ride value
suggestedMaxGuests = 0;

4
src/openrct2/world/tile_inspector.c
View File

@ -600,7 +600,7 @@ sint32 tile_inspector_track_base_height_offset(sint32 x, sint32 y, sint32 elemen
sint16 originZ = trackElement->base_height * 8;
uint8 rotation = map_element_get_direction(trackElement);
uint8 rideIndex = trackElement->properties.track.ride_index;
rct_ride* ride = get_ride(rideIndex);
Ride* ride = get_ride(rideIndex);
const rct_preview_track* trackBlock = get_track_def_from_ride(ride, type);
trackBlock += map_element_get_track_sequence(trackElement);
@ -732,7 +732,7 @@ sint32 tile_inspector_track_set_chain(sint32 x, sint32 y, sint32 elementIndex, b
sint16 originZ = trackElement->base_height * 8;
uint8 rotation = map_element_get_direction(trackElement);
uint8 rideIndex = trackElement->properties.track.ride_index;
rct_ride* ride = get_ride(rideIndex);
Ride* ride = get_ride(rideIndex);
const rct_preview_track* trackBlock = get_track_def_from_ride(ride, type);
trackBlock += map_element_get_track_sequence(trackElement);

2
test/testpaint/TestPaint.cpp
View File

@ -47,7 +47,7 @@ namespace TestPaint
unk_140E9A8 = &dpi;
gPaintSession.Unk140E9A8 = &dpi;
rct_ride ride = {0};
Ride ride = {0};
ride.entrance_style = RIDE_ENTRANCE_STYLE_PLAIN;
rct_ride_entry rideEntry = {0};