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

Refactor rides to be only accessible with getters 

This changes how rides are accessed from macros to getter functions.
This commit is contained in:
Michał Janiszewski 2016-01-22 15:38:52 +01:00
parent 414c97ed8c
commit 6d6f9f3c23
41 changed files with 513 additions and 494 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/interface/console.c
View File

@ -783,7 +783,7 @@ static int cc_load_object(const utf8 **argv, int argc) {
rct_ride_type *rideEntry; rct_ride_type *rideEntry;
int rideType; int rideType;
rideEntry = GET_RIDE_ENTRY(entryGroupIndex); rideEntry = get_ride_entry(entryGroupIndex);
for (int j = 0; j < 3; j++) { for (int j = 0; j < 3; j++) {
rideType = rideEntry->ride_type[j]; rideType = rideEntry->ride_type[j];

6
src/interface/viewport.c
View File

@ -1099,7 +1099,7 @@ void viewport_vehicle_paint_setup(rct_vehicle *vehicle, int imageDirection)
if (vehicle->ride_subtype == 0xFF) { if (vehicle->ride_subtype == 0xFF) {
vehicleEntry = &CableLiftVehicle; vehicleEntry = &CableLiftVehicle;
} else { } else {
rideEntry = GET_RIDE_ENTRY(vehicle->ride_subtype); rideEntry = get_ride_entry(vehicle->ride_subtype);
vehicleEntry = &rideEntry->vehicles[vehicle->vehicle_type]; vehicleEntry = &rideEntry->vehicles[vehicle->vehicle_type];
if (vehicle->update_flags & VEHICLE_UPDATE_FLAG_11) { if (vehicle->update_flags & VEHICLE_UPDATE_FLAG_11) {
@ -1255,7 +1255,7 @@ void viewport_ride_entrance_exit_paint_setup(uint8 direction, int height, rct_ma
return; return;
} }
rct_ride* ride = GET_RIDE(map_element->properties.entrance.ride_index); rct_ride* ride = get_ride(map_element->properties.entrance.ride_index);
if (ride->entrance_style == RIDE_ENTRANCE_STYLE_NONE) return; if (ride->entrance_style == RIDE_ENTRANCE_STYLE_NONE) return;
const rct_ride_entrance_definition *style = &RideEntranceDefinitions[ride->entrance_style]; const rct_ride_entrance_definition *style = &RideEntranceDefinitions[ride->entrance_style];
@ -1530,7 +1530,7 @@ void viewport_track_paint_setup(uint8 direction, int height, rct_map_element *ma
int rideIndex, trackType, trackColourScheme, trackSequence; int rideIndex, trackType, trackColourScheme, trackSequence;
rideIndex = mapElement->properties.track.ride_index; rideIndex = mapElement->properties.track.ride_index;
ride = GET_RIDE(rideIndex); ride = get_ride(rideIndex);
if (ride->type == RIDE_TYPE_NULL) { if (ride->type == RIDE_TYPE_NULL) {
log_error("Attempted to paint invalid ride: %d", rideIndex); log_error("Attempted to paint invalid ride: %d", rideIndex);
return; return;

4
src/interface/viewport_interaction.c
View File

@ -196,7 +196,7 @@ int viewport_interaction_get_item_right(int x, int y, viewport_interaction_info
return info->type = VIEWPORT_INTERACTION_ITEM_NONE; return info->type = VIEWPORT_INTERACTION_ITEM_NONE;
mapElement += 6; mapElement += 6;
ride = GET_RIDE(mapElement->type); ride = get_ride(mapElement->type);
if (ride->status == RIDE_STATUS_CLOSED) { if (ride->status == RIDE_STATUS_CLOSED) {
RCT2_GLOBAL(RCT2_ADDRESS_MAP_TOOLTIP_ARGS + 0, uint16) = 1163; RCT2_GLOBAL(RCT2_ADDRESS_MAP_TOOLTIP_ARGS + 0, uint16) = 1163;
RCT2_GLOBAL(RCT2_ADDRESS_MAP_TOOLTIP_ARGS + 2, uint16) = ride->name; RCT2_GLOBAL(RCT2_ADDRESS_MAP_TOOLTIP_ARGS + 2, uint16) = ride->name;
@ -210,7 +210,7 @@ int viewport_interaction_get_item_right(int x, int y, viewport_interaction_info
if (map_element_get_type(mapElement) == MAP_ELEMENT_TYPE_PATH) if (map_element_get_type(mapElement) == MAP_ELEMENT_TYPE_PATH)
return info->type = VIEWPORT_INTERACTION_ITEM_NONE; return info->type = VIEWPORT_INTERACTION_ITEM_NONE;
ride = GET_RIDE(mapElement->properties.track.ride_index); ride = get_ride(mapElement->properties.track.ride_index);
if (ride->status != RIDE_STATUS_CLOSED) if (ride->status != RIDE_STATUS_CLOSED)
return info->type; return info->type;

10
src/management/award.c
View File

@ -139,7 +139,7 @@ static int award_is_deserved_best_rollercoasters(int awardType, int activeAwardT
rollerCoasters = 0; rollerCoasters = 0;
FOR_ALL_RIDES(i, ride) { FOR_ALL_RIDES(i, ride) {
rideType = gRideTypeList[ride->subtype]; rideType = get_ride_entry(ride->subtype);
if (rideType->category[0] != RIDE_GROUP_ROLLERCOASTER && rideType->category[1] != RIDE_GROUP_ROLLERCOASTER) if (rideType->category[0] != RIDE_GROUP_ROLLERCOASTER && rideType->category[1] != RIDE_GROUP_ROLLERCOASTER)
continue; continue;
@ -295,7 +295,7 @@ static int award_is_deserved_best_food(int awardType, int activeAwardTypes)
continue; continue;
shops++; shops++;
rideType = gRideTypeList[ride->subtype]; rideType = get_ride_entry(ride->subtype);
if (!(shopTypes & (1ULL << rideType->shop_item))) { if (!(shopTypes & (1ULL << rideType->shop_item))) {
shopTypes |= (1ULL << rideType->shop_item); shopTypes |= (1ULL << rideType->shop_item);
uniqueShops++; uniqueShops++;
@ -341,7 +341,7 @@ static int award_is_deserved_worst_food(int awardType, int activeAwardTypes)
continue; continue;
shops++; shops++;
rideType = gRideTypeList[ride->subtype]; rideType = get_ride_entry(ride->subtype);
if (!(shopTypes & (1ULL << rideType->shop_item))) { if (!(shopTypes & (1ULL << rideType->shop_item))) {
shopTypes |= (1ULL << rideType->shop_item); shopTypes |= (1ULL << rideType->shop_item);
uniqueShops++; uniqueShops++;
@ -438,7 +438,7 @@ static int award_is_deserved_best_water_rides(int awardType, int activeAwardType
waterRides = 0; waterRides = 0;
FOR_ALL_RIDES(i, ride) { FOR_ALL_RIDES(i, ride) {
rideType = gRideTypeList[ride->subtype]; rideType = get_ride_entry(ride->subtype);
if (rideType->category[0] != RIDE_GROUP_WATER && rideType->category[1] != RIDE_GROUP_WATER) if (rideType->category[0] != RIDE_GROUP_WATER && rideType->category[1] != RIDE_GROUP_WATER)
continue; continue;
@ -538,7 +538,7 @@ static int award_is_deserved_best_gentle_rides(int awardType, int activeAwardTyp
gentleRides = 0; gentleRides = 0;
FOR_ALL_RIDES(i, ride) { FOR_ALL_RIDES(i, ride) {
rideType = gRideTypeList[ride->subtype]; rideType = get_ride_entry(ride->subtype);
if (rideType->category[0] != RIDE_GROUP_GENTLE && rideType->category[1] != RIDE_GROUP_GENTLE) if (rideType->category[0] != RIDE_GROUP_GENTLE && rideType->category[1] != RIDE_GROUP_GENTLE)
continue; continue;

6
src/management/marketing.c
View File

@ -59,7 +59,7 @@ int marketing_get_campaign_guest_generation_probability(int campaign)
probability /= 8; probability /= 8;
break; break;
case ADVERTISING_CAMPAIGN_RIDE_FREE: case ADVERTISING_CAMPAIGN_RIDE_FREE:
ride = &g_ride_list[gMarketingCampaignRideIndex[campaign]]; ride = get_ride(gMarketingCampaignRideIndex[campaign]);
if (ride->price < 3) if (ride->price < 3)
probability /= 8; probability /= 8;
break; break;
@ -94,7 +94,7 @@ void marketing_update()
// This sets the string parameters for the marketing types that have an argument. // This sets the string parameters for the marketing types that have an argument.
if (campaign == ADVERTISING_CAMPAIGN_RIDE_FREE || campaign == ADVERTISING_CAMPAIGN_RIDE) { if (campaign == ADVERTISING_CAMPAIGN_RIDE_FREE || campaign == ADVERTISING_CAMPAIGN_RIDE) {
rct_ride* ride = GET_RIDE(campaignItem); rct_ride* ride = get_ride(campaignItem);
RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS, uint16) = ride->name; RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS, uint16) = ride->name;
RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 2, uint32) = ride->name_arguments; RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 2, uint32) = ride->name_arguments;
} else if (campaign == ADVERTISING_CAMPAIGN_FOOD_OR_DRINK_FREE) { } else if (campaign == ADVERTISING_CAMPAIGN_FOOD_OR_DRINK_FREE) {
@ -209,7 +209,7 @@ bool marketing_is_campaign_type_applicable(int campaignType)
case ADVERTISING_CAMPAIGN_FOOD_OR_DRINK_FREE: case ADVERTISING_CAMPAIGN_FOOD_OR_DRINK_FREE:
// Check if any food or drink stalls exist // Check if any food or drink stalls exist
FOR_ALL_RIDES(i, ride) { FOR_ALL_RIDES(i, ride) {
rideEntry = GET_RIDE_ENTRY(ride->subtype); rideEntry = get_ride_entry(ride->subtype);
if ( if (
shop_item_is_food_or_drink(rideEntry->shop_item) || shop_item_is_food_or_drink(rideEntry->shop_item) ||
shop_item_is_food_or_drink(rideEntry->shop_item_secondary) shop_item_is_food_or_drink(rideEntry->shop_item_secondary)

4
src/management/news_item.c
View File

@ -234,7 +234,7 @@ void news_item_get_subject_location(int type, int subject, int *x, int *y, int *
switch (type) { switch (type) {
case NEWS_ITEM_RIDE: case NEWS_ITEM_RIDE:
ride = &g_ride_list[subject]; ride = get_ride(subject);
if (ride->overall_view == 0xFFFF) { if (ride->overall_view == 0xFFFF) {
*x = SPRITE_LOCATION_NULL; *x = SPRITE_LOCATION_NULL;
break; break;
@ -257,7 +257,7 @@ void news_item_get_subject_location(int type, int subject, int *x, int *y, int *
} }
// Find which ride peep is on // Find which ride peep is on
ride = &g_ride_list[peep->current_ride]; ride = get_ride(peep->current_ride);
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_ON_TRACK)) { if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_ON_TRACK)) {
*x = SPRITE_LOCATION_NULL; *x = SPRITE_LOCATION_NULL;
break; break;

12
src/management/research.c
View File

@ -177,7 +177,7 @@ void research_finish_item(sint32 entryIndex)
// Ride // Ride
base_ride_type = (entryIndex >> 8) & 0xFF; base_ride_type = (entryIndex >> 8) & 0xFF;
rideEntryIndex = entryIndex & 0xFF; rideEntryIndex = entryIndex & 0xFF;
rideEntry = GET_RIDE_ENTRY(rideEntryIndex); rideEntry = get_ride_entry(rideEntryIndex);
RCT2_ADDRESS(0x01357404, uint32)[base_ride_type >> 5] |= (1u << (base_ride_type & 0x1F)); RCT2_ADDRESS(0x01357404, uint32)[base_ride_type >> 5] |= (1u << (base_ride_type & 0x1F));
RCT2_ADDRESS(0x01357444, uint32)[base_ride_type] = RCT2_ADDRESS(0x0097C468, uint32)[base_ride_type]; RCT2_ADDRESS(0x01357444, uint32)[base_ride_type] = RCT2_ADDRESS(0x0097C468, uint32)[base_ride_type];
RCT2_ADDRESS(0x01357644, uint32)[base_ride_type] = RCT2_ADDRESS(0x0097C5D4, uint32)[base_ride_type]; RCT2_ADDRESS(0x01357644, uint32)[base_ride_type] = RCT2_ADDRESS(0x0097C5D4, uint32)[base_ride_type];
@ -189,7 +189,7 @@ void research_finish_item(sint32 entryIndex)
RCT2_ADDRESS(0x001357424, uint32)[rideEntryIndex >> 5] |= 1u << (rideEntryIndex & 0x1F); RCT2_ADDRESS(0x001357424, uint32)[rideEntryIndex >> 5] |= 1u << (rideEntryIndex & 0x1F);
if (!(rideEntry->flags & RIDE_ENTRY_FLAG_SEPARATE_RIDE)) { if (!(rideEntry->flags & RIDE_ENTRY_FLAG_SEPARATE_RIDE)) {
for (i = 0; i < 128; i++) { for (i = 0; i < 128; i++) {
rideEntry2 = GET_RIDE_ENTRY(i); rideEntry2 = get_ride_entry(i);
if (rideEntry2 == (rct_ride_type*)-1) if (rideEntry2 == (rct_ride_type*)-1)
continue; continue;
if ((rideEntry2->flags & RIDE_ENTRY_FLAG_SEPARATE_RIDE)) if ((rideEntry2->flags & RIDE_ENTRY_FLAG_SEPARATE_RIDE))
@ -363,7 +363,7 @@ void research_remove_non_separate_vehicle_types()
researchItem->entryIndex != RESEARCHED_ITEMS_END && researchItem->entryIndex != RESEARCHED_ITEMS_END &&
researchItem->entryIndex >= 0x10000 researchItem->entryIndex >= 0x10000
) { ) {
rct_ride_type *rideEntry = GET_RIDE_ENTRY(researchItem->entryIndex & 0xFF); rct_ride_type *rideEntry = get_ride_entry(researchItem->entryIndex & 0xFF);
if (!(rideEntry->flags & (RIDE_ENTRY_FLAG_SEPARATE_RIDE | RIDE_ENTRY_FLAG_SEPARATE_RIDE_NAME))) { if (!(rideEntry->flags & (RIDE_ENTRY_FLAG_SEPARATE_RIDE | RIDE_ENTRY_FLAG_SEPARATE_RIDE_NAME))) {
// Check if ride type already exists further up for a vehicle type that isn't displayed as a ride // Check if ride type already exists further up for a vehicle type that isn't displayed as a ride
researchItem2 = researchItem - 1; researchItem2 = researchItem - 1;
@ -372,7 +372,7 @@ void research_remove_non_separate_vehicle_types()
researchItem2->entryIndex != RESEARCHED_ITEMS_SEPARATOR && researchItem2->entryIndex != RESEARCHED_ITEMS_SEPARATOR &&
researchItem2->entryIndex >= 0x10000 researchItem2->entryIndex >= 0x10000
) { ) {
rideEntry = GET_RIDE_ENTRY(researchItem2->entryIndex & 0xFF); rideEntry = get_ride_entry(researchItem2->entryIndex & 0xFF);
if (!(rideEntry->flags & (RIDE_ENTRY_FLAG_SEPARATE_RIDE | RIDE_ENTRY_FLAG_SEPARATE_RIDE_NAME))) { if (!(rideEntry->flags & (RIDE_ENTRY_FLAG_SEPARATE_RIDE | RIDE_ENTRY_FLAG_SEPARATE_RIDE_NAME))) {
if (((researchItem->entryIndex >> 8) & 0xFF) == ((researchItem2->entryIndex >> 8) & 0xFF)) { if (((researchItem->entryIndex >> 8) & 0xFF) == ((researchItem2->entryIndex >> 8) & 0xFF)) {
@ -484,7 +484,7 @@ void research_populate_list_random()
// Rides // Rides
for (int i = 0; i < 128; i++) { for (int i = 0; i < 128; i++) {
rideEntry = GET_RIDE_ENTRY(i); rideEntry = get_ride_entry(i);
if (rideEntry == (rct_ride_type*)-1) if (rideEntry == (rct_ride_type*)-1)
continue; continue;
@ -515,7 +515,7 @@ void research_populate_list_researched()
// Rides // Rides
for (int i = 0; i < 128; i++) { for (int i = 0; i < 128; i++) {
rideEntry = GET_RIDE_ENTRY(i); rideEntry = get_ride_entry(i);
if (rideEntry == (rct_ride_type*)-1) if (rideEntry == (rct_ride_type*)-1)
continue; continue;

198
src/peep/peep.c
View File

@ -222,7 +222,7 @@ static uint8 peep_assess_surroundings(sint16 center_x, sint16 center_y, sint16 c
num_scenery++; num_scenery++;
break; break;
case MAP_ELEMENT_TYPE_TRACK: case MAP_ELEMENT_TYPE_TRACK:
ride = GET_RIDE(mapElement->properties.track.ride_index); ride = get_ride(mapElement->properties.track.ride_index);
if (ride->type == RIDE_TYPE_MERRY_GO_ROUND && if (ride->type == RIDE_TYPE_MERRY_GO_ROUND &&
ride->music_tune_id != 0xFF){ ride->music_tune_id != 0xFF){
nearby_music |= 1; nearby_music |= 1;
@ -474,7 +474,7 @@ static void sub_68F41A(rct_peep *peep, int index)
peep->happiness_growth_rate = min(0, peep->happiness_growth_rate - 5); peep->happiness_growth_rate = min(0, peep->happiness_growth_rate - 5);
if (peep->time_on_ride > 22){ if (peep->time_on_ride > 22){
rct_ride* ride = GET_RIDE(peep->current_ride); rct_ride* ride = get_ride(peep->current_ride);
uint8 thought_type = ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_IN_RIDE) ? uint8 thought_type = ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_IN_RIDE) ?
PEEP_THOUGHT_TYPE_GET_OUT : PEEP_THOUGHT_TYPE_GET_OUT :
@ -1075,7 +1075,7 @@ void peep_decrement_num_riders(rct_peep* peep){
if (peep->state == PEEP_STATE_ON_RIDE if (peep->state == PEEP_STATE_ON_RIDE
|| peep->state == PEEP_STATE_ENTERING_RIDE){ || peep->state == PEEP_STATE_ENTERING_RIDE){
rct_ride* ride = GET_RIDE(peep->current_ride); rct_ride* ride = get_ride(peep->current_ride);
ride->num_riders--; ride->num_riders--;
ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAIN | RIDE_INVALIDATE_RIDE_LIST; ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAIN | RIDE_INVALIDATE_RIDE_LIST;
} }
@ -1268,7 +1268,7 @@ void peep_window_state_update(rct_peep* peep){
widget_invalidate_by_number(WC_PEEP, peep->sprite_index, 12); widget_invalidate_by_number(WC_PEEP, peep->sprite_index, 12);
if (peep->state == PEEP_STATE_ON_RIDE || peep->state == PEEP_STATE_ENTERING_RIDE){ if (peep->state == PEEP_STATE_ON_RIDE || peep->state == PEEP_STATE_ENTERING_RIDE){
rct_ride* ride = GET_RIDE(peep->current_ride); rct_ride* ride = get_ride(peep->current_ride);
ride->num_riders++; ride->num_riders++;
ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAIN | RIDE_INVALIDATE_RIDE_LIST; ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_MAIN | RIDE_INVALIDATE_RIDE_LIST;
} }
@ -1569,7 +1569,7 @@ void peep_update_sitting(rct_peep* peep){
*/ */
void remove_peep_from_queue(rct_peep* peep) void remove_peep_from_queue(rct_peep* peep)
{ {
rct_ride* ride = GET_RIDE(peep->current_ride); rct_ride* ride = get_ride(peep->current_ride);
uint8 cur_station = peep->current_ride_station; uint8 cur_station = peep->current_ride_station;
ride->queue_length[cur_station]--; ride->queue_length[cur_station]--;
@ -1657,7 +1657,7 @@ static void peep_go_to_ride_entrance(rct_peep* peep, rct_ride* ride){
sint16 y_shift = RCT2_ADDRESS(0x00981D6E, sint16)[direction * 2]; sint16 y_shift = RCT2_ADDRESS(0x00981D6E, sint16)[direction * 2];
uint8 shift_multiplier = 21; uint8 shift_multiplier = 21;
rct_ride_type* ride_type = GET_RIDE_ENTRY(ride->subtype); rct_ride_type* ride_type = get_ride_entry(ride->subtype);
if (ride_type->vehicles[ride_type->default_vehicle].flags_a & VEHICLE_ENTRY_FLAG_A_MINI_GOLF || if (ride_type->vehicles[ride_type->default_vehicle].flags_a & VEHICLE_ENTRY_FLAG_A_MINI_GOLF ||
ride_type->vehicles[ride_type->default_vehicle].flags_b & (VEHICLE_ENTRY_FLAG_B_12 | VEHICLE_ENTRY_FLAG_B_14)){ ride_type->vehicles[ride_type->default_vehicle].flags_b & (VEHICLE_ENTRY_FLAG_B_12 | VEHICLE_ENTRY_FLAG_B_14)){
shift_multiplier = 32; shift_multiplier = 32;
@ -1689,7 +1689,7 @@ static void peep_go_to_ride_entrance(rct_peep* peep, rct_ride* ride){
* rct2: 0x00691A3B * rct2: 0x00691A3B
*/ */
static void peep_update_ride_sub_state_0(rct_peep* peep){ static void peep_update_ride_sub_state_0(rct_peep* peep){
rct_ride* ride = GET_RIDE(peep->current_ride); rct_ride* ride = get_ride(peep->current_ride);
if (peep->destination_tolerence != 0){ if (peep->destination_tolerence != 0){
invalidate_sprite_2((rct_sprite*)peep); invalidate_sprite_2((rct_sprite*)peep);
@ -1856,8 +1856,8 @@ static void peep_update_ride_sub_state_0(rct_peep* peep){
void peep_update_ride_sub_state_1(rct_peep* peep){ void peep_update_ride_sub_state_1(rct_peep* peep){
sint16 x, y, xy_distance; sint16 x, y, xy_distance;
rct_ride* ride = GET_RIDE(peep->current_ride); rct_ride* ride = get_ride(peep->current_ride);
rct_ride_type* ride_entry = gRideTypeList[ride->subtype]; rct_ride_type* ride_entry = get_ride_entry(ride->subtype);
if (peep_update_action(&x, &y, &xy_distance, peep)) if (peep_update_action(&x, &y, &xy_distance, peep))
{ {
@ -1962,7 +1962,7 @@ void peep_update_ride_sub_state_1(rct_peep* peep){
vehicle = GET_VEHICLE(vehicle->next_vehicle_on_train); vehicle = GET_VEHICLE(vehicle->next_vehicle_on_train);
} }
ride_entry = GET_RIDE_ENTRY(vehicle->ride_subtype); ride_entry = get_ride_entry(vehicle->ride_subtype);
rct_ride_type_vehicle* vehicle_type = &ride_entry->vehicles[vehicle->vehicle_type]; rct_ride_type_vehicle* vehicle_type = &ride_entry->vehicles[vehicle->vehicle_type];
if (vehicle_type->flags_b & VEHICLE_ENTRY_FLAG_B_10){ if (vehicle_type->flags_b & VEHICLE_ENTRY_FLAG_B_10){
@ -1983,7 +1983,7 @@ void peep_update_ride_sub_state_1(rct_peep* peep){
uint8 direction_track = (map_element == NULL ? 0 : map_element->type & MAP_ELEMENT_DIRECTION_MASK); uint8 direction_track = (map_element == NULL ? 0 : map_element->type & MAP_ELEMENT_DIRECTION_MASK);
vehicle = GET_VEHICLE(ride->vehicles[peep->current_train]); vehicle = GET_VEHICLE(ride->vehicles[peep->current_train]);
ride_entry = GET_RIDE_ENTRY(vehicle->ride_subtype); ride_entry = get_ride_entry(vehicle->ride_subtype);
vehicle_type = &ride_entry->vehicles[vehicle->vehicle_type]; vehicle_type = &ride_entry->vehicles[vehicle->vehicle_type];
uint8 cl = peep->current_seat; uint8 cl = peep->current_seat;
@ -2073,7 +2073,7 @@ static void peep_go_to_ride_exit(rct_peep* peep, rct_ride* ride, sint16 x, sint1
sint16 shift_multiplier = 20; sint16 shift_multiplier = 20;
rct_ride_type* ride_type = GET_RIDE_ENTRY(ride->subtype); rct_ride_type* ride_type = get_ride_entry(ride->subtype);
rct_ride_type_vehicle* vehicle_entry = &ride_type->vehicles[ride_type->default_vehicle]; rct_ride_type_vehicle* vehicle_entry = &ride_type->vehicles[ride_type->default_vehicle];
if (vehicle_entry->flags_a & VEHICLE_ENTRY_FLAG_A_MINI_GOLF || if (vehicle_entry->flags_a & VEHICLE_ENTRY_FLAG_A_MINI_GOLF ||
vehicle_entry->flags_b & (VEHICLE_ENTRY_FLAG_B_12 | VEHICLE_ENTRY_FLAG_B_14)){ vehicle_entry->flags_b & (VEHICLE_ENTRY_FLAG_B_12 | VEHICLE_ENTRY_FLAG_B_14)){
@ -2205,7 +2205,7 @@ static void peep_update_ride_sub_state_2_rejoin_queue(rct_peep* peep, rct_ride*
* separate functions. * separate functions.
*/ */
static void peep_update_ride_sub_state_2(rct_peep* peep){ static void peep_update_ride_sub_state_2(rct_peep* peep){
rct_ride* ride = GET_RIDE(peep->current_ride); rct_ride* ride = get_ride(peep->current_ride);
if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_13)){ if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_13)){
if (ride->status != RIDE_STATUS_OPEN || if (ride->status != RIDE_STATUS_OPEN ||
@ -2225,7 +2225,7 @@ static void peep_update_ride_sub_state_2(rct_peep* peep){
vehicle = GET_VEHICLE(vehicle->next_vehicle_on_train); vehicle = GET_VEHICLE(vehicle->next_vehicle_on_train);
} }
rct_ride_type* ride_entry = GET_RIDE_ENTRY(vehicle->ride_subtype); rct_ride_type* ride_entry = get_ride_entry(vehicle->ride_subtype);
if (ride_entry->vehicles[0].flags_a & VEHICLE_ENTRY_FLAG_A_MINI_GOLF){ if (ride_entry->vehicles[0].flags_a & VEHICLE_ENTRY_FLAG_A_MINI_GOLF){
vehicle->var_D5 &= ~(1 << 5); vehicle->var_D5 &= ~(1 << 5);
@ -2290,7 +2290,7 @@ static void peep_update_ride_sub_state_2(rct_peep* peep){
} }
static void peep_update_ride_sub_state_5(rct_peep* peep){ static void peep_update_ride_sub_state_5(rct_peep* peep){
rct_ride* ride = GET_RIDE(peep->current_ride); rct_ride* ride = get_ride(peep->current_ride);
rct_vehicle* vehicle = GET_VEHICLE(ride->vehicles[peep->current_train]); rct_vehicle* vehicle = GET_VEHICLE(ride->vehicles[peep->current_train]);
for (int i = peep->current_car; i != 0; --i){ for (int i = peep->current_car; i != 0; --i){
@ -2347,7 +2347,7 @@ static void peep_update_ride_sub_state_5(rct_peep* peep){
* rct2: 0x00693028 * rct2: 0x00693028
*/ */
void peep_update_ride_sub_state_7(rct_peep* peep){ void peep_update_ride_sub_state_7(rct_peep* peep){
rct_ride* ride = GET_RIDE(peep->current_ride); rct_ride* ride = get_ride(peep->current_ride);
rct_vehicle* vehicle = GET_VEHICLE(ride->vehicles[peep->current_train]); rct_vehicle* vehicle = GET_VEHICLE(ride->vehicles[peep->current_train]);
uint8 ride_station = vehicle->current_station; uint8 ride_station = vehicle->current_station;
@ -2375,7 +2375,7 @@ void peep_update_ride_sub_state_7(rct_peep* peep){
peep->current_ride_station = ride_station; peep->current_ride_station = ride_station;
rct_ride_type* ride_entry = GET_RIDE_ENTRY(vehicle->ride_subtype); rct_ride_type* ride_entry = get_ride_entry(vehicle->ride_subtype);
rct_ride_type_vehicle* vehicle_entry = &ride_entry->vehicles[vehicle->vehicle_type]; rct_ride_type_vehicle* vehicle_entry = &ride_entry->vehicles[vehicle->vehicle_type];
if (!(vehicle_entry->flags_b & VEHICLE_ENTRY_FLAG_B_10)){ if (!(vehicle_entry->flags_b & VEHICLE_ENTRY_FLAG_B_10)){
@ -2409,7 +2409,7 @@ void peep_update_ride_sub_state_7(rct_peep* peep){
break; break;
} }
ride_entry = GET_RIDE_ENTRY(ride->subtype); ride_entry = get_ride_entry(ride->subtype);
vehicle_entry = &ride_entry->vehicles[ride_entry->default_vehicle]; vehicle_entry = &ride_entry->vehicles[ride_entry->default_vehicle];
uint8 shift_multiplier = 12; uint8 shift_multiplier = 12;
@ -2481,7 +2481,7 @@ void peep_update_ride_sub_state_7(rct_peep* peep){
vehicle = GET_VEHICLE(ride->vehicles[peep->current_train]); vehicle = GET_VEHICLE(ride->vehicles[peep->current_train]);
ride_entry = GET_RIDE_ENTRY(vehicle->ride_subtype); ride_entry = get_ride_entry(vehicle->ride_subtype);
rct_ride_type_vehicle* vehicle_type = &ride_entry->vehicles[vehicle->vehicle_type]; rct_ride_type_vehicle* vehicle_type = &ride_entry->vehicles[vehicle->vehicle_type];
uint8 cl = peep->current_seat; uint8 cl = peep->current_seat;
@ -2537,7 +2537,7 @@ void peep_update_ride_sub_state_7(rct_peep* peep){
* rct2: 0x0069376A * rct2: 0x0069376A
*/ */
static void peep_update_ride_prepare_for_state_9(rct_peep* peep){ static void peep_update_ride_prepare_for_state_9(rct_peep* peep){
rct_ride* ride = GET_RIDE(peep->current_ride); rct_ride* ride = get_ride(peep->current_ride);
sint16 x = ride->exits[peep->current_ride_station] & 0xFF; sint16 x = ride->exits[peep->current_ride_station] & 0xFF;
sint16 y = ride->exits[peep->current_ride_station] >> 8; sint16 y = ride->exits[peep->current_ride_station] >> 8;
@ -2557,7 +2557,7 @@ static void peep_update_ride_prepare_for_state_9(rct_peep* peep){
sint16 shift_multiplier = 20; sint16 shift_multiplier = 20;
rct_ride_type* ride_type = GET_RIDE_ENTRY(ride->subtype); rct_ride_type* ride_type = get_ride_entry(ride->subtype);
rct_ride_type_vehicle* vehicle_entry = &ride_type->vehicles[ride_type->default_vehicle]; rct_ride_type_vehicle* vehicle_entry = &ride_type->vehicles[ride_type->default_vehicle];
if (vehicle_entry->flags_b & (VEHICLE_ENTRY_FLAG_B_12 | VEHICLE_ENTRY_FLAG_B_14)){ if (vehicle_entry->flags_b & (VEHICLE_ENTRY_FLAG_B_12 | VEHICLE_ENTRY_FLAG_B_14)){
shift_multiplier = 32; shift_multiplier = 32;
@ -2597,7 +2597,7 @@ static void peep_update_ride_sub_state_8(rct_peep* peep){
*/ */
static void peep_update_ride_sub_state_9(rct_peep* peep){ static void peep_update_ride_sub_state_9(rct_peep* peep){
sint16 x, y, xy_distance; sint16 x, y, xy_distance;
rct_ride* ride = GET_RIDE(peep->current_ride); rct_ride* ride = get_ride(peep->current_ride);
if (peep_update_action(&x, &y, &xy_distance, peep)){ if (peep_update_action(&x, &y, &xy_distance, peep)){
invalidate_sprite_2((rct_sprite*)peep); invalidate_sprite_2((rct_sprite*)peep);
@ -2631,7 +2631,7 @@ static void peep_update_ride_sub_state_9(rct_peep* peep){
*/ */
static void peep_update_ride_sub_state_12(rct_peep* peep){ static void peep_update_ride_sub_state_12(rct_peep* peep){
sint16 x, y, xy_distance; sint16 x, y, xy_distance;
rct_ride* ride = GET_RIDE(peep->current_ride); rct_ride* ride = get_ride(peep->current_ride);
if (peep_update_action(&x, &y, &xy_distance, peep)){ if (peep_update_action(&x, &y, &xy_distance, peep)){
sint16 z; sint16 z;
@ -2679,7 +2679,7 @@ static void peep_update_ride_sub_state_12(rct_peep* peep){
y = vehicle->y; y = vehicle->y;
} }
rct_ride_type* ride_entry = GET_RIDE_ENTRY(vehicle->ride_subtype); rct_ride_type* ride_entry = get_ride_entry(vehicle->ride_subtype);
rct_ride_type_vehicle* vehicle_type = &ride_entry->vehicles[vehicle->vehicle_type]; rct_ride_type_vehicle* vehicle_type = &ride_entry->vehicles[vehicle->vehicle_type];
x += vehicle_type->peep_loading_positions[peep->var_37 * 2 + 1]; x += vehicle_type->peep_loading_positions[peep->var_37 * 2 + 1];
@ -2695,7 +2695,7 @@ static void peep_update_ride_sub_state_12(rct_peep* peep){
*/ */
static void peep_update_ride_sub_state_13(rct_peep* peep){ static void peep_update_ride_sub_state_13(rct_peep* peep){
sint16 x, y, xy_distance; sint16 x, y, xy_distance;
rct_ride* ride = GET_RIDE(peep->current_ride); rct_ride* ride = get_ride(peep->current_ride);
if (peep_update_action(&x, &y, &xy_distance, peep)){ if (peep_update_action(&x, &y, &xy_distance, peep)){
sint16 z; sint16 z;
@ -2741,7 +2741,7 @@ static void peep_update_ride_sub_state_13(rct_peep* peep){
y = vehicle->y; y = vehicle->y;
} }
rct_ride_type* ride_entry = GET_RIDE_ENTRY(vehicle->ride_subtype); rct_ride_type* ride_entry = get_ride_entry(vehicle->ride_subtype);
rct_ride_type_vehicle* vehicle_type = &ride_entry->vehicles[vehicle->vehicle_type]; rct_ride_type_vehicle* vehicle_type = &ride_entry->vehicles[vehicle->vehicle_type];
x += vehicle_type->peep_loading_positions[peep->var_37 * 2 + 1]; x += vehicle_type->peep_loading_positions[peep->var_37 * 2 + 1];
@ -2773,7 +2773,7 @@ static void peep_update_ride_sub_state_13(rct_peep* peep){
sint16 shift_multiplier = 20; sint16 shift_multiplier = 20;
rct_ride_type* ride_type = GET_RIDE_ENTRY(ride->subtype); rct_ride_type* ride_type = get_ride_entry(ride->subtype);
rct_ride_type_vehicle* vehicle_entry = &ride_type->vehicles[ride_type->default_vehicle]; rct_ride_type_vehicle* vehicle_entry = &ride_type->vehicles[ride_type->default_vehicle];
if (vehicle_entry->flags_b & (VEHICLE_ENTRY_FLAG_B_12 | VEHICLE_ENTRY_FLAG_B_14)){ if (vehicle_entry->flags_b & (VEHICLE_ENTRY_FLAG_B_12 | VEHICLE_ENTRY_FLAG_B_14)){
shift_multiplier = 32; shift_multiplier = 32;
@ -2795,7 +2795,7 @@ static void peep_update_ride_sub_state_13(rct_peep* peep){
*/ */
static void peep_update_ride_sub_state_14(rct_peep* peep){ static void peep_update_ride_sub_state_14(rct_peep* peep){
sint16 x, y, xy_distance; sint16 x, y, xy_distance;
rct_ride* ride = GET_RIDE(peep->current_ride); rct_ride* ride = get_ride(peep->current_ride);
if (peep_update_action(&x, &y, &xy_distance, peep)){ if (peep_update_action(&x, &y, &xy_distance, peep)){
invalidate_sprite_2((rct_sprite*)peep); invalidate_sprite_2((rct_sprite*)peep);
@ -2870,7 +2870,7 @@ static void peep_update_ride_sub_state_14(rct_peep* peep){
* rct2: 0x00692D83 * rct2: 0x00692D83
*/ */
static void peep_update_ride_sub_state_15(rct_peep* peep){ static void peep_update_ride_sub_state_15(rct_peep* peep){
rct_ride* ride = GET_RIDE(peep->current_ride); rct_ride* ride = get_ride(peep->current_ride);
if (ride->type != RIDE_TYPE_SPIRAL_SLIDE) if (ride->type != RIDE_TYPE_SPIRAL_SLIDE)
return; return;
@ -2966,7 +2966,7 @@ static void peep_update_ride_sub_state_16(rct_peep* peep){
return; return;
} }
rct_ride* ride = GET_RIDE(peep->current_ride); rct_ride* ride = get_ride(peep->current_ride);
if ((peep->var_37 & 0x3) != 0){ if ((peep->var_37 & 0x3) != 0){
if ((peep->var_37 & 0x3) == 3){ if ((peep->var_37 & 0x3) == 3){
@ -3035,7 +3035,7 @@ static void peep_update_ride_sub_state_17(rct_peep* peep){
return; return;
} }
rct_ride* ride = GET_RIDE(peep->current_ride); rct_ride* ride = get_ride(peep->current_ride);
if (peep->var_37 == 16){ if (peep->var_37 == 16){
peep_update_ride_prepare_for_state_9(peep); peep_update_ride_prepare_for_state_9(peep);
return; return;
@ -3168,7 +3168,7 @@ static void peep_update_ride_sub_state_17(rct_peep* peep){
*/ */
static void peep_update_ride_sub_state_18(rct_peep* peep){ static void peep_update_ride_sub_state_18(rct_peep* peep){
sint16 x, y, xy_distance; sint16 x, y, xy_distance;
rct_ride* ride = GET_RIDE(peep->current_ride); rct_ride* ride = get_ride(peep->current_ride);
if (peep_update_action(&x, &y, &xy_distance, peep)){ if (peep_update_action(&x, &y, &xy_distance, peep)){
invalidate_sprite_2((rct_sprite*)peep); invalidate_sprite_2((rct_sprite*)peep);
@ -3240,7 +3240,7 @@ static void peep_update_ride_sub_state_19(rct_peep* peep){
*/ */
static void peep_update_ride_sub_state_20(rct_peep* peep){ static void peep_update_ride_sub_state_20(rct_peep* peep){
sint16 x, y; sint16 x, y;
rct_ride* ride = GET_RIDE(peep->current_ride); rct_ride* ride = get_ride(peep->current_ride);
if (ride->type == RIDE_TYPE_FIRST_AID){ if (ride->type == RIDE_TYPE_FIRST_AID){
if (peep->nausea <= 35){ if (peep->nausea <= 35){
@ -3309,7 +3309,7 @@ static void peep_update_ride_sub_state_21(rct_peep* peep){
peep->state = PEEP_STATE_WALKING; peep->state = PEEP_STATE_WALKING;
peep_window_state_update(peep); peep_window_state_update(peep);
rct_ride* ride = GET_RIDE(peep->current_ride); rct_ride* ride = get_ride(peep->current_ride);
ride->total_customers++; ride->total_customers++;
ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_CUSTOMER; ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_CUSTOMER;
@ -3410,7 +3410,7 @@ static void peep_update_ride(rct_peep* peep){
* Also used by inspecting. * Also used by inspecting.
*/ */
static void peep_update_fixing(int steps, rct_peep* peep){ static void peep_update_fixing(int steps, rct_peep* peep){
rct_ride* ride = GET_RIDE(peep->current_ride); rct_ride* ride = get_ride(peep->current_ride);
if (ride->type == RIDE_TYPE_NULL) if (ride->type == RIDE_TYPE_NULL)
{ {
@ -3432,7 +3432,7 @@ static void peep_update_queuing(rct_peep* peep){
remove_peep_from_queue(peep); remove_peep_from_queue(peep);
return; return;
} }
rct_ride* ride = GET_RIDE(peep->current_ride); rct_ride* ride = get_ride(peep->current_ride);
if (ride->status == RIDE_STATUS_CLOSED || ride->status == RIDE_STATUS_TESTING){ if (ride->status == RIDE_STATUS_CLOSED || ride->status == RIDE_STATUS_TESTING){
remove_peep_from_queue(peep); remove_peep_from_queue(peep);
peep_decrement_num_riders(peep); peep_decrement_num_riders(peep);
@ -4142,7 +4142,7 @@ static void peep_update_buying(rct_peep* peep)
{ {
if (!checkForPath(peep))return; if (!checkForPath(peep))return;
rct_ride* ride = GET_RIDE(peep->current_ride); rct_ride* ride = get_ride(peep->current_ride);
if (ride->type == RIDE_TYPE_NULL || ride->status != RIDE_STATUS_OPEN){ if (ride->type == RIDE_TYPE_NULL || ride->status != RIDE_STATUS_OPEN){
peep_decrement_num_riders(peep); peep_decrement_num_riders(peep);
peep->state = PEEP_STATE_FALLING; peep->state = PEEP_STATE_FALLING;
@ -4194,7 +4194,7 @@ static void peep_update_buying(rct_peep* peep)
} }
} }
else{ else{
rct_ride_type* ride_type = gRideTypeList[ride->subtype]; rct_ride_type* ride_type = get_ride_entry(ride->subtype);
if (ride_type->shop_item_secondary != 0xFF){ if (ride_type->shop_item_secondary != 0xFF){
money16 price = ride->price_secondary; money16 price = ride->price_secondary;
@ -4363,7 +4363,7 @@ static void peep_update_using_bin(rct_peep* peep){
* rct2: 0x006C16D7 * rct2: 0x006C16D7
*/ */
static void peep_update_heading_to_inspect(rct_peep* peep){ static void peep_update_heading_to_inspect(rct_peep* peep){
rct_ride* ride = GET_RIDE(peep->current_ride); rct_ride* ride = get_ride(peep->current_ride);
if (ride->type == RIDE_TYPE_NULL){ if (ride->type == RIDE_TYPE_NULL){
peep_decrement_num_riders(peep); peep_decrement_num_riders(peep);
@ -4472,7 +4472,7 @@ static void peep_update_heading_to_inspect(rct_peep* peep){
* rct2: 0x006C0CB8 * rct2: 0x006C0CB8
*/ */
static void peep_update_answering(rct_peep* peep){ static void peep_update_answering(rct_peep* peep){
rct_ride* ride = GET_RIDE(peep->current_ride); rct_ride* ride = get_ride(peep->current_ride);
if (ride->type == RIDE_TYPE_NULL || if (ride->type == RIDE_TYPE_NULL ||
ride->mechanic_status != RIDE_MECHANIC_STATUS_HEADING){ ride->mechanic_status != RIDE_MECHANIC_STATUS_HEADING){
@ -5225,7 +5225,7 @@ void peep_problem_warnings_update()
hunger_counter++; hunger_counter++;
break; break;
} }
ride = &g_ride_list[peep->guest_heading_to_ride_id]; ride = get_ride(peep->guest_heading_to_ride_id);
if (!ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_FLAT_RIDE)) if (!ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_FLAT_RIDE))
hunger_counter++; hunger_counter++;
break; break;
@ -5235,7 +5235,7 @@ void peep_problem_warnings_update()
thirst_counter++; thirst_counter++;
break; break;
} }
ride = &g_ride_list[peep->guest_heading_to_ride_id]; ride = get_ride(peep->guest_heading_to_ride_id);
if (!ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_SELLS_DRINKS)) if (!ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_SELLS_DRINKS))
thirst_counter++; thirst_counter++;
break; break;
@ -5245,7 +5245,7 @@ void peep_problem_warnings_update()
bathroom_counter++; bathroom_counter++;
break; break;
} }
ride = &g_ride_list[peep->guest_heading_to_ride_id]; ride = get_ride(peep->guest_heading_to_ride_id);
if (!ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_IS_BATHROOM)) if (!ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_IS_BATHROOM))
bathroom_counter++; bathroom_counter++;
break; break;
@ -5630,7 +5630,7 @@ rct_peep *peep_generate(int x, int y, int z)
* argument_2 (edx) * argument_2 (edx)
*/ */
void get_arguments_from_action(rct_peep* peep, uint32 *argument_1, uint32* argument_2){ void get_arguments_from_action(rct_peep* peep, uint32 *argument_1, uint32* argument_2){
rct_ride ride; rct_ride *ride;
switch (peep->state){ switch (peep->state){
case PEEP_STATE_FALLING: case PEEP_STATE_FALLING:
@ -5645,23 +5645,23 @@ void get_arguments_from_action(rct_peep* peep, uint32 *argument_1, uint32* argum
case PEEP_STATE_LEAVING_RIDE: case PEEP_STATE_LEAVING_RIDE:
case PEEP_STATE_ENTERING_RIDE: case PEEP_STATE_ENTERING_RIDE:
*argument_1 = STR_ON_RIDE; *argument_1 = STR_ON_RIDE;
ride = g_ride_list[peep->current_ride]; ride = get_ride(peep->current_ride);
if (ride_type_has_flag(ride.type, RIDE_TYPE_FLAG_IN_RIDE)) if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_IN_RIDE))
*argument_1 = STR_IN_RIDE; *argument_1 = STR_IN_RIDE;
*argument_1 |= (ride.name << 16); *argument_1 |= (ride->name << 16);
*argument_2 = ride.name_arguments; *argument_2 = ride->name_arguments;
break; break;
case PEEP_STATE_BUYING: case PEEP_STATE_BUYING:
ride = g_ride_list[peep->current_ride]; ride = get_ride(peep->current_ride);
*argument_1 = STR_AT_RIDE | (ride.name << 16); *argument_1 = STR_AT_RIDE | (ride->name << 16);
*argument_2 = ride.name_arguments; *argument_2 = ride->name_arguments;
break; break;
case PEEP_STATE_WALKING: case PEEP_STATE_WALKING:
case PEEP_STATE_USING_BIN: case PEEP_STATE_USING_BIN:
if (peep->guest_heading_to_ride_id != 0xFF){ if (peep->guest_heading_to_ride_id != 0xFF){
ride = g_ride_list[peep->guest_heading_to_ride_id]; ride = get_ride(peep->guest_heading_to_ride_id);
*argument_1 = STR_HEADING_FOR | (ride.name << 16); *argument_1 = STR_HEADING_FOR | (ride->name << 16);
*argument_2 = ride.name_arguments; *argument_2 = ride->name_arguments;
} }
else{ else{
*argument_1 = peep->flags & PEEP_FLAGS_LEAVING_PARK ? STR_LEAVING_PARK : STR_WALKING; *argument_1 = peep->flags & PEEP_FLAGS_LEAVING_PARK ? STR_LEAVING_PARK : STR_WALKING;
@ -5670,9 +5670,9 @@ void get_arguments_from_action(rct_peep* peep, uint32 *argument_1, uint32* argum
break; break;
case PEEP_STATE_QUEUING_FRONT: case PEEP_STATE_QUEUING_FRONT:
case PEEP_STATE_QUEUING: case PEEP_STATE_QUEUING:
ride = g_ride_list[peep->current_ride]; ride = get_ride(peep->current_ride);
*argument_1 = STR_QUEUING_FOR | (ride.name << 16); *argument_1 = STR_QUEUING_FOR | (ride->name << 16);
*argument_2 = ride.name_arguments; *argument_2 = ride->name_arguments;
break; break;
case PEEP_STATE_SITTING: case PEEP_STATE_SITTING:
*argument_1 = STR_SITTING; *argument_1 = STR_SITTING;
@ -5680,13 +5680,13 @@ void get_arguments_from_action(rct_peep* peep, uint32 *argument_1, uint32* argum
break; break;
case PEEP_STATE_WATCHING: case PEEP_STATE_WATCHING:
if (peep->current_ride != 0xFF){ if (peep->current_ride != 0xFF){
ride = g_ride_list[peep->current_ride]; ride = get_ride(peep->current_ride);
*argument_1 = STR_WATCHING_RIDE | (ride.name << 16); *argument_1 = STR_WATCHING_RIDE | (ride->name << 16);
*argument_2 = ride.name_arguments; *argument_2 = ride->name_arguments;
if (peep->current_seat & 0x1) if (peep->current_seat & 0x1)
*argument_1 = STR_WATCHING_CONSTRUCTION_OF | (ride.name << 16); *argument_1 = STR_WATCHING_CONSTRUCTION_OF | (ride->name << 16);
else else
*argument_1 = STR_WATCHING_RIDE | (ride.name << 16); *argument_1 = STR_WATCHING_RIDE | (ride->name << 16);
} }
else{ else{
*argument_1 = peep->current_seat & 0x1 ? STR_WATCHING_NEW_RIDE_BEING_CONSTRUCTED : STR_LOOKING_AT_SCENERY; *argument_1 = peep->current_seat & 0x1 ? STR_WATCHING_NEW_RIDE_BEING_CONSTRUCTED : STR_LOOKING_AT_SCENERY;
@ -5729,25 +5729,25 @@ void get_arguments_from_action(rct_peep* peep, uint32 *argument_1, uint32* argum
*argument_2 = 0; *argument_2 = 0;
} }
else{ else{
ride = g_ride_list[peep->current_ride]; ride = get_ride(peep->current_ride);
*argument_1 = STR_RESPONDING_TO_RIDE_BREAKDOWN_CALL | (ride.name << 16); *argument_1 = STR_RESPONDING_TO_RIDE_BREAKDOWN_CALL | (ride->name << 16);
*argument_2 = ride.name_arguments; *argument_2 = ride->name_arguments;
} }
break; break;
case PEEP_STATE_FIXING: case PEEP_STATE_FIXING:
ride = g_ride_list[peep->current_ride]; ride = get_ride(peep->current_ride);
*argument_1 = STR_FIXING_RIDE | (ride.name << 16); *argument_1 = STR_FIXING_RIDE | (ride->name << 16);
*argument_2 = ride.name_arguments; *argument_2 = ride->name_arguments;
break; break;
case PEEP_STATE_HEADING_TO_INSPECTION: case PEEP_STATE_HEADING_TO_INSPECTION:
ride = g_ride_list[peep->current_ride]; ride = get_ride(peep->current_ride);
*argument_1 = STR_HEADING_TO_RIDE_FOR_INSPECTION | (ride.name << 16); *argument_1 = STR_HEADING_TO_RIDE_FOR_INSPECTION | (ride->name << 16);
*argument_2 = ride.name_arguments; *argument_2 = ride->name_arguments;
break; break;
case PEEP_STATE_INSPECTING: case PEEP_STATE_INSPECTING:
ride = g_ride_list[peep->current_ride]; ride = get_ride(peep->current_ride);
*argument_1 = STR_INSPECTING_RIDE | (ride.name << 16); *argument_1 = STR_INSPECTING_RIDE | (ride->name << 16);
*argument_2 = ride.name_arguments; *argument_2 = ride->name_arguments;
break; break;
} }
@ -5765,7 +5765,7 @@ void get_arguments_from_thought(rct_peep_thought thought, uint32* argument_1, ui
int esi = 0x009AC86C; int esi = 0x009AC86C;
if ((RCT2_ADDRESS(0x00981DB1, uint16)[thought.type] & 0xFF) & 1) { if ((RCT2_ADDRESS(0x00981DB1, uint16)[thought.type] & 0xFF) & 1) {
rct_ride* ride = &g_ride_list[thought.item]; rct_ride* ride = get_ride(thought.item);
esi = (int)(&(ride->name)); esi = (int)(&(ride->name));
} else if ((RCT2_ADDRESS(0x00981DB1, uint16)[thought.type] & 0xFF) & 2) { } else if ((RCT2_ADDRESS(0x00981DB1, uint16)[thought.type] & 0xFF) & 2) {
RCT2_GLOBAL(0x009AC86C, uint16) = ShopItemStringIds[thought.item].singular; RCT2_GLOBAL(0x009AC86C, uint16) = ShopItemStringIds[thought.item].singular;
@ -6302,7 +6302,7 @@ static int peep_interact_with_entrance(rct_peep* peep, sint16 x, sint16 y, rct_m
peep->action_sprite_image_offset = RCT2_GLOBAL(0x00F1AEF0, uint8); peep->action_sprite_image_offset = RCT2_GLOBAL(0x00F1AEF0, uint8);
peep->var_79 = rideIndex; peep->var_79 = rideIndex;
rct_ride* ride = GET_RIDE(rideIndex); rct_ride* ride = get_ride(rideIndex);
uint16 previous_last = ride->last_peep_in_queue[stationNum]; uint16 previous_last = ride->last_peep_in_queue[stationNum];
ride->last_peep_in_queue[stationNum] = peep->sprite_index; ride->last_peep_in_queue[stationNum] = peep->sprite_index;
peep->next_in_queue = previous_last; peep->next_in_queue = previous_last;
@ -6680,7 +6680,7 @@ static int peep_interact_with_path(rct_peep* peep, sint16 x, sint16 y, rct_map_e
} }
peep->var_79 = rideIndex; peep->var_79 = rideIndex;
rct_ride* ride = GET_RIDE(rideIndex); rct_ride* ride = get_ride(rideIndex);
uint16 old_last_peep = ride->last_peep_in_queue[stationNum]; uint16 old_last_peep = ride->last_peep_in_queue[stationNum];
ride->last_peep_in_queue[stationNum] = peep->sprite_index; ride->last_peep_in_queue[stationNum] = peep->sprite_index;
@ -6727,7 +6727,7 @@ static int peep_interact_with_path(rct_peep* peep, sint16 x, sint16 y, rct_map_e
*/ */
static int peep_interact_with_shop(rct_peep* peep, sint16 x, sint16 y, rct_map_element* map_element){ static int peep_interact_with_shop(rct_peep* peep, sint16 x, sint16 y, rct_map_element* map_element){
uint8 rideIndex = map_element->properties.track.ride_index; uint8 rideIndex = map_element->properties.track.ride_index;
rct_ride* ride = GET_RIDE(rideIndex); rct_ride* ride = get_ride(rideIndex);
if (!ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_IS_SHOP)) if (!ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_IS_SHOP))
return 0; return 0;
@ -7002,7 +7002,7 @@ static uint8 loc_6949B9(
case MAP_ELEMENT_TYPE_TRACK: case MAP_ELEMENT_TYPE_TRACK:
if (z != mapElement->base_height) continue; if (z != mapElement->base_height) continue;
int rideIndex = mapElement->properties.track.ride_index; int rideIndex = mapElement->properties.track.ride_index;
rct_ride *ride = GET_RIDE(rideIndex); rct_ride *ride = get_ride(rideIndex);
if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_IS_SHOP)) { if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_IS_SHOP)) {
*outRideIndex = rideIndex; *outRideIndex = rideIndex;
return PATH_SEARCH_RIDE_ENTRANCE; return PATH_SEARCH_RIDE_ENTRANCE;
@ -7677,7 +7677,7 @@ static int guest_path_finding(rct_peep* peep)
return guest_path_find_aimless(peep, edges); return guest_path_find_aimless(peep, edges);
uint8 rideIndex = peep->guest_heading_to_ride_id; uint8 rideIndex = peep->guest_heading_to_ride_id;
rct_ride* ride = GET_RIDE(rideIndex); rct_ride* ride = get_ride(rideIndex);
if (ride->status != RIDE_STATUS_OPEN) if (ride->status != RIDE_STATUS_OPEN)
return guest_path_find_aimless(peep, edges); return guest_path_find_aimless(peep, edges);
@ -7895,7 +7895,7 @@ static void peep_spend_money(rct_peep *peep, money16 *peep_expend_type, money32
static void peep_set_has_ridden(rct_peep *peep, int rideIndex) static void peep_set_has_ridden(rct_peep *peep, int rideIndex)
{ {
peep->rides_been_on[rideIndex / 8] |= 1 << (rideIndex % 8); peep->rides_been_on[rideIndex / 8] |= 1 << (rideIndex % 8);
rct_ride *ride = GET_RIDE(rideIndex); rct_ride *ride = get_ride(rideIndex);
peep_set_has_ridden_ride_type(peep, ride->type); peep_set_has_ridden_ride_type(peep, ride->type);
} }
@ -7921,7 +7921,7 @@ static bool peep_has_ridden_ride_type(rct_peep *peep, int rideType)
*/ */
static void peep_on_enter_ride(rct_peep *peep, int rideIndex) static void peep_on_enter_ride(rct_peep *peep, int rideIndex)
{ {
rct_ride *ride = GET_RIDE(rideIndex); rct_ride *ride = get_ride(rideIndex);
// Calculate how satisfying the ride is for the peep. Can range from -140 to +140. // Calculate how satisfying the ride is for the peep. Can range from -140 to +140.
sint8 satisfaction = peep_calculate_ride_satisfaction(peep, ride); sint8 satisfaction = peep_calculate_ride_satisfaction(peep, ride);
@ -8177,7 +8177,7 @@ static bool peep_really_liked_ride(rct_peep *peep, rct_ride *ride)
*/ */
static void peep_on_exit_ride(rct_peep *peep, int rideIndex) static void peep_on_exit_ride(rct_peep *peep, int rideIndex)
{ {
rct_ride *ride = GET_RIDE(rideIndex); rct_ride *ride = get_ride(rideIndex);
if (peep->flags & PEEP_FLAGS_RIDE_SHOULD_BE_MARKED_AS_FAVOURITE) { if (peep->flags & PEEP_FLAGS_RIDE_SHOULD_BE_MARKED_AS_FAVOURITE) {
peep->flags &= ~PEEP_FLAGS_RIDE_SHOULD_BE_MARKED_AS_FAVOURITE; peep->flags &= ~PEEP_FLAGS_RIDE_SHOULD_BE_MARKED_AS_FAVOURITE;
@ -8255,7 +8255,7 @@ static void peep_on_enter_or_exit_ride(rct_peep *peep, int rideIndex, int flags)
*/ */
static bool sub_69AF1E(rct_peep *peep, int rideIndex, int shopItem, money32 price) static bool sub_69AF1E(rct_peep *peep, int rideIndex, int shopItem, money32 price)
{ {
rct_ride* ride = GET_RIDE(rideIndex); rct_ride* ride = get_ride(rideIndex);
money32 value; money32 value;
bool has_voucher = false; bool has_voucher = false;
@ -8504,7 +8504,7 @@ static bool peep_should_use_cash_machine(rct_peep *peep, int rideIndex)
if (115 + (scenario_rand() % 128) > peep->happiness) return false; if (115 + (scenario_rand() % 128) > peep->happiness) return false;
if (peep->energy < 80) return false; if (peep->energy < 80) return false;
rct_ride *ride = GET_RIDE(rideIndex); rct_ride *ride = get_ride(rideIndex);
ride_update_satisfaction(ride, peep->happiness >> 6); ride_update_satisfaction(ride, peep->happiness >> 6);
ride->cur_num_customers++; ride->cur_num_customers++;
ride->total_customers++; ride->total_customers++;
@ -8733,7 +8733,7 @@ static void peep_reset_ride_heading(rct_peep *peep)
*/ */
static bool peep_should_go_on_ride(rct_peep *peep, int rideIndex, int entranceNum, int flags) static bool peep_should_go_on_ride(rct_peep *peep, int rideIndex, int entranceNum, int flags)
{ {
rct_ride *ride = GET_RIDE(rideIndex); rct_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) // 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; bool peepAtQueue = flags & PEEP_RIDE_DECISION_AT_QUEUE;
@ -8982,7 +8982,7 @@ static bool peep_should_go_on_ride(rct_peep *peep, int rideIndex, int entranceNu
static void peep_ride_is_too_intense(rct_peep *peep, int rideIndex, bool peepAtRide) static void peep_ride_is_too_intense(rct_peep *peep, int rideIndex, bool peepAtRide)
{ {
rct_ride *ride = GET_RIDE(rideIndex); rct_ride *ride = get_ride(rideIndex);
if (peepAtRide) { if (peepAtRide) {
peep_insert_new_thought(peep, PEEP_THOUGHT_TYPE_INTENSE, rideIndex); peep_insert_new_thought(peep, PEEP_THOUGHT_TYPE_INTENSE, rideIndex);
@ -9013,7 +9013,7 @@ static void peep_chose_not_to_go_on_ride(rct_peep *peep, int rideIndex, bool pee
*/ */
static void peep_tried_to_enter_full_queue(rct_peep *peep, int rideIndex) static void peep_tried_to_enter_full_queue(rct_peep *peep, int rideIndex)
{ {
rct_ride *ride = GET_RIDE(rideIndex); rct_ride *ride = get_ride(rideIndex);
ride->lifecycle_flags |= RIDE_LIFECYCLE_QUEUE_FULL; ride->lifecycle_flags |= RIDE_LIFECYCLE_QUEUE_FULL;
peep->previous_ride = rideIndex; peep->previous_ride = rideIndex;
@ -9022,7 +9022,7 @@ static void peep_tried_to_enter_full_queue(rct_peep *peep, int rideIndex)
static bool peep_should_go_to_shop(rct_peep *peep, int rideIndex, bool peepAtShop) static bool peep_should_go_to_shop(rct_peep *peep, int rideIndex, bool peepAtShop)
{ {
rct_ride *ride = GET_RIDE(rideIndex); rct_ride *ride = get_ride(rideIndex);
// Peeps won't go to the same shop twice in a row. // Peeps won't go to the same shop twice in a row.
if (rideIndex == peep->previous_ride) { if (rideIndex == peep->previous_ride) {
@ -9152,7 +9152,7 @@ static void peep_pick_ride_to_go_on(rct_peep *peep)
if (!(RCT2_ADDRESS(0x00F1AD98, uint32)[i >> 5] & (1u << (i & 0x1F)))) if (!(RCT2_ADDRESS(0x00F1AD98, uint32)[i >> 5] & (1u << (i & 0x1F))))
continue; continue;
rct_ride *ride = GET_RIDE(i); rct_ride *ride = get_ride(i);
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_QUEUE_FULL)) { if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_QUEUE_FULL)) {
if (peep_should_go_on_ride(peep, i, 0, PEEP_RIDE_DECISION_THINKING)) { if (peep_should_go_on_ride(peep, i, 0, PEEP_RIDE_DECISION_THINKING)) {
*nextPotentialRide++ = i; *nextPotentialRide++ = i;
@ -9165,7 +9165,7 @@ static void peep_pick_ride_to_go_on(rct_peep *peep)
int mostExcitingRideIndex = -1; int mostExcitingRideIndex = -1;
ride_rating mostExcitingRideRating = 0; ride_rating mostExcitingRideRating = 0;
for (int i = 0; i < numPotentialRides; i++) { for (int i = 0; i < numPotentialRides; i++) {
ride = GET_RIDE(potentialRides[i]); ride = get_ride(potentialRides[i]);
if (ride->excitement == (ride_rating)0xFFFF) continue; if (ride->excitement == (ride_rating)0xFFFF) continue;
if (ride->excitement > mostExcitingRideRating) { if (ride->excitement > mostExcitingRideRating) {
mostExcitingRideIndex = potentialRides[i]; mostExcitingRideIndex = potentialRides[i];
@ -9207,7 +9207,7 @@ static void peep_head_for_nearest_ride_type(rct_peep *peep, int rideType)
if (peep->flags & PEEP_FLAGS_LEAVING_PARK) return; if (peep->flags & PEEP_FLAGS_LEAVING_PARK) return;
if (peep->x == (sint16)0x8000) return; if (peep->x == (sint16)0x8000) return;
if (peep->guest_heading_to_ride_id != 255) { if (peep->guest_heading_to_ride_id != 255) {
ride = GET_RIDE(peep->guest_heading_to_ride_id); ride = get_ride(peep->guest_heading_to_ride_id);
if (ride->type == rideType) { if (ride->type == rideType) {
return; return;
} }
@ -9243,7 +9243,7 @@ static void peep_head_for_nearest_ride_type(rct_peep *peep, int rideType)
if (map_element_get_type(mapElement) != MAP_ELEMENT_TYPE_TRACK) continue; if (map_element_get_type(mapElement) != MAP_ELEMENT_TYPE_TRACK) continue;
int rideIndex = mapElement->properties.track.ride_index; int rideIndex = mapElement->properties.track.ride_index;
ride = GET_RIDE(rideIndex); ride = get_ride(rideIndex);
if (ride->type == rideType) { if (ride->type == rideType) {
RCT2_ADDRESS(0x00F1AD98, uint32)[rideIndex >> 5] |= (1u << (rideIndex & 0x1F)); RCT2_ADDRESS(0x00F1AD98, uint32)[rideIndex >> 5] |= (1u << (rideIndex & 0x1F));
} }
@ -9261,7 +9261,7 @@ static void peep_head_for_nearest_ride_type(rct_peep *peep, int rideType)
if (!(RCT2_ADDRESS(0x00F1AD98, uint32)[i >> 5] & (1u << (i & 0x1F)))) if (!(RCT2_ADDRESS(0x00F1AD98, uint32)[i >> 5] & (1u << (i & 0x1F))))
continue; continue;
rct_ride *ride = GET_RIDE(i); rct_ride *ride = get_ride(i);
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_QUEUE_FULL)) { if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_QUEUE_FULL)) {
if (peep_should_go_on_ride(peep, i, 0, PEEP_RIDE_DECISION_THINKING)) { if (peep_should_go_on_ride(peep, i, 0, PEEP_RIDE_DECISION_THINKING)) {
*nextPotentialRide++ = i; *nextPotentialRide++ = i;
@ -9274,7 +9274,7 @@ static void peep_head_for_nearest_ride_type(rct_peep *peep, int rideType)
int closestRideIndex = -1; int closestRideIndex = -1;
int closestRideDistance = INT_MAX; int closestRideDistance = INT_MAX;
for (int i = 0; i < numPotentialRides; i++) { for (int i = 0; i < numPotentialRides; i++) {
ride = GET_RIDE(potentialRides[i]); ride = get_ride(potentialRides[i]);
int rideX = (ride->station_starts[0] & 0xFF) * 32; int rideX = (ride->station_starts[0] & 0xFF) * 32;
int rideY = (ride->station_starts[0] >> 8) * 32; int rideY = (ride->station_starts[0] >> 8) * 32;
int distance = abs(rideX - peep->x) + abs(rideY - peep->y); int distance = abs(rideX - peep->x) + abs(rideY - peep->y);
@ -9315,7 +9315,7 @@ static void peep_head_for_nearest_ride_with_flags(rct_peep *peep, int rideTypeFl
if (peep->flags & PEEP_FLAGS_LEAVING_PARK) return; if (peep->flags & PEEP_FLAGS_LEAVING_PARK) return;
if (peep->x == (sint16)0x8000) return; if (peep->x == (sint16)0x8000) return;
if (peep->guest_heading_to_ride_id != 255) { if (peep->guest_heading_to_ride_id != 255) {
ride = GET_RIDE(peep->guest_heading_to_ride_id); ride = get_ride(peep->guest_heading_to_ride_id);
if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_IS_BATHROOM | RIDE_TYPE_FLAG_SELLS_DRINKS | RIDE_TYPE_FLAG_SELLS_FOOD)) { if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_IS_BATHROOM | RIDE_TYPE_FLAG_SELLS_DRINKS | RIDE_TYPE_FLAG_SELLS_FOOD)) {
return; return;
} }
@ -9355,7 +9355,7 @@ static void peep_head_for_nearest_ride_with_flags(rct_peep *peep, int rideTypeFl
if (map_element_get_type(mapElement) != MAP_ELEMENT_TYPE_TRACK) continue; if (map_element_get_type(mapElement) != MAP_ELEMENT_TYPE_TRACK) continue;
int rideIndex = mapElement->properties.track.ride_index; int rideIndex = mapElement->properties.track.ride_index;
ride = GET_RIDE(rideIndex); ride = get_ride(rideIndex);
if (ride_type_has_flag(ride->type, rideTypeFlags)) { if (ride_type_has_flag(ride->type, rideTypeFlags)) {
RCT2_ADDRESS(0x00F1AD98, uint32)[rideIndex >> 5] |= (1u << (rideIndex & 0x1F)); RCT2_ADDRESS(0x00F1AD98, uint32)[rideIndex >> 5] |= (1u << (rideIndex & 0x1F));
} }
@ -9373,7 +9373,7 @@ static void peep_head_for_nearest_ride_with_flags(rct_peep *peep, int rideTypeFl
if (!(RCT2_ADDRESS(0x00F1AD98, uint32)[i >> 5] & (1u << (i & 0x1F)))) if (!(RCT2_ADDRESS(0x00F1AD98, uint32)[i >> 5] & (1u << (i & 0x1F))))
continue; continue;
rct_ride *ride = GET_RIDE(i); rct_ride *ride = get_ride(i);
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_QUEUE_FULL)) { if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_QUEUE_FULL)) {
if (peep_should_go_on_ride(peep, i, 0, PEEP_RIDE_DECISION_THINKING)) { if (peep_should_go_on_ride(peep, i, 0, PEEP_RIDE_DECISION_THINKING)) {
*nextPotentialRide++ = i; *nextPotentialRide++ = i;
@ -9386,7 +9386,7 @@ static void peep_head_for_nearest_ride_with_flags(rct_peep *peep, int rideTypeFl
int closestRideIndex = -1; int closestRideIndex = -1;
int closestRideDistance = INT_MAX; int closestRideDistance = INT_MAX;
for (int i = 0; i < numPotentialRides; i++) { for (int i = 0; i < numPotentialRides; i++) {
ride = GET_RIDE(potentialRides[i]); ride = get_ride(potentialRides[i]);
int rideX = (ride->station_starts[0] & 0xFF) * 32; int rideX = (ride->station_starts[0] & 0xFF) * 32;
int rideY = (ride->station_starts[0] >> 8) * 32; int rideY = (ride->station_starts[0] >> 8) * 32;
int distance = abs(rideX - peep->x) + abs(rideY - peep->y); int distance = abs(rideX - peep->x) + abs(rideY - peep->y);

2
src/rct1.c
View File

@ -735,7 +735,7 @@ static void rct1_fix_z()
} }
for (int i = 0; i < MAX_RIDE_MEASUREMENTS; i++) { for (int i = 0; i < MAX_RIDE_MEASUREMENTS; i++) {
rideMeasurement = GET_RIDE_MEASUREMENT(i); rideMeasurement = get_ride_measurement(i);
if (rideMeasurement->ride_index == 255) if (rideMeasurement->ride_index == 255)
continue; continue;

10
src/ride/cable_lift.c
View File

@ -11,7 +11,7 @@ static void cable_lift_update_arriving(rct_vehicle *vehicle);
rct_vehicle *cable_lift_segment_create(int rideIndex, int x, int y, int z, int direction, uint16 var_44, sint32 remaining_distance, bool head) rct_vehicle *cable_lift_segment_create(int rideIndex, int x, int y, int z, int direction, uint16 var_44, sint32 remaining_distance, bool head)
{ {
rct_ride *ride = GET_RIDE(rideIndex); rct_ride *ride = get_ride(rideIndex);
rct_vehicle *current = &(create_sprite(1)->vehicle); rct_vehicle *current = &(create_sprite(1)->vehicle);
current->sprite_identifier = SPRITE_IDENTIFIER_VEHICLE; current->sprite_identifier = SPRITE_IDENTIFIER_VEHICLE;
current->ride = rideIndex; current->ride = rideIndex;
@ -200,7 +200,7 @@ static void cable_lift_update_arriving(rct_vehicle *vehicle)
} }
bool sub_6DF01A_loop(rct_vehicle* vehicle) { bool sub_6DF01A_loop(rct_vehicle* vehicle) {
rct_ride* ride = GET_RIDE(vehicle->ride); rct_ride* ride = get_ride(vehicle->ride);
rct_xyz16 *unk_F64E20 = RCT2_ADDRESS(0x00F64E20, rct_xyz16); rct_xyz16 *unk_F64E20 = RCT2_ADDRESS(0x00F64E20, rct_xyz16);
for (; vehicle->remaining_distance >= 13962; RCT2_GLOBAL(0x00F64E10, uint32)++) { for (; vehicle->remaining_distance >= 13962; RCT2_GLOBAL(0x00F64E10, uint32)++) {
@ -287,7 +287,7 @@ bool sub_6DF01A_loop(rct_vehicle* vehicle) {
} }
bool sub_6DF21B_loop(rct_vehicle* vehicle) { bool sub_6DF21B_loop(rct_vehicle* vehicle) {
rct_ride* ride = GET_RIDE(vehicle->ride); rct_ride* ride = get_ride(vehicle->ride);
rct_xyz16 *unk_F64E20 = RCT2_ADDRESS(0x00F64E20, rct_xyz16); rct_xyz16 *unk_F64E20 = RCT2_ADDRESS(0x00F64E20, rct_xyz16);
for (; vehicle->remaining_distance < 0; RCT2_GLOBAL(0x00F64E10, uint32)++) { for (; vehicle->remaining_distance < 0; RCT2_GLOBAL(0x00F64E10, uint32)++) {
@ -378,9 +378,9 @@ bool sub_6DF21B_loop(rct_vehicle* vehicle) {
*/ */
int cable_lift_update_track_motion(rct_vehicle *cableLift) int cable_lift_update_track_motion(rct_vehicle *cableLift)
{ {
rct_ride_type* rideEntry = GET_RIDE_ENTRY(cableLift->ride_subtype); rct_ride_type* rideEntry = get_ride_entry(cableLift->ride_subtype);
rct_ride_type_vehicle* vehicleEntry = &rideEntry->vehicles[cableLift->vehicle_type]; rct_ride_type_vehicle* vehicleEntry = &rideEntry->vehicles[cableLift->vehicle_type];
rct_ride* ride = GET_RIDE(cableLift->ride); rct_ride* ride = get_ride(cableLift->ride);
RCT2_GLOBAL(0x00F64E2C, uint8) = 0; RCT2_GLOBAL(0x00F64E2C, uint8) = 0;
RCT2_GLOBAL(0x00F64E04, rct_vehicle*) = cableLift; RCT2_GLOBAL(0x00F64E04, rct_vehicle*) = cableLift;

203
src/ride/ride.c
View File

@ -128,7 +128,7 @@ static const int RideInspectionInterval[] = {
}; };
rct_ride_type **gRideTypeList = RCT2_ADDRESS(RCT2_ADDRESS_RIDE_ENTRIES, rct_ride_type*); rct_ride_type **gRideTypeList = RCT2_ADDRESS(RCT2_ADDRESS_RIDE_ENTRIES, rct_ride_type*);
rct_ride* g_ride_list = RCT2_ADDRESS(RCT2_ADDRESS_RIDE_LIST, rct_ride); rct_ride* gRideList = RCT2_ADDRESS(RCT2_ADDRESS_RIDE_LIST, rct_ride);
bool gGotoStartPlacementMode = false; bool gGotoStartPlacementMode = false;
int gRideRemoveTrackPieceCallbackX; int gRideRemoveTrackPieceCallbackX;
int gRideRemoveTrackPieceCallbackY; int gRideRemoveTrackPieceCallbackY;
@ -156,9 +156,34 @@ static void ride_update_vehicle_colours(int rideIndex);
static void ride_set_vehicle_colours_to_random_preset(rct_ride *ride, uint8 preset_index); static void ride_set_vehicle_colours_to_random_preset(rct_ride *ride, uint8 preset_index);
static void maze_entrance_hedge_removal(int x, int y, rct_map_element *mapElement); static void maze_entrance_hedge_removal(int x, int y, rct_map_element *mapElement);
rct_ride *get_ride(int index)
{
if (index < 0 || index >= MAX_RIDES)
{
log_error("invalid index %d for ride", index);
return NULL;
}
return &gRideList[index];
}
rct_ride_type *get_ride_entry(int index)
{
if (index < 0 || index >= object_entry_group_counts[0])
{
log_error("invalid index %d for ride type", index);
return NULL;
}
return gRideTypeList[index];
}
rct_ride_measurement *get_ride_measurement(int index)
{
return &(RCT2_ADDRESS(RCT2_ADDRESS_RIDE_MEASUREMENTS, rct_ride_measurement)[index]);
}
rct_ride_type *ride_get_entry(rct_ride *ride) rct_ride_type *ride_get_entry(rct_ride *ride)
{ {
return GET_RIDE_ENTRY(ride->subtype); return get_ride_entry(ride->subtype);
} }
/** /**
@ -230,7 +255,7 @@ void ride_update_favourited_stat()
if (peep->linked_list_type_offset != SPRITE_LINKEDLIST_OFFSET_PEEP) if (peep->linked_list_type_offset != SPRITE_LINKEDLIST_OFFSET_PEEP)
return; return;
if (peep->favourite_ride != 0xff) { if (peep->favourite_ride != 0xff) {
ride = &g_ride_list[peep->favourite_ride]; ride = &gRideList[peep->favourite_ride];
ride->guests_favourite++; ride->guests_favourite++;
ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_CUSTOMER; ride->window_invalidate_flags |= RIDE_INVALIDATE_RIDE_CUSTOMER;
@ -279,7 +304,7 @@ money32 ride_calculate_income_per_hour(rct_ride *ride)
money32 customersPerHour, priceMinusCost; money32 customersPerHour, priceMinusCost;
int currentShopItem; int currentShopItem;
entry = GET_RIDE_ENTRY(ride->subtype); entry = get_ride_entry(ride->subtype);
customersPerHour = ride_customers_per_hour(ride); customersPerHour = ride_customers_per_hour(ride);
priceMinusCost = ride->price; priceMinusCost = ride->price;
@ -361,7 +386,7 @@ bool ride_try_get_origin_element(int rideIndex, rct_xy_element *output)
*/ */
bool track_block_get_next_from_zero(sint16 x, sint16 y, sint16 z_start, uint8 rideIndex, uint8 direction_start, rct_xy_element *output, int *z, int *direction) bool track_block_get_next_from_zero(sint16 x, sint16 y, sint16 z_start, uint8 rideIndex, uint8 direction_start, rct_xy_element *output, int *z, int *direction)
{ {
rct_ride* ride = GET_RIDE(rideIndex); rct_ride* ride = get_ride(rideIndex);
RCT2_GLOBAL(0x00F441D3, uint8) = direction_start; RCT2_GLOBAL(0x00F441D3, uint8) = direction_start;
if (!(direction_start & (1 << 2))){ if (!(direction_start & (1 << 2))){
@ -425,7 +450,7 @@ bool track_block_get_next(rct_xy_element *input, rct_xy_element *output, int *z,
{ {
uint8 rideIndex = input->element->properties.track.ride_index; uint8 rideIndex = input->element->properties.track.ride_index;
RCT2_GLOBAL(0x00F441D2, uint8) = rideIndex; RCT2_GLOBAL(0x00F441D2, uint8) = rideIndex;
rct_ride* ride = GET_RIDE(rideIndex); rct_ride* ride = get_ride(rideIndex);
const rct_preview_track* trackBlock = get_track_def_from_ride(ride, input->element->properties.track.type); const rct_preview_track* trackBlock = get_track_def_from_ride(ride, input->element->properties.track.type);
uint8 sequence = input->element->properties.track.sequence & 0xF; uint8 sequence = input->element->properties.track.sequence & 0xF;
@ -483,7 +508,7 @@ bool track_block_get_next(rct_xy_element *input, rct_xy_element *output, int *z,
* rct2: 0x006C63D6 * rct2: 0x006C63D6
*/ */
bool track_block_get_previous_from_zero(sint16 x, sint16 y, sint16 z, uint8 rideIndex, uint8 direction, track_begin_end *outTrackBeginEnd){ bool track_block_get_previous_from_zero(sint16 x, sint16 y, sint16 z, uint8 rideIndex, uint8 direction, track_begin_end *outTrackBeginEnd){
rct_ride* ride = GET_RIDE(rideIndex); rct_ride* ride = get_ride(rideIndex);
RCT2_GLOBAL(0x00F441D3, uint8) = direction; RCT2_GLOBAL(0x00F441D3, uint8) = direction;
direction ^= (1 << 1); direction ^= (1 << 1);
@ -586,7 +611,7 @@ bool track_block_get_previous(int x, int y, rct_map_element *mapElement, track_b
{ {
uint8 rideIndex = mapElement->properties.track.ride_index; uint8 rideIndex = mapElement->properties.track.ride_index;
RCT2_GLOBAL(0x00F441D2, uint8) = rideIndex; RCT2_GLOBAL(0x00F441D2, uint8) = rideIndex;
rct_ride* ride = GET_RIDE(rideIndex); rct_ride* ride = get_ride(rideIndex);
const rct_preview_track* trackBlock = get_track_def_from_ride(ride, mapElement->properties.track.type); const rct_preview_track* trackBlock = get_track_def_from_ride(ride, mapElement->properties.track.type);
uint8 sequence = mapElement->properties.track.sequence & 0xF; uint8 sequence = mapElement->properties.track.sequence & 0xF;
@ -642,7 +667,7 @@ int ride_find_track_gap(rct_xy_element *input, rct_xy_element *output)
int rideIndex; int rideIndex;
rideIndex = input->element->properties.track.ride_index; rideIndex = input->element->properties.track.ride_index;
ride = GET_RIDE(rideIndex); ride = get_ride(rideIndex);
if (ride->type == RIDE_TYPE_MAZE) if (ride->type == RIDE_TYPE_MAZE)
return 0; return 0;
@ -672,7 +697,7 @@ int ride_find_track_gap(rct_xy_element *input, rct_xy_element *output)
*/ */
void ride_get_status(int rideIndex, int *formatSecondary, int *argument) void ride_get_status(int rideIndex, int *formatSecondary, int *argument)
{ {
rct_ride *ride = &g_ride_list[rideIndex]; rct_ride *ride = get_ride(rideIndex);
if (ride->lifecycle_flags & RIDE_LIFECYCLE_CRASHED) { if (ride->lifecycle_flags & RIDE_LIFECYCLE_CRASHED) {
*formatSecondary = STR_CRASHED; *formatSecondary = STR_CRASHED;
@ -762,7 +787,7 @@ void ride_init_all()
rct_ride_measurement *ride_measurement; rct_ride_measurement *ride_measurement;
for (i = 0; i < MAX_RIDES; i++) { for (i = 0; i < MAX_RIDES; i++) {
ride = &g_ride_list[i]; ride = get_ride(i);
ride->type = RIDE_TYPE_NULL; ride->type = RIDE_TYPE_NULL;
} }
@ -770,7 +795,7 @@ void ride_init_all()
RCT2_GLOBAL(0x0138B591, sint8) = 0; RCT2_GLOBAL(0x0138B591, sint8) = 0;
for (i = 0; i < MAX_RIDE_MEASUREMENTS; i++) { for (i = 0; i < MAX_RIDE_MEASUREMENTS; i++) {
ride_measurement = GET_RIDE_MEASUREMENT(i); ride_measurement = get_ride_measurement(i);
ride_measurement->ride_index = 255; ride_measurement->ride_index = 255;
} }
} }
@ -943,7 +968,7 @@ void ride_clear_for_construction(int rideIndex)
rct_ride *ride; rct_ride *ride;
rct_window *w; rct_window *w;
ride = GET_RIDE(rideIndex); ride = get_ride(rideIndex);
ride_measurement_clear(ride); ride_measurement_clear(ride);
@ -970,7 +995,7 @@ void ride_remove_peeps(int rideIndex)
rct_map_element *mapElement; rct_map_element *mapElement;
rct_peep *peep; rct_peep *peep;
ride = GET_RIDE(rideIndex); ride = get_ride(rideIndex);
// Find first station // Find first station
stationIndex = -1; stationIndex = -1;
@ -1225,7 +1250,7 @@ void sub_6C96C0()
y = RCT2_GLOBAL(0x00F440C7, uint16); y = RCT2_GLOBAL(0x00F440C7, uint16);
z = RCT2_GLOBAL(0x00F440C9, uint16); z = RCT2_GLOBAL(0x00F440C9, uint16);
ride = GET_RIDE(rideIndex); ride = get_ride(rideIndex);
if (ride->type == RIDE_TYPE_MAZE) { if (ride->type == RIDE_TYPE_MAZE) {
game_do_command(x , 41 | (0 << 8), y , rideIndex | (2 << 8), GAME_COMMAND_SET_MAZE_TRACK, z, 0); game_do_command(x , 41 | (0 << 8), y , rideIndex | (2 << 8), GAME_COMMAND_SET_MAZE_TRACK, z, 0);
game_do_command(x , 41 | (1 << 8), y + 16, rideIndex | (2 << 8), GAME_COMMAND_SET_MAZE_TRACK, z, 0); game_do_command(x , 41 | (1 << 8), y + 16, rideIndex | (2 << 8), GAME_COMMAND_SET_MAZE_TRACK, z, 0);
@ -1304,7 +1329,7 @@ static void ride_construction_reset_current_piece()
{ {
rct_ride *ride; rct_ride *ride;
ride = GET_RIDE(_currentRideIndex); ride = get_ride(_currentRideIndex);
if (!ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_15) || ride->num_stations == 0) { if (!ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_15) || ride->num_stations == 0) {
_currentTrackCurve = RCT2_GLOBAL(0x0097CC68 + (ride->type * 2), uint8) | 0x100; _currentTrackCurve = RCT2_GLOBAL(0x0097CC68 + (ride->type * 2), uint8) | 0x100;
_currentTrackSlopeEnd = 0; _currentTrackSlopeEnd = 0;
@ -1338,7 +1363,7 @@ void ride_construction_set_default_next_piece()
switch (_rideConstructionState) { switch (_rideConstructionState) {
case RIDE_CONSTRUCTION_STATE_FRONT: case RIDE_CONSTRUCTION_STATE_FRONT:
rideIndex = _currentRideIndex; rideIndex = _currentRideIndex;
ride = GET_RIDE(rideIndex); ride = get_ride(rideIndex);
RCT2_GLOBAL(0x00F441D2, uint8) = rideIndex; RCT2_GLOBAL(0x00F441D2, uint8) = rideIndex;
x = _currentTrackBeginX; x = _currentTrackBeginX;
@ -1395,7 +1420,7 @@ void ride_construction_set_default_next_piece()
break; break;
case RIDE_CONSTRUCTION_STATE_BACK: case RIDE_CONSTRUCTION_STATE_BACK:
rideIndex = _currentRideIndex; rideIndex = _currentRideIndex;
ride = GET_RIDE(rideIndex); ride = get_ride(rideIndex);
RCT2_GLOBAL(0x00F441D2, uint8) = rideIndex; RCT2_GLOBAL(0x00F441D2, uint8) = rideIndex;
x = _currentTrackBeginX; x = _currentTrackBeginX;
@ -1644,7 +1669,7 @@ int ride_modify(rct_xy_element *input)
mapElement = *input; mapElement = *input;
rideIndex = mapElement.element->properties.track.ride_index; rideIndex = mapElement.element->properties.track.ride_index;
ride = GET_RIDE(rideIndex); ride = get_ride(rideIndex);
if (!ride_check_if_construction_allowed(ride)) if (!ride_check_if_construction_allowed(ride))
return 0; return 0;
@ -1739,7 +1764,7 @@ int sub_6CC3FB(int rideIndex)
rct_window *w; rct_window *w;
tool_cancel(); tool_cancel();
ride = GET_RIDE(rideIndex); ride = get_ride(rideIndex);
if (!ride_check_if_construction_allowed(ride)) if (!ride_check_if_construction_allowed(ride))
return 0; return 0;
@ -1752,7 +1777,7 @@ int sub_6CC3FB(int rideIndex)
tool_set(w, 23, 12); tool_set(w, 23, 12);
gInputFlags |= INPUT_FLAG_6; gInputFlags |= INPUT_FLAG_6;
ride = GET_RIDE(_currentRideIndex); ride = get_ride(_currentRideIndex);
_currentTrackCurve = RCT2_ADDRESS(0x0097CC68, uint8)[ride->type * 2] | 0x100; _currentTrackCurve = RCT2_ADDRESS(0x0097CC68, uint8)[ride->type * 2] | 0x100;
_currentTrackSlopeEnd = 0; _currentTrackSlopeEnd = 0;
@ -1815,7 +1840,7 @@ void ride_update_all()
static void ride_update(int rideIndex) static void ride_update(int rideIndex)
{ {
int i; int i;
rct_ride *ride = GET_RIDE(rideIndex); rct_ride *ride = get_ride(rideIndex);
if (ride->var_1CA != 0) if (ride->var_1CA != 0)
ride->var_1CA--; ride->var_1CA--;
@ -2076,7 +2101,7 @@ static int get_age_penalty(rct_ride *ride) {
static void ride_breakdown_update(int rideIndex) static void ride_breakdown_update(int rideIndex)
{ {
int breakdownReason, unreliabilityAccumulator; int breakdownReason, unreliabilityAccumulator;
rct_ride *ride = GET_RIDE(rideIndex); rct_ride *ride = get_ride(rideIndex);
if (RCT2_GLOBAL(RCT2_ADDRESS_CURRENT_TICKS, uint32) & 255) if (RCT2_GLOBAL(RCT2_ADDRESS_CURRENT_TICKS, uint32) & 255)
return; return;
@ -2203,7 +2228,7 @@ void ride_prepare_breakdown(int rideIndex, int breakdownReason)
rct_ride *ride; rct_ride *ride;
rct_vehicle *vehicle; rct_vehicle *vehicle;
ride = GET_RIDE(rideIndex); ride = get_ride(rideIndex);
if (ride->lifecycle_flags & (RIDE_LIFECYCLE_BREAKDOWN_PENDING | RIDE_LIFECYCLE_BROKEN_DOWN | RIDE_LIFECYCLE_CRASHED)) if (ride->lifecycle_flags & (RIDE_LIFECYCLE_BREAKDOWN_PENDING | RIDE_LIFECYCLE_BROKEN_DOWN | RIDE_LIFECYCLE_CRASHED))
return; return;
@ -2275,7 +2300,7 @@ void ride_prepare_breakdown(int rideIndex, int breakdownReason)
*/ */
void ride_breakdown_add_news_item(int rideIndex) void ride_breakdown_add_news_item(int rideIndex)
{ {
rct_ride *ride = GET_RIDE(rideIndex); rct_ride *ride = get_ride(rideIndex);
RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 0, uint16) = ride->name; RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 0, uint16) = ride->name;
RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 2, uint32) = ride->name_arguments; RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 2, uint32) = ride->name_arguments;
@ -2290,7 +2315,7 @@ void ride_breakdown_add_news_item(int rideIndex)
*/ */
static void ride_breakdown_status_update(int rideIndex) static void ride_breakdown_status_update(int rideIndex)
{ {
rct_ride *ride = GET_RIDE(rideIndex); rct_ride *ride = get_ride(rideIndex);
// Warn player if ride hasnt been fixed for ages // Warn player if ride hasnt been fixed for ages
if (ride->lifecycle_flags & RIDE_LIFECYCLE_BROKEN_DOWN) { if (ride->lifecycle_flags & RIDE_LIFECYCLE_BROKEN_DOWN) {
@ -2324,7 +2349,7 @@ static void ride_mechanic_status_update(int rideIndex, int mechanicStatus)
rct_ride *ride; rct_ride *ride;
rct_peep *mechanic; rct_peep *mechanic;
ride = GET_RIDE(rideIndex); ride = get_ride(rideIndex);
switch (mechanicStatus) { switch (mechanicStatus) {
case RIDE_MECHANIC_STATUS_UNDEFINED: case RIDE_MECHANIC_STATUS_UNDEFINED:
breakdownReason = ride->breakdown_reason_pending; breakdownReason = ride->breakdown_reason_pending;
@ -2387,7 +2412,7 @@ static void ride_call_mechanic(int rideIndex, rct_peep *mechanic, int forInspect
{ {
rct_ride *ride; rct_ride *ride;
ride = GET_RIDE(rideIndex); ride = get_ride(rideIndex);
peep_decrement_num_riders(mechanic); peep_decrement_num_riders(mechanic);
mechanic->state = forInspection ? PEEP_STATE_HEADING_TO_INSPECTION : PEEP_STATE_ANSWERING; mechanic->state = forInspection ? PEEP_STATE_HEADING_TO_INSPECTION : PEEP_STATE_ANSWERING;
peep_window_state_update(mechanic); peep_window_state_update(mechanic);
@ -2409,7 +2434,7 @@ static void ride_call_closest_mechanic(int rideIndex)
rct_peep *mechanic; rct_peep *mechanic;
int forInspection; int forInspection;
ride = GET_RIDE(rideIndex); ride = get_ride(rideIndex);
forInspection = (ride->lifecycle_flags & (RIDE_LIFECYCLE_BREAKDOWN_PENDING | RIDE_LIFECYCLE_BROKEN_DOWN)) == 0; forInspection = (ride->lifecycle_flags & (RIDE_LIFECYCLE_BREAKDOWN_PENDING | RIDE_LIFECYCLE_BROKEN_DOWN)) == 0;
mechanic = ride_find_closest_mechanic(ride, forInspection); mechanic = ride_find_closest_mechanic(ride, forInspection);
@ -2570,7 +2595,7 @@ static void ride_music_update(int rideIndex)
{ {
int x, y, z; int x, y, z;
rct_vehicle *vehicle; rct_vehicle *vehicle;
rct_ride *ride = GET_RIDE(rideIndex); rct_ride *ride = get_ride(rideIndex);
if ( if (
!(RideData4[ride->type].flags & RIDE_TYPE_FLAG4_MUSIC_ON_DEFAULT) && !(RideData4[ride->type].flags & RIDE_TYPE_FLAG4_MUSIC_ON_DEFAULT) &&
@ -2656,7 +2681,7 @@ void ride_measurement_clear(rct_ride *ride)
if (ride->measurement_index == 255) if (ride->measurement_index == 255)
return; return;
measurement = GET_RIDE_MEASUREMENT(ride->measurement_index); measurement = get_ride_measurement(ride->measurement_index);
measurement->ride_index = 255; measurement->ride_index = 255;
ride->measurement_index = 255; ride->measurement_index = 255;
} }
@ -2672,7 +2697,7 @@ void ride_measurement_update(rct_ride_measurement *measurement)
rct_vehicle *vehicle; rct_vehicle *vehicle;
int velocity, altitude, verticalG, lateralG; int velocity, altitude, verticalG, lateralG;
ride = GET_RIDE(measurement->ride_index); ride = get_ride(measurement->ride_index);
spriteIndex = ride->vehicles[measurement->vehicle_index]; spriteIndex = ride->vehicles[measurement->vehicle_index];
if (spriteIndex == SPRITE_INDEX_NULL) if (spriteIndex == SPRITE_INDEX_NULL)
return; return;
@ -2754,11 +2779,11 @@ void ride_measurements_update()
// For each ride measurement // For each ride measurement
for (i = 0; i < MAX_RIDE_MEASUREMENTS; i++) { for (i = 0; i < MAX_RIDE_MEASUREMENTS; i++) {
measurement = GET_RIDE_MEASUREMENT(i); measurement = get_ride_measurement(i);
if (measurement->ride_index == 255) if (measurement->ride_index == 255)
continue; continue;
ride = GET_RIDE(measurement->ride_index); ride = get_ride(measurement->ride_index);
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_ON_TRACK)) if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_ON_TRACK))
continue; continue;
@ -2792,7 +2817,7 @@ rct_ride_measurement *ride_get_existing_measurement(int rideIndex)
rct_ride_measurement *measurement; rct_ride_measurement *measurement;
for (i = 0; i < MAX_RIDE_MEASUREMENTS; i++) { for (i = 0; i < MAX_RIDE_MEASUREMENTS; i++) {
measurement = GET_RIDE_MEASUREMENT(i); measurement = get_ride_measurement(i);
if (measurement->ride_index == rideIndex) if (measurement->ride_index == rideIndex)
return measurement; return measurement;
} }
@ -2806,7 +2831,7 @@ int ride_get_free_measurement()
rct_ride_measurement *measurement; rct_ride_measurement *measurement;
for (i = 0; i < MAX_RIDE_MEASUREMENTS; i++) { for (i = 0; i < MAX_RIDE_MEASUREMENTS; i++) {
measurement = GET_RIDE_MEASUREMENT(i); measurement = get_ride_measurement(i);
if (measurement->ride_index == 255) if (measurement->ride_index == 255)
return i; return i;
} }
@ -2825,7 +2850,7 @@ rct_ride_measurement *ride_get_measurement(int rideIndex, rct_string_id *message
uint32 lruTicks; uint32 lruTicks;
int i, lruIndex; int i, lruIndex;
ride = GET_RIDE(rideIndex); ride = get_ride(rideIndex);
// Check if ride type supports data logging // Check if ride type supports data logging
if (!ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_HAS_DATA_LOGGING)) { if (!ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_HAS_DATA_LOGGING)) {
@ -2843,7 +2868,7 @@ rct_ride_measurement *ride_get_measurement(int rideIndex, rct_string_id *message
lruIndex = 0; lruIndex = 0;
lruTicks = 0xFFFFFFFF; lruTicks = 0xFFFFFFFF;
for (i = 0; i < MAX_RIDE_MEASUREMENTS; i++) { for (i = 0; i < MAX_RIDE_MEASUREMENTS; i++) {
measurement = GET_RIDE_MEASUREMENT(i); measurement = get_ride_measurement(i);
if (measurement->last_use_tick <= lruTicks) { if (measurement->last_use_tick <= lruTicks) {
lruTicks = measurement->last_use_tick; lruTicks = measurement->last_use_tick;
@ -2852,10 +2877,10 @@ rct_ride_measurement *ride_get_measurement(int rideIndex, rct_string_id *message
} }
i = lruIndex; i = lruIndex;
measurement = GET_RIDE_MEASUREMENT(i); measurement = get_ride_measurement(i);
GET_RIDE(measurement->ride_index)->measurement_index = 255; get_ride(measurement->ride_index)->measurement_index = 255;
} else { } else {
measurement = GET_RIDE_MEASUREMENT(i); measurement = get_ride_measurement(i);
} }
measurement->ride_index = rideIndex; measurement->ride_index = rideIndex;
@ -2919,7 +2944,7 @@ static int ride_get_unused_preset_vehicle_colour(uint8 ride_type, uint8 ride_sub
{ {
return 0; return 0;
} }
rct_ride_type *rideEntry = GET_RIDE_ENTRY(ride_sub_type); rct_ride_type *rideEntry = get_ride_entry(ride_sub_type);
if (rideEntry == (rct_ride_type *)0xFFFFFFFF) if (rideEntry == (rct_ride_type *)0xFFFFFFFF)
{ {
return 0; return 0;
@ -2946,7 +2971,7 @@ static int ride_get_unused_preset_vehicle_colour(uint8 ride_type, uint8 ride_sub
*/ */
static void ride_set_vehicle_colours_to_random_preset(rct_ride *ride, uint8 preset_index) static void ride_set_vehicle_colours_to_random_preset(rct_ride *ride, uint8 preset_index)
{ {
rct_ride_type *rideEntry = GET_RIDE_ENTRY(ride->subtype); rct_ride_type *rideEntry = get_ride_entry(ride->subtype);
vehicle_colour_preset_list *presetList = rideEntry->vehicle_preset_list; vehicle_colour_preset_list *presetList = rideEntry->vehicle_preset_list;
if (presetList->count != 255) { if (presetList->count != 255) {
ride->colour_scheme_type = RIDE_COLOUR_SCHEME_ALL_SAME; ride->colour_scheme_type = RIDE_COLOUR_SCHEME_ALL_SAME;
@ -3079,7 +3104,7 @@ static void ride_shop_connected(rct_ride* ride, int ride_idx)
uint16 entrance_directions = 0; uint16 entrance_directions = 0;
uint8 track_type = mapElement->properties.track.type; uint8 track_type = mapElement->properties.track.type;
ride = &g_ride_list[mapElement->properties.track.ride_index]; ride = get_ride(mapElement->properties.track.ride_index);
if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_FLAT_RIDE)) { if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_FLAT_RIDE)) {
entrance_directions = RCT2_ADDRESS(0x0099CA64, uint8)[track_type * 16]; entrance_directions = RCT2_ADDRESS(0x0099CA64, uint8)[track_type * 16];
} else { } else {
@ -3135,7 +3160,7 @@ static void ride_track_set_map_tooltip(rct_map_element *mapElement)
rct_ride *ride; rct_ride *ride;
rideIndex = mapElement->properties.track.ride_index; rideIndex = mapElement->properties.track.ride_index;
ride = GET_RIDE(rideIndex); ride = get_ride(rideIndex);
RCT2_GLOBAL(RCT2_ADDRESS_MAP_TOOLTIP_ARGS + 0, uint16) = 2215; RCT2_GLOBAL(RCT2_ADDRESS_MAP_TOOLTIP_ARGS + 0, uint16) = 2215;
RCT2_GLOBAL(RCT2_ADDRESS_MAP_TOOLTIP_ARGS + 2, uint16) = ride->name; RCT2_GLOBAL(RCT2_ADDRESS_MAP_TOOLTIP_ARGS + 2, uint16) = ride->name;
@ -3153,7 +3178,7 @@ static void ride_station_set_map_tooltip(rct_map_element *mapElement)
rct_ride *ride; rct_ride *ride;
rideIndex = mapElement->properties.track.ride_index; rideIndex = mapElement->properties.track.ride_index;
ride = GET_RIDE(rideIndex); ride = get_ride(rideIndex);
stationIndex = map_get_station(mapElement); stationIndex = map_get_station(mapElement);
for (i = stationIndex; i >= 0; i--) for (i = stationIndex; i >= 0; i--)
@ -3179,7 +3204,7 @@ static void ride_entrance_set_map_tooltip(rct_map_element *mapElement)
rct_ride *ride; rct_ride *ride;
rideIndex = mapElement->properties.track.ride_index; rideIndex = mapElement->properties.track.ride_index;
ride = GET_RIDE(rideIndex); ride = get_ride(rideIndex);
// Get the station // Get the station
stationIndex = map_get_station(mapElement); stationIndex = map_get_station(mapElement);
@ -3602,7 +3627,7 @@ void game_command_set_ride_setting(int *eax, int *ebx, int *ecx, int *edx, int *
*ebx = MONEY32_UNDEFINED; *ebx = MONEY32_UNDEFINED;
return; return;
} }
rct_ride* ride = GET_RIDE(ride_id); rct_ride* ride = get_ride(ride_id);
if (ride->type == RIDE_TYPE_NULL) if (ride->type == RIDE_TYPE_NULL)
{ {
log_warning("Invalid game command."); log_warning("Invalid game command.");
@ -3649,7 +3674,7 @@ void game_command_set_ride_setting(int *eax, int *ebx, int *ecx, int *edx, int *
ride_clear_for_construction(ride_id); ride_clear_for_construction(ride_id);
ride_remove_peeps(ride_id); ride_remove_peeps(ride_id);
rct_ride_type* ride_entry = GET_RIDE_ENTRY(ride->subtype); rct_ride_type* ride_entry = get_ride_entry(ride->subtype);
const uint8* available_modes = ride_seek_available_modes(ride); const uint8* available_modes = ride_seek_available_modes(ride);
if ((ride_entry->flags & RIDE_ENTRY_DISABLE_FIRST_TWO_OPERATING_MODES) && !gCheatsShowAllOperatingModes){ if ((ride_entry->flags & RIDE_ENTRY_DISABLE_FIRST_TWO_OPERATING_MODES) && !gCheatsShowAllOperatingModes){
@ -3788,7 +3813,7 @@ int ride_mode_check_station_present(rct_ride* ride){
*/ */
int ride_check_for_entrance_exit(int rideIndex) int ride_check_for_entrance_exit(int rideIndex)
{ {
rct_ride* ride = GET_RIDE(rideIndex); rct_ride* ride = get_ride(rideIndex);
if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_IS_SHOP)) if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_IS_SHOP))
return 1; return 1;
@ -3835,7 +3860,7 @@ int ride_check_for_entrance_exit(int rideIndex)
*/ */
void sub_6B5952(int rideIndex) void sub_6B5952(int rideIndex)
{ {
rct_ride *ride = GET_RIDE(rideIndex); rct_ride *ride = get_ride(rideIndex);
for (int i = 0; i < 4; i++) { for (int i = 0; i < 4; i++) {
uint16 xy = ride->entrances[i]; uint16 xy = ride->entrances[i];
@ -3920,7 +3945,7 @@ bool ride_check_track_contains_inversions(rct_xy_element *input, rct_xy_element
track_circuit_iterator it; track_circuit_iterator it;
rideIndex = input->element->properties.track.ride_index; rideIndex = input->element->properties.track.ride_index;
ride = GET_RIDE(rideIndex); ride = get_ride(rideIndex);
if (ride->type == RIDE_TYPE_MAZE) if (ride->type == RIDE_TYPE_MAZE)
return true; return true;
@ -3955,7 +3980,7 @@ bool ride_check_track_contains_banked(rct_xy_element *input, rct_xy_element *out
track_circuit_iterator it; track_circuit_iterator it;
rideIndex = input->element->properties.track.ride_index; rideIndex = input->element->properties.track.ride_index;
ride = GET_RIDE(rideIndex); ride = get_ride(rideIndex);
if (ride->type == RIDE_TYPE_MAZE) if (ride->type == RIDE_TYPE_MAZE)
return true; return true;
@ -4036,7 +4061,7 @@ bool ride_check_start_and_end_is_station(rct_xy_element *input, rct_xy_element *
rct_xy_element trackBack, trackFront; rct_xy_element trackBack, trackFront;
rideIndex = input->element->properties.track.ride_index; rideIndex = input->element->properties.track.ride_index;
ride = GET_RIDE(rideIndex); ride = get_ride(rideIndex);
w = window_find_by_class(WC_RIDE_CONSTRUCTION); w = window_find_by_class(WC_RIDE_CONSTRUCTION);
if (w != NULL && _rideConstructionState != RIDE_CONSTRUCTION_STATE_0 && rideIndex == _currentRideIndex) { if (w != NULL && _rideConstructionState != RIDE_CONSTRUCTION_STATE_0 && rideIndex == _currentRideIndex) {
@ -4168,7 +4193,7 @@ static void ride_set_block_points(rct_xy_element *startElement)
*/ */
void ride_set_start_finish_points(int rideIndex, rct_xy_element *startElement) void ride_set_start_finish_points(int rideIndex, rct_xy_element *startElement)
{ {
rct_ride *ride = GET_RIDE(rideIndex); rct_ride *ride = get_ride(rideIndex);
switch (ride->type) { switch (ride->type) {
case RIDE_TYPE_BOAT_RIDE: case RIDE_TYPE_BOAT_RIDE:
@ -4446,7 +4471,7 @@ static bool ride_initialise_cable_lift_track(rct_ride *ride, bool isApplying)
*/ */
bool ride_create_cable_lift(int rideIndex, bool isApplying) bool ride_create_cable_lift(int rideIndex, bool isApplying)
{ {
rct_ride *ride = GET_RIDE(rideIndex); rct_ride *ride = get_ride(rideIndex);
if (ride->mode != RIDE_MODE_CONTINUOUS_CIRCUIT_BLOCK_SECTIONED && if (ride->mode != RIDE_MODE_CONTINUOUS_CIRCUIT_BLOCK_SECTIONED &&
ride->mode != RIDE_MODE_CONTINUOUS_CIRCUIT ride->mode != RIDE_MODE_CONTINUOUS_CIRCUIT
@ -4525,7 +4550,7 @@ void loc_6B51C0(int rideIndex)
rct_xy_element trackElement; rct_xy_element trackElement;
rct_window *w; rct_window *w;
ride = GET_RIDE(rideIndex); ride = get_ride(rideIndex);
if (RCT2_GLOBAL(0x0141F568, uint8) != RCT2_GLOBAL(0x013CA740, uint8)) if (RCT2_GLOBAL(0x0141F568, uint8) != RCT2_GLOBAL(0x013CA740, uint8))
return; return;
@ -4578,7 +4603,7 @@ void loc_6B528A(rct_xy_element *trackElement)
rct_ride *ride; rct_ride *ride;
rct_window *w; rct_window *w;
ride = GET_RIDE(trackElement->element->properties.track.ride_index); ride = get_ride(trackElement->element->properties.track.ride_index);
if (RCT2_GLOBAL(0x0141F568, uint8) != RCT2_GLOBAL(0x013CA740, uint8)) if (RCT2_GLOBAL(0x0141F568, uint8) != RCT2_GLOBAL(0x013CA740, uint8))
return; return;
@ -4626,7 +4651,7 @@ int ride_is_valid_for_test(int rideIndex, int goingToBeOpen, int isApplying)
rct_ride *ride; rct_ride *ride;
rct_xy_element trackElement, problematicTrackElement; rct_xy_element trackElement, problematicTrackElement;
ride = GET_RIDE(rideIndex); ride = get_ride(rideIndex);
if (ride->type == RIDE_TYPE_NULL) if (ride->type == RIDE_TYPE_NULL)
{ {
log_warning("Invalid ride type for ride %u", rideIndex); log_warning("Invalid ride type for ride %u", rideIndex);
@ -4686,7 +4711,7 @@ int ride_is_valid_for_test(int rideIndex, int goingToBeOpen, int isApplying)
} }
if (ride->subtype != 255) { if (ride->subtype != 255) {
rct_ride_type *rideType = GET_RIDE_ENTRY(ride->subtype); rct_ride_type *rideType = get_ride_entry(ride->subtype);
if (rideType->flags & RIDE_ENTRY_FLAG_NO_INVERSIONS) { if (rideType->flags & RIDE_ENTRY_FLAG_NO_INVERSIONS) {
RCT2_GLOBAL(RCT2_ADDRESS_GAME_COMMAND_ERROR_TEXT, uint16) = STR_TRACK_UNSUITABLE_FOR_TYPE_OF_TRAIN; RCT2_GLOBAL(RCT2_ADDRESS_GAME_COMMAND_ERROR_TEXT, uint16) = STR_TRACK_UNSUITABLE_FOR_TYPE_OF_TRAIN;
if (ride_check_track_contains_inversions(&trackElement, &problematicTrackElement)) { if (ride_check_track_contains_inversions(&trackElement, &problematicTrackElement)) {
@ -4755,7 +4780,7 @@ int ride_is_valid_for_open(int rideIndex, int goingToBeOpen, int isApplying)
rct_ride *ride; rct_ride *ride;
rct_xy_element trackElement, problematicTrackElement; rct_xy_element trackElement, problematicTrackElement;
ride = GET_RIDE(rideIndex); ride = get_ride(rideIndex);
window_close_by_number(WC_RIDE_CONSTRUCTION, rideIndex); window_close_by_number(WC_RIDE_CONSTRUCTION, rideIndex);
@ -4810,7 +4835,7 @@ int ride_is_valid_for_open(int rideIndex, int goingToBeOpen, int isApplying)
} }
if (ride->subtype != 255) { if (ride->subtype != 255) {
rct_ride_type *rideType = GET_RIDE_ENTRY(ride->subtype); rct_ride_type *rideType = get_ride_entry(ride->subtype);
if (rideType->flags & RIDE_ENTRY_FLAG_NO_INVERSIONS) { if (rideType->flags & RIDE_ENTRY_FLAG_NO_INVERSIONS) {
RCT2_GLOBAL(RCT2_ADDRESS_GAME_COMMAND_ERROR_TEXT, uint16) = STR_TRACK_UNSUITABLE_FOR_TYPE_OF_TRAIN; RCT2_GLOBAL(RCT2_ADDRESS_GAME_COMMAND_ERROR_TEXT, uint16) = STR_TRACK_UNSUITABLE_FOR_TYPE_OF_TRAIN;
if (ride_check_track_contains_inversions(&trackElement, &problematicTrackElement)) { if (ride_check_track_contains_inversions(&trackElement, &problematicTrackElement)) {
@ -4895,7 +4920,7 @@ void game_command_set_ride_status(int *eax, int *ebx, int *ecx, int *edx, int *e
RCT2_GLOBAL(RCT2_ADDRESS_NEXT_EXPENDITURE_TYPE, uint8) = RCT_EXPENDITURE_TYPE_RIDE_RUNNING_COSTS * 4; RCT2_GLOBAL(RCT2_ADDRESS_NEXT_EXPENDITURE_TYPE, uint8) = RCT_EXPENDITURE_TYPE_RIDE_RUNNING_COSTS * 4;
ride = GET_RIDE(rideIndex); ride = get_ride(rideIndex);
if (ride->type == RIDE_TYPE_NULL) if (ride->type == RIDE_TYPE_NULL)
{ {
log_warning("Invalid game command for ride %u", rideIndex); log_warning("Invalid game command for ride %u", rideIndex);
@ -4999,7 +5024,7 @@ void game_command_set_ride_name(int *eax, int *ebx, int *ecx, int *edx, int *esi
return; return;
} }
ride = GET_RIDE(rideIndex); ride = get_ride(rideIndex);
if (ride->type == RIDE_TYPE_NULL) if (ride->type == RIDE_TYPE_NULL)
{ {
log_warning("Invalid game command for ride %u", rideIndex); log_warning("Invalid game command for ride %u", rideIndex);
@ -5151,7 +5176,7 @@ static int ride_get_empty_slot()
{ {
rct_ride *ride; rct_ride *ride;
for (int i = 0; i < MAX_RIDES; i++) { for (int i = 0; i < MAX_RIDES; i++) {
ride = GET_RIDE(i); ride = get_ride(i);
if (ride->type == RIDE_TYPE_NULL) { if (ride->type == RIDE_TYPE_NULL) {
return i; return i;
} }
@ -5161,7 +5186,7 @@ static int ride_get_empty_slot()
static int ride_get_default_mode(rct_ride *ride) static int ride_get_default_mode(rct_ride *ride)
{ {
const rct_ride_type *rideEntry = GET_RIDE_ENTRY(ride->subtype); const rct_ride_type *rideEntry = get_ride_entry(ride->subtype);
const uint8 *availableModes = RideAvailableModes; const uint8 *availableModes = RideAvailableModes;
for (int i = 0; i < ride->type; i++) { for (int i = 0; i < ride->type; i++) {
@ -5272,7 +5297,7 @@ static money32 shop_item_get_common_price(rct_ride *forRide, int shopItem)
FOR_ALL_RIDES(i, ride) { FOR_ALL_RIDES(i, ride) {
if (ride != forRide) { if (ride != forRide) {
rideEntry = GET_RIDE_ENTRY(ride->subtype); rideEntry = get_ride_entry(ride->subtype);
if (rideEntry->shop_item == shopItem) { if (rideEntry->shop_item == shopItem) {
return ride->price; return ride->price;
} }
@ -5314,7 +5339,7 @@ money32 ride_create(int type, int subType, int flags, int *outRideIndex, int *ou
if (subType == 255) { if (subType == 255) {
uint8 *availableRideEntries = get_ride_entry_indices_for_ride_type(type); uint8 *availableRideEntries = get_ride_entry_indices_for_ride_type(type);
for (uint8 *rei = availableRideEntries; *rei != 255; rei++) { for (uint8 *rei = availableRideEntries; *rei != 255; rei++) {
rideEntry = GET_RIDE_ENTRY(*rei); rideEntry = get_ride_entry(*rei);
if ((rideEntry->flags & RIDE_ENTRY_FLAG_SEPARATE_RIDE_NAME) && !rideTypeShouldLoseSeparateFlag(rideEntry)) { if ((rideEntry->flags & RIDE_ENTRY_FLAG_SEPARATE_RIDE_NAME) && !rideTypeShouldLoseSeparateFlag(rideEntry)) {
subType = *rei; subType = *rei;
goto foundRideEntry; goto foundRideEntry;
@ -5351,8 +5376,8 @@ foundRideEntry:
return 0; return 0;
} }
ride = GET_RIDE(rideIndex); ride = get_ride(rideIndex);
rideEntry = GET_RIDE_ENTRY(rideEntryIndex); rideEntry = get_ride_entry(rideEntryIndex);
if (rideEntry == (rct_ride_type *)0xFFFFFFFF) if (rideEntry == (rct_ride_type *)0xFFFFFFFF)
{ {
log_warning("Invalid request for ride %u", rideIndex); log_warning("Invalid request for ride %u", rideIndex);
@ -5673,7 +5698,7 @@ void game_command_demolish_ride(int *eax, int *ebx, int *ecx, int *edx, int *esi
RCT2_GLOBAL(RCT2_ADDRESS_COMMAND_MAP_X, uint16) = 0; RCT2_GLOBAL(RCT2_ADDRESS_COMMAND_MAP_X, uint16) = 0;
RCT2_GLOBAL(RCT2_ADDRESS_COMMAND_MAP_Y, uint16) = 0; RCT2_GLOBAL(RCT2_ADDRESS_COMMAND_MAP_Y, uint16) = 0;
RCT2_GLOBAL(RCT2_ADDRESS_COMMAND_MAP_Z, uint16) = 0; RCT2_GLOBAL(RCT2_ADDRESS_COMMAND_MAP_Z, uint16) = 0;
rct_ride *ride = GET_RIDE(ride_id); rct_ride *ride = get_ride(ride_id);
if (ride->type == RIDE_TYPE_NULL) if (ride->type == RIDE_TYPE_NULL)
{ {
log_warning("Invalid game command for ride %u", ride_id); log_warning("Invalid game command for ride %u", ride_id);
@ -5821,7 +5846,7 @@ void game_command_set_ride_appearance(int *eax, int *ebx, int *ecx, int *edx, in
return; return;
} }
rct_ride *ride = GET_RIDE(ride_id); rct_ride *ride = get_ride(ride_id);
if (ride->type == RIDE_TYPE_NULL) { if (ride->type == RIDE_TYPE_NULL) {
log_warning("Invalid game command, ride_id = %u", ride_id); log_warning("Invalid game command, ride_id = %u", ride_id);
*ebx = MONEY32_UNDEFINED; *ebx = MONEY32_UNDEFINED;
@ -5940,14 +5965,14 @@ void game_command_set_ride_price(int *eax, int *ebx, int *ecx, int *edx, int *es
*ebx = MONEY32_UNDEFINED; *ebx = MONEY32_UNDEFINED;
return; return;
} }
ride = GET_RIDE(ride_number); ride = get_ride(ride_number);
if (ride->type == RIDE_TYPE_NULL) if (ride->type == RIDE_TYPE_NULL)
{ {
log_warning("Invalid game command for ride %u", ride_number); log_warning("Invalid game command for ride %u", ride_number);
*ebx = MONEY32_UNDEFINED; *ebx = MONEY32_UNDEFINED;
return; return;
} }
rideEntry = GET_RIDE_ENTRY(ride->subtype); rideEntry = get_ride_entry(ride->subtype);
price = *edi; price = *edi;
secondary_price = (*edx >> 8); secondary_price = (*edx >> 8);
@ -6002,8 +6027,8 @@ void game_command_set_ride_price(int *eax, int *ebx, int *ecx, int *edx, int *es
return; return;
} }
} }
ride = GET_RIDE(0); ride = get_ride(0);
rideEntry = GET_RIDE_ENTRY(ride->subtype); rideEntry = get_ride_entry(ride->subtype);
uint8 count = 0; uint8 count = 0;
while (count < 0xFF) { while (count < 0xFF) {
if (ride->type != 0xFF) { if (ride->type != 0xFF) {
@ -6028,7 +6053,7 @@ void game_command_set_ride_price(int *eax, int *ebx, int *ecx, int *edx, int *es
} }
count++; count++;
ride++; ride++;
rideEntry = GET_RIDE_ENTRY(ride->subtype); rideEntry = get_ride_entry(ride->subtype);
} }
} }
} }
@ -6465,7 +6490,7 @@ void ride_get_entrance_or_exit_position_from_screen_position(int screenX, int sc
} }
} }
ride = GET_RIDE(RCT2_GLOBAL(0x00F44192, uint8)); ride = get_ride(RCT2_GLOBAL(0x00F44192, uint8));
stationHeight = ride->station_heights[RCT2_GLOBAL(0x00F44193, uint8)]; stationHeight = ride->station_heights[RCT2_GLOBAL(0x00F44193, uint8)];
screen_get_map_xy_with_z(screenX, screenY, stationHeight * 8, &mapX, &mapY); screen_get_map_xy_with_z(screenX, screenY, stationHeight * 8, &mapX, &mapY);
@ -6672,7 +6697,7 @@ bool ride_are_all_possible_entrances_and_exits_built(rct_ride *ride)
*/ */
void invalidate_test_results(int rideIndex) void invalidate_test_results(int rideIndex)
{ {
rct_ride *ride = GET_RIDE(rideIndex); rct_ride *ride = get_ride(rideIndex);
ride_measurement_clear(ride); ride_measurement_clear(ride);
ride->excitement = 0xFFFF; ride->excitement = 0xFFFF;
@ -6696,7 +6721,7 @@ void invalidate_test_results(int rideIndex)
*/ */
void ride_fix_breakdown(int rideIndex, int reliabilityIncreaseFactor) void ride_fix_breakdown(int rideIndex, int reliabilityIncreaseFactor)
{ {
rct_ride *ride = GET_RIDE(rideIndex); rct_ride *ride = get_ride(rideIndex);
ride->lifecycle_flags &= ~RIDE_LIFECYCLE_BREAKDOWN_PENDING; ride->lifecycle_flags &= ~RIDE_LIFECYCLE_BREAKDOWN_PENDING;
ride->lifecycle_flags &= ~RIDE_LIFECYCLE_BROKEN_DOWN; ride->lifecycle_flags &= ~RIDE_LIFECYCLE_BROKEN_DOWN;
@ -6735,7 +6760,7 @@ static void ride_update_vehicle_colours(int rideIndex)
uint16 spriteIndex; uint16 spriteIndex;
uint8 coloursExtended = 0; uint8 coloursExtended = 0;
ride = GET_RIDE(rideIndex); ride = get_ride(rideIndex);
if (ride->type == RIDE_TYPE_SPACE_RINGS || ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_16)) { if (ride->type == RIDE_TYPE_SPACE_RINGS || ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_16)) {
gfx_invalidate_screen(); gfx_invalidate_screen();
} }
@ -6776,7 +6801,7 @@ static void ride_update_vehicle_colours(int rideIndex)
*/ */
void ride_entry_get_train_layout(int rideEntryIndex, int numCarsPerTrain, uint8 *trainLayout) void ride_entry_get_train_layout(int rideEntryIndex, int numCarsPerTrain, uint8 *trainLayout)
{ {
rct_ride_type *rideEntry = GET_RIDE_ENTRY(rideEntryIndex); rct_ride_type *rideEntry = get_ride_entry(rideEntryIndex);
for (int i = 0; i < numCarsPerTrain; i++) { for (int i = 0; i < numCarsPerTrain; i++) {
uint8 vehicleType = rideEntry->default_vehicle; uint8 vehicleType = rideEntry->default_vehicle;
@ -6870,11 +6895,11 @@ void ride_update_max_vehicles(int rideIndex)
uint8 trainLayout[16], numCarsPerTrain, numVehicles; uint8 trainLayout[16], numCarsPerTrain, numVehicles;
int trainLength, maxNumTrains; int trainLength, maxNumTrains;
ride = GET_RIDE(rideIndex); ride = get_ride(rideIndex);
if (ride->subtype == 0xFF) if (ride->subtype == 0xFF)
return; return;
rideEntry = GET_RIDE_ENTRY(ride->subtype); rideEntry = get_ride_entry(ride->subtype);
if (rideEntry->cars_per_flat_ride == 0xFF) { if (rideEntry->cars_per_flat_ride == 0xFF) {
ride->num_cars_per_train = max(rideEntry->min_cars_in_train, ride->num_cars_per_train); ride->num_cars_per_train = max(rideEntry->min_cars_in_train, ride->num_cars_per_train);
ride->min_max_cars_per_train = rideEntry->max_cars_in_train | (rideEntry->min_cars_in_train << 4); ride->min_max_cars_per_train = rideEntry->max_cars_in_train | (rideEntry->min_cars_in_train << 4);
@ -7051,7 +7076,7 @@ void game_command_set_ride_vehicles(int *eax, int *ebx, int *ecx, int *edx, int
} }
value = (*edx >> 8) & 0xFF; value = (*edx >> 8) & 0xFF;
ride = GET_RIDE(rideIndex); ride = get_ride(rideIndex);
if (ride->type == RIDE_TYPE_NULL) if (ride->type == RIDE_TYPE_NULL)
{ {
log_warning("Invalid game command for ride %u", rideIndex); log_warning("Invalid game command for ride %u", rideIndex);
@ -7099,7 +7124,7 @@ void game_command_set_ride_vehicles(int *eax, int *ebx, int *ecx, int *edx, int
break; break;
case RIDE_SET_VEHICLES_COMMAND_TYPE_NUM_CARS_PER_TRAIN: case RIDE_SET_VEHICLES_COMMAND_TYPE_NUM_CARS_PER_TRAIN:
invalidate_test_results(rideIndex); invalidate_test_results(rideIndex);
rideEntry = GET_RIDE_ENTRY(ride->subtype); rideEntry = get_ride_entry(ride->subtype);
value = clamp(rideEntry->min_cars_in_train, value, rideEntry->max_cars_in_train); value = clamp(rideEntry->min_cars_in_train, value, rideEntry->max_cars_in_train);
ride->var_0CB = value; ride->var_0CB = value;
break; break;
@ -7255,7 +7280,7 @@ money32 place_ride_entrance_or_exit(sint16 x, sint16 y, sint16 z, uint8 directio
log_warning("Invalid game command for ride %u", rideIndex); log_warning("Invalid game command for ride %u", rideIndex);
return MONEY32_UNDEFINED; return MONEY32_UNDEFINED;
} }
rct_ride* ride = GET_RIDE(rideIndex); rct_ride* ride = get_ride(rideIndex);
if (ride->type == RIDE_TYPE_NULL) if (ride->type == RIDE_TYPE_NULL)
{ {
log_warning("Invalid game command for ride %u", rideIndex); log_warning("Invalid game command for ride %u", rideIndex);
@ -7413,7 +7438,7 @@ money32 remove_ride_entrance_or_exit(sint16 x, sint16 y, uint8 rideIndex, uint8
log_warning("Invalid game command for ride %u", rideIndex); log_warning("Invalid game command for ride %u", rideIndex);
return MONEY32_UNDEFINED; return MONEY32_UNDEFINED;
} }
rct_ride* ride = GET_RIDE(rideIndex); rct_ride* ride = get_ride(rideIndex);
if (ride->type == RIDE_TYPE_NULL) if (ride->type == RIDE_TYPE_NULL)
{ {
log_warning("Invalide ride id %u for entrance/exit removal", rideIndex); log_warning("Invalide ride id %u for entrance/exit removal", rideIndex);
@ -7510,7 +7535,7 @@ void ride_crash(uint8 rideIndex, uint8 vehicleIndex)
rct_vehicle *vehicle; rct_vehicle *vehicle;
rct_window *w; rct_window *w;
ride = GET_RIDE(rideIndex); ride = get_ride(rideIndex);
vehicle = GET_VEHICLE(ride->vehicles[vehicleIndex]); vehicle = GET_VEHICLE(ride->vehicles[vehicleIndex]);
if (!(RCT2_GLOBAL(RCT2_ADDRESS_SCREEN_FLAGS, uint8) & SCREEN_FLAGS_TITLE_DEMO)) { if (!(RCT2_GLOBAL(RCT2_ADDRESS_SCREEN_FLAGS, uint8) & SCREEN_FLAGS_TITLE_DEMO)) {

14
src/ride/ride.h
View File

@ -850,23 +850,17 @@ enum {
#define TURN_MASK_3_ELEMENTS 0x0700 #define TURN_MASK_3_ELEMENTS 0x0700
#define TURN_MASK_4_PLUS_ELEMENTS 0xF800 #define TURN_MASK_4_PLUS_ELEMENTS 0xF800
// rct2: 0x009ACFA4 (RCT2_ADDRESS_RIDE_ENTRIES)
extern rct_ride_type **gRideTypeList;
// rct2: 0x013628F8
extern rct_ride* g_ride_list;
/** Helper macros until rides are stored in this module. */ /** Helper macros until rides are stored in this module. */
#define GET_RIDE(x) (&g_ride_list[x]) rct_ride *get_ride(int index);
#define GET_RIDE_MEASUREMENT(x) (&(RCT2_ADDRESS(RCT2_ADDRESS_RIDE_MEASUREMENTS, rct_ride_measurement)[x])) rct_ride_type *get_ride_entry(int index);
#define GET_RIDE_ENTRY(x) gRideTypeList[x] rct_ride_measurement *get_ride_measurement(int index);
/** /**
* Helper macro loop for enumerating through all the non null rides. * Helper macro loop for enumerating through all the non null rides.
*/ */
#define FOR_ALL_RIDES(i, ride) \ #define FOR_ALL_RIDES(i, ride) \
for (i = 0; i < MAX_RIDES; i++) \ for (i = 0; i < MAX_RIDES; i++) \
if ((ride = &g_ride_list[i])->type != RIDE_TYPE_NULL) if ((ride = get_ride(i))->type != RIDE_TYPE_NULL)
extern const uint8 gRideClassifications[255]; extern const uint8 gRideClassifications[255];

14
src/ride/ride_ratings.c
View File

@ -137,7 +137,7 @@ static void ride_ratings_update_state_0()
if (_rideRatingsCurrentRide == 255) if (_rideRatingsCurrentRide == 255)
_rideRatingsCurrentRide = 0; _rideRatingsCurrentRide = 0;
ride = GET_RIDE(_rideRatingsCurrentRide); ride = get_ride(_rideRatingsCurrentRide);
if (ride->type != RIDE_TYPE_NULL && ride->status != RIDE_STATUS_CLOSED) if (ride->type != RIDE_TYPE_NULL && ride->status != RIDE_STATUS_CLOSED)
_rideRatingsState = RIDE_RATINGS_STATE_INITIALISE; _rideRatingsState = RIDE_RATINGS_STATE_INITIALISE;
} }
@ -170,7 +170,7 @@ static void ride_ratings_update_state_2()
rct_xy_element trackElement, nextTrackElement; rct_xy_element trackElement, nextTrackElement;
int x, y, z, trackType, entranceIndex; int x, y, z, trackType, entranceIndex;
ride = GET_RIDE(_rideRatingsCurrentRide); ride = get_ride(_rideRatingsCurrentRide);
if (ride->type == RIDE_TYPE_NULL || ride->status == RIDE_STATUS_CLOSED) { if (ride->type == RIDE_TYPE_NULL || ride->status == RIDE_STATUS_CLOSED) {
_rideRatingsState = RIDE_RATINGS_STATE_FIND_NEXT_RIDE; _rideRatingsState = RIDE_RATINGS_STATE_FIND_NEXT_RIDE;
return; return;
@ -233,7 +233,7 @@ static void ride_ratings_update_state_3()
{ {
rct_ride *ride; rct_ride *ride;
ride = GET_RIDE(_rideRatingsCurrentRide); ride = get_ride(_rideRatingsCurrentRide);
if (ride->type == RIDE_TYPE_NULL || ride->status == RIDE_STATUS_CLOSED) { if (ride->type == RIDE_TYPE_NULL || ride->status == RIDE_STATUS_CLOSED) {
_rideRatingsState = RIDE_RATINGS_STATE_FIND_NEXT_RIDE; _rideRatingsState = RIDE_RATINGS_STATE_FIND_NEXT_RIDE;
return; return;
@ -267,7 +267,7 @@ static void ride_ratings_update_state_5()
track_begin_end trackBeginEnd; track_begin_end trackBeginEnd;
int x, y, z, trackType; int x, y, z, trackType;
ride = GET_RIDE(_rideRatingsCurrentRide); ride = get_ride(_rideRatingsCurrentRide);
if (ride->type == RIDE_TYPE_NULL || ride->status == RIDE_STATUS_CLOSED) { if (ride->type == RIDE_TYPE_NULL || ride->status == RIDE_STATUS_CLOSED) {
_rideRatingsState = RIDE_RATINGS_STATE_FIND_NEXT_RIDE; _rideRatingsState = RIDE_RATINGS_STATE_FIND_NEXT_RIDE;
return; return;
@ -322,7 +322,7 @@ static void ride_ratings_begin_proximity_loop()
rct_ride *ride; rct_ride *ride;
int i, x, y, z; int i, x, y, z;
ride = GET_RIDE(_rideRatingsCurrentRide); ride = get_ride(_rideRatingsCurrentRide);
if (ride->type == RIDE_TYPE_NULL || ride->status == RIDE_STATUS_CLOSED) { if (ride->type == RIDE_TYPE_NULL || ride->status == RIDE_STATUS_CLOSED) {
_rideRatingsState = RIDE_RATINGS_STATE_FIND_NEXT_RIDE; _rideRatingsState = RIDE_RATINGS_STATE_FIND_NEXT_RIDE;
return; return;
@ -786,7 +786,7 @@ static void ride_ratings_apply_adjustments(rct_ride *ride, rating_tuple *ratings
{ {
rct_ride_type *rideEntry; rct_ride_type *rideEntry;
rideEntry = gRideTypeList[ride->subtype]; rideEntry = get_ride_entry(ride->subtype);
// Apply ride entry multipliers // Apply ride entry multipliers
ratings->excitement += ((ratings->excitement * rideEntry->excitement_multipler) >> 7); ratings->excitement += ((ratings->excitement * rideEntry->excitement_multipler) >> 7);
@ -920,7 +920,7 @@ static int sub_65E72D(rct_ride *ride)
} }
int dh = numShelteredEighths; int dh = numShelteredEighths;
rct_ride_type *rideType = GET_RIDE_ENTRY(ride->subtype); rct_ride_type *rideType = get_ride_entry(ride->subtype);
if (rideType->flags & RIDE_ENTRY_FLAG_COVERED_RIDE) if (rideType->flags & RIDE_ENTRY_FLAG_COVERED_RIDE)
numShelteredEighths = 7; numShelteredEighths = 7;

2
src/ride/station.c
View File

@ -250,7 +250,7 @@ static void ride_race_init_vehicle_speeds(rct_ride *ride)
vehicle = &g_sprite_list[ride->vehicles[i]].vehicle; vehicle = &g_sprite_list[ride->vehicles[i]].vehicle;
vehicle->update_flags &= ~VEHICLE_UPDATE_FLAG_6; vehicle->update_flags &= ~VEHICLE_UPDATE_FLAG_6;
rideEntry = GET_RIDE_ENTRY(vehicle->ride_subtype); rideEntry = get_ride_entry(vehicle->ride_subtype);
vehicle->speed = (scenario_rand() & 16) - 8 + rideEntry->vehicles[vehicle->vehicle_type].powered_max_speed; vehicle->speed = (scenario_rand() & 16) - 8 + rideEntry->vehicles[vehicle->vehicle_type].powered_max_speed;

36
src/ride/track.c
View File

@ -359,8 +359,8 @@ void track_list_populate(ride_list_item item, uint8* track_list_cache){
} }
else{ else{
if (find_object_in_entry_group(track_object, &entry_type, &entry_index)){ if (find_object_in_entry_group(track_object, &entry_type, &entry_index)){
if ((GET_RIDE_ENTRY(entry_index)->flags & (RIDE_ENTRY_FLAG_SEPARATE_RIDE_NAME | RIDE_ENTRY_FLAG_SEPARATE_RIDE)) && if ((get_ride_entry(entry_index)->flags & (RIDE_ENTRY_FLAG_SEPARATE_RIDE_NAME | RIDE_ENTRY_FLAG_SEPARATE_RIDE)) &&
!rideTypeShouldLoseSeparateFlag(GET_RIDE_ENTRY(entry_index))) !rideTypeShouldLoseSeparateFlag(get_ride_entry(entry_index)))
continue; continue;
} }
else{ else{
@ -408,7 +408,7 @@ void track_load_list(ride_list_item item)
RCT2_GLOBAL(0xF635ED, uint8) = 0; RCT2_GLOBAL(0xF635ED, uint8) = 0;
if (item.type < 0x80){ if (item.type < 0x80){
rct_ride_type* ride_type = gRideTypeList[item.entry_index]; rct_ride_type* ride_type = get_ride_entry(item.entry_index);
if (!(ride_type->flags & RIDE_ENTRY_FLAG_SEPARATE_RIDE) || rideTypeShouldLoseSeparateFlag(ride_type)){ if (!(ride_type->flags & RIDE_ENTRY_FLAG_SEPARATE_RIDE) || rideTypeShouldLoseSeparateFlag(ride_type)){
item.entry_index = 0xFF; item.entry_index = 0xFF;
} }
@ -1913,7 +1913,7 @@ int track_place_ride(sint16 x, sint16 y, sint16 z, uint8 rideIndex, uint8** trac
if (RCT2_GLOBAL(0x00F440D4, uint8) == 6){ if (RCT2_GLOBAL(0x00F440D4, uint8) == 6){
sub_6CB945(RCT2_GLOBAL(0x00F440A7, uint8)); sub_6CB945(RCT2_GLOBAL(0x00F440A7, uint8));
rct_ride* ride = GET_RIDE(RCT2_GLOBAL(0x00F440A7, uint8)); rct_ride* ride = get_ride(RCT2_GLOBAL(0x00F440A7, uint8));
user_string_free(ride->name); user_string_free(ride->name);
ride->type = RIDE_TYPE_NULL; ride->type = RIDE_TYPE_NULL;
} }
@ -2027,7 +2027,7 @@ int sub_6D2189(int* cost, uint8* ride_id){
// bh // bh
*ride_id = edi & 0xFF; *ride_id = edi & 0xFF;
rct_ride* ride = GET_RIDE(*ride_id); rct_ride* ride = get_ride(*ride_id);
const utf8* ride_name = RCT2_ADDRESS(0x9E3504, const utf8); const utf8* ride_name = RCT2_ADDRESS(0x9E3504, const utf8);
rct_string_id new_ride_name = user_string_allocate(132, ride_name); rct_string_id new_ride_name = user_string_allocate(132, ride_name);
@ -2104,7 +2104,7 @@ int sub_6D2189(int* cost, uint8* ride_id){
* rct2: 0x006D235B * rct2: 0x006D235B
*/ */
void sub_6D235B(uint8 ride_id){ void sub_6D235B(uint8 ride_id){
rct_ride* ride = GET_RIDE(ride_id); rct_ride* ride = get_ride(ride_id);
user_string_free(ride->name); user_string_free(ride->name);
ride->type = RIDE_TYPE_NULL; ride->type = RIDE_TYPE_NULL;
} }
@ -2572,7 +2572,7 @@ int maze_ride_to_td6(uint8 rideIndex, rct_track_td6* track_design, uint8* track_
x = 0; x = 0;
} }
rct_ride* ride = GET_RIDE(rideIndex); rct_ride* ride = get_ride(rideIndex);
uint16 location = ride->entrances[0]; uint16 location = ride->entrances[0];
if (location == 0xFFFF){ if (location == 0xFFFF){
@ -2673,7 +2673,7 @@ int maze_ride_to_td6(uint8 rideIndex, rct_track_td6* track_design, uint8* track_
*/ */
int tracked_ride_to_td6(uint8 rideIndex, rct_track_td6* track_design, uint8* track_elements) int tracked_ride_to_td6(uint8 rideIndex, rct_track_td6* track_design, uint8* track_elements)
{ {
rct_ride* ride = GET_RIDE(rideIndex); rct_ride* ride = get_ride(rideIndex);
rct_xy_element trackElement; rct_xy_element trackElement;
track_begin_end trackBeginEnd; track_begin_end trackBeginEnd;
@ -2933,7 +2933,7 @@ int tracked_ride_to_td6(uint8 rideIndex, rct_track_td6* track_design, uint8* tra
* rct2: 0x006CE44F * rct2: 0x006CE44F
*/ */
int ride_to_td6(uint8 rideIndex){ int ride_to_td6(uint8 rideIndex){
rct_ride* ride = GET_RIDE(rideIndex); rct_ride* ride = get_ride(rideIndex);
rct_track_td6* track_design = RCT2_ADDRESS(0x009D8178, rct_track_td6); rct_track_td6* track_design = RCT2_ADDRESS(0x009D8178, rct_track_td6);
track_design->type = ride->type; track_design->type = ride->type;
@ -3039,7 +3039,7 @@ int save_track_to_file(rct_track_td6* track_design, char* path)
* rct2: 0x006D2804, 0x006D264D * rct2: 0x006D2804, 0x006D264D
*/ */
int save_track_design(uint8 rideIndex){ int save_track_design(uint8 rideIndex){
rct_ride* ride = GET_RIDE(rideIndex); rct_ride* ride = get_ride(rideIndex);
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED)){ if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_TESTED)){
window_error_open(STR_CANT_SAVE_TRACK_DESIGN, RCT2_GLOBAL(RCT2_ADDRESS_GAME_COMMAND_ERROR_TEXT, rct_string_id)); window_error_open(STR_CANT_SAVE_TRACK_DESIGN, RCT2_GLOBAL(RCT2_ADDRESS_GAME_COMMAND_ERROR_TEXT, rct_string_id));
@ -3292,7 +3292,7 @@ void game_command_place_track_design(int* eax, int* ebx, int* ecx, int* edx, int
rideIndex = _edi & 0xFF; rideIndex = _edi & 0xFF;
} }
rct_ride* ride = GET_RIDE(rideIndex); rct_ride* ride = get_ride(rideIndex);
if (ride->type == RIDE_TYPE_NULL) if (ride->type == RIDE_TYPE_NULL)
{ {
log_warning("Invalid game command for track placement, ride id = %d", rideIndex); log_warning("Invalid game command for track placement, ride id = %d", rideIndex);
@ -3472,7 +3472,7 @@ money32 place_maze_design(uint8 flags, uint8 rideIndex, uint16 mazeEntry, sint16
} }
} }
rct_ride *ride = GET_RIDE(rideIndex); rct_ride *ride = get_ride(rideIndex);
// Calculate price // Calculate price
money32 price = 0; money32 price = 0;
@ -4067,7 +4067,7 @@ const rct_track_coordinates *get_track_coord_from_ride(rct_ride *ride, int track
const rct_preview_track *get_track_def_from_ride_index(int rideIndex, int trackType) const rct_preview_track *get_track_def_from_ride_index(int rideIndex, int trackType)
{ {
return get_track_def_from_ride(GET_RIDE(rideIndex), trackType); return get_track_def_from_ride(get_ride(rideIndex), trackType);
} }
/** /**
@ -4081,8 +4081,8 @@ static bool sub_6C4D89(int x, int y, int z, int direction, int rideIndex, int fl
static money32 track_place(int rideIndex, int type, int originX, int originY, int originZ, int direction, int properties_1, int properties_2, int properties_3, int edx_flags, int flags) static money32 track_place(int rideIndex, int type, int originX, int originY, int originZ, int direction, int properties_1, int properties_2, int properties_3, int edx_flags, int flags)
{ {
rct_ride *ride = GET_RIDE(rideIndex); rct_ride *ride = get_ride(rideIndex);
rct_ride_type *rideEntry = GET_RIDE_ENTRY(ride->subtype); rct_ride_type *rideEntry = get_ride_entry(ride->subtype);
rct_map_element *mapElement; rct_map_element *mapElement;
RCT2_GLOBAL(RCT2_ADDRESS_NEXT_EXPENDITURE_TYPE, uint8) = RCT_EXPENDITURE_TYPE_RIDE_CONSTRUCTION * 4; RCT2_GLOBAL(RCT2_ADDRESS_NEXT_EXPENDITURE_TYPE, uint8) = RCT_EXPENDITURE_TYPE_RIDE_CONSTRUCTION * 4;
@ -4673,7 +4673,7 @@ money32 track_remove(uint8 type, uint8 sequence, sint16 originX, sint16 originY,
RCT2_GLOBAL(0x00F44138, uint8) = rideIndex; RCT2_GLOBAL(0x00F44138, uint8) = rideIndex;
RCT2_GLOBAL(0x00F4414C, uint8) = mapElement->type; RCT2_GLOBAL(0x00F4414C, uint8) = mapElement->type;
rct_ride* ride = GET_RIDE(rideIndex); rct_ride* ride = get_ride(rideIndex);
const rct_preview_track* trackBlock = get_track_def_from_ride(ride, type); const rct_preview_track* trackBlock = get_track_def_from_ride(ride, type);
trackBlock += mapElement->properties.track.sequence & 0xF; trackBlock += mapElement->properties.track.sequence & 0xF;
@ -5082,7 +5082,7 @@ void track_element_clear_cable_lift(rct_map_element *trackElement) {
int track_get_actual_bank(rct_map_element *mapElement, int bank) int track_get_actual_bank(rct_map_element *mapElement, int bank)
{ {
rct_ride *ride = GET_RIDE(mapElement->properties.track.ride_index); rct_ride *ride = get_ride(mapElement->properties.track.ride_index);
int trackColour = mapElement->properties.track.colour; int trackColour = mapElement->properties.track.colour;
return track_get_actual_bank_2(ride->type, trackColour, bank); return track_get_actual_bank_2(ride->type, trackColour, bank);
} }
@ -5105,7 +5105,7 @@ int track_get_actual_bank_3(rct_vehicle *vehicle, rct_map_element *mapElement)
{ {
uint8 colourThingToXor = (vehicle->update_flags >> 9) & 0xFF; uint8 colourThingToXor = (vehicle->update_flags >> 9) & 0xFF;
int trackType = mapElement->properties.track.type; int trackType = mapElement->properties.track.type;
int rideType = GET_RIDE(mapElement->properties.track.ride_index)->type; int rideType = get_ride(mapElement->properties.track.ride_index)->type;
int trackColour = mapElement->properties.track.colour ^ colourThingToXor; int trackColour = mapElement->properties.track.colour ^ colourThingToXor;
int bankStart = gTrackDefinitions[trackType].bank_start; int bankStart = gTrackDefinitions[trackType].bank_start;
return track_get_actual_bank_2(rideType, trackColour, bankStart); return track_get_actual_bank_2(rideType, trackColour, bankStart);

28
src/ride/track_paint.c
View File

@ -104,8 +104,8 @@ static void top_spin_paint_vehicle(sint8 al, sint8 cl, uint8 rideIndex, uint8 di
height += 3; height += 3;
rct_ride* ride = GET_RIDE(rideIndex); rct_ride* ride = get_ride(rideIndex);
rct_ride_type* rideEntry = GET_RIDE_ENTRY(ride->subtype); rct_ride_type* rideEntry = get_ride_entry(ride->subtype);
rct_vehicle* vehicle = NULL; rct_vehicle* vehicle = NULL;
uint8 seatRotation = 0; uint8 seatRotation = 0;
@ -357,7 +357,7 @@ static void top_spin_paint_tile_1(uint8 rideIndex, uint8 trackSequence, uint8 di
(((y / 32) + loc_7667AE[get_current_rotation()].y) << 8); (((y / 32) + loc_7667AE[get_current_rotation()].y) << 8);
uint8 entranceId = (mapElement->properties.track.sequence & 0x70) >> 4; uint8 entranceId = (mapElement->properties.track.sequence & 0x70) >> 4;
rct_ride* ride = GET_RIDE(rideIndex); rct_ride* ride = get_ride(rideIndex);
if (ride->entrances[entranceId] != entranceLoc && ride->exits[entranceId] != entranceLoc) { if (ride->entrances[entranceId] != entranceLoc && ride->exits[entranceId] != entranceLoc) {
@ -426,7 +426,7 @@ static void top_spin_paint_tile_2(uint8 rideIndex, uint8 trackSequence, uint8 di
(((y / 32) + loc_7667AC[get_current_rotation()].y) << 8); (((y / 32) + loc_7667AC[get_current_rotation()].y) << 8);
uint8 entranceId = (mapElement->properties.track.sequence & 0x70) >> 4; uint8 entranceId = (mapElement->properties.track.sequence & 0x70) >> 4;
rct_ride* ride = GET_RIDE(rideIndex); rct_ride* ride = get_ride(rideIndex);
if (ride->entrances[entranceId] != entranceLoc && ride->exits[entranceId] != entranceLoc) { if (ride->entrances[entranceId] != entranceLoc && ride->exits[entranceId] != entranceLoc) {
@ -476,7 +476,7 @@ static void top_spin_paint_tile_4(uint8 rideIndex, uint8 trackSequence, uint8 di
(((y / 32) + loc_7667AE[get_current_rotation()].y) << 8); (((y / 32) + loc_7667AE[get_current_rotation()].y) << 8);
uint8 entranceId = (mapElement->properties.track.sequence & 0x70) >> 4; uint8 entranceId = (mapElement->properties.track.sequence & 0x70) >> 4;
rct_ride* ride = GET_RIDE(rideIndex); rct_ride* ride = get_ride(rideIndex);
if (ride->entrances[entranceId] != entranceLoc && ride->exits[entranceId] != entranceLoc) { if (ride->entrances[entranceId] != entranceLoc && ride->exits[entranceId] != entranceLoc) {
@ -526,7 +526,7 @@ static void top_spin_paint_tile_3(uint8 rideIndex, uint8 trackSequence, uint8 di
(((y / 32) + loc_7667AC[get_current_rotation()].y) << 8); (((y / 32) + loc_7667AC[get_current_rotation()].y) << 8);
uint8 entranceId = (mapElement->properties.track.sequence & 0x70) >> 4; uint8 entranceId = (mapElement->properties.track.sequence & 0x70) >> 4;
rct_ride* ride = GET_RIDE(rideIndex); rct_ride* ride = get_ride(rideIndex);
if (ride->entrances[entranceId] != entranceLoc && ride->exits[entranceId] != entranceLoc) { if (ride->entrances[entranceId] != entranceLoc && ride->exits[entranceId] != entranceLoc) {
@ -591,7 +591,7 @@ static void top_spin_paint_tile_5(uint8 rideIndex, uint8 trackSequence, uint8 di
sint16 x = RCT2_GLOBAL(0x009DE56A, sint16), y = RCT2_GLOBAL(0x009DE56E, sint16); sint16 x = RCT2_GLOBAL(0x009DE56A, sint16), y = RCT2_GLOBAL(0x009DE56E, sint16);
uint8 entranceId = (mapElement->properties.track.sequence & 0x70) >> 4; uint8 entranceId = (mapElement->properties.track.sequence & 0x70) >> 4;
rct_ride* ride = GET_RIDE(rideIndex); rct_ride* ride = get_ride(rideIndex);
uint16 entranceLoc = uint16 entranceLoc =
((x / 32) + loc_7667AC[(get_current_rotation() + 3) & 3].x) | ((x / 32) + loc_7667AC[(get_current_rotation() + 3) & 3].x) |
@ -646,7 +646,7 @@ static void top_spin_paint_tile_6(uint8 rideIndex, uint8 trackSequence, uint8 di
(((y / 32) + loc_7667AE[get_current_rotation()].y) << 8); (((y / 32) + loc_7667AE[get_current_rotation()].y) << 8);
uint8 entranceId = (mapElement->properties.track.sequence & 0x70) >> 4; uint8 entranceId = (mapElement->properties.track.sequence & 0x70) >> 4;
rct_ride* ride = GET_RIDE(rideIndex); rct_ride* ride = get_ride(rideIndex);
if (ride->entrances[entranceId] != entranceLoc && ride->exits[entranceId] != entranceLoc) { if (ride->entrances[entranceId] != entranceLoc && ride->exits[entranceId] != entranceLoc) {
@ -711,7 +711,7 @@ static void top_spin_paint_tile_7(uint8 rideIndex, uint8 trackSequence, uint8 di
sint16 x = RCT2_GLOBAL(0x009DE56A, sint16), y = RCT2_GLOBAL(0x009DE56E, sint16); sint16 x = RCT2_GLOBAL(0x009DE56A, sint16), y = RCT2_GLOBAL(0x009DE56E, sint16);
uint8 entranceId = (mapElement->properties.track.sequence & 0x70) >> 4; uint8 entranceId = (mapElement->properties.track.sequence & 0x70) >> 4;
rct_ride* ride = GET_RIDE(rideIndex); rct_ride* ride = get_ride(rideIndex);
uint16 entranceLoc = uint16 entranceLoc =
((x / 32) + loc_7667AE[(get_current_rotation() + 1) & 3].x) | ((x / 32) + loc_7667AE[(get_current_rotation() + 1) & 3].x) |
@ -780,7 +780,7 @@ static void top_spin_paint_tile_8(uint8 rideIndex, uint8 trackSequence, uint8 di
sint16 x = RCT2_GLOBAL(0x009DE56A, sint16), y = RCT2_GLOBAL(0x009DE56E, sint16); sint16 x = RCT2_GLOBAL(0x009DE56A, sint16), y = RCT2_GLOBAL(0x009DE56E, sint16);
uint8 entranceId = (mapElement->properties.track.sequence & 0x70) >> 4; uint8 entranceId = (mapElement->properties.track.sequence & 0x70) >> 4;
rct_ride* ride = GET_RIDE(rideIndex); rct_ride* ride = get_ride(rideIndex);
uint16 entranceLoc = uint16 entranceLoc =
((x / 32) + loc_7667AE[(get_current_rotation() + 1) & 3].x) | ((x / 32) + loc_7667AE[(get_current_rotation() + 1) & 3].x) |
@ -1003,8 +1003,8 @@ static void shop_paint_setup(uint8 rideIndex, uint8 trackSequence, uint8 directi
RCT2_GLOBAL(0x0141E9C8, sint16) = -1; RCT2_GLOBAL(0x0141E9C8, sint16) = -1;
RCT2_GLOBAL(0x0141E9D4, sint16) = -1; RCT2_GLOBAL(0x0141E9D4, sint16) = -1;
rct_ride *ride = GET_RIDE(rideIndex); rct_ride *ride = get_ride(rideIndex);
rct_ride_type *rideEntry = GET_RIDE_ENTRY(ride->subtype); rct_ride_type *rideEntry = get_ride_entry(ride->subtype);
rct_ride_type_vehicle *firstVehicleEntry = &rideEntry->vehicles[0]; rct_ride_type_vehicle *firstVehicleEntry = &rideEntry->vehicles[0];
uint32 imageId = RCT2_GLOBAL(0x00F44198, uint32); uint32 imageId = RCT2_GLOBAL(0x00F44198, uint32);
@ -1074,8 +1074,8 @@ static void facility_paint_setup(uint8 rideIndex, uint8 trackSequence, uint8 dir
RCT2_GLOBAL(0x0141E9C8, sint16) = -1; RCT2_GLOBAL(0x0141E9C8, sint16) = -1;
RCT2_GLOBAL(0x0141E9D4, sint16) = -1; RCT2_GLOBAL(0x0141E9D4, sint16) = -1;
rct_ride *ride = GET_RIDE(rideIndex); rct_ride *ride = get_ride(rideIndex);
rct_ride_type *rideEntry = GET_RIDE_ENTRY(ride->subtype); rct_ride_type *rideEntry = get_ride_entry(ride->subtype);
rct_ride_type_vehicle *firstVehicleEntry = &rideEntry->vehicles[0]; rct_ride_type_vehicle *firstVehicleEntry = &rideEntry->vehicles[0];
uint32 imageId = RCT2_GLOBAL(0x00F44198, uint32); uint32 imageId = RCT2_GLOBAL(0x00F44198, uint32);

128
src/ride/vehicle.c
View File

@ -226,7 +226,7 @@ void vehicle_update_sound_params(rct_vehicle* vehicle)
sint32 v19 = vehicle->velocity; sint32 v19 = vehicle->velocity;
rct_ride_type* ride_type = GET_RIDE_ENTRY(vehicle->ride_subtype); rct_ride_type* ride_type = get_ride_entry(vehicle->ride_subtype);
uint8 test = ride_type->vehicles[vehicle->vehicle_type].var_5A; uint8 test = ride_type->vehicles[vehicle->vehicle_type].var_5A;
if (test & 1) { if (test & 1) {
@ -584,7 +584,7 @@ void vehicle_update_all()
* @returns 0 when all closed * @returns 0 when all closed
*/ */
static int vehicle_close_restraints(rct_vehicle* vehicle){ static int vehicle_close_restraints(rct_vehicle* vehicle){
rct_ride* ride = GET_RIDE(vehicle->ride); rct_ride* ride = get_ride(vehicle->ride);
int ebp = 0; int ebp = 0;
uint16 vehicle_id = vehicle->sprite_index; uint16 vehicle_id = vehicle->sprite_index;
@ -646,8 +646,8 @@ static int vehicle_open_restraints(rct_vehicle* vehicle){
vehicle->var_4E = 0; vehicle->var_4E = 0;
vehicle->var_4A = 0; vehicle->var_4A = 0;
rct_ride* ride = GET_RIDE(vehicle->ride); rct_ride* ride = get_ride(vehicle->ride);
rct_ride_type* rideEntry = GET_RIDE_ENTRY(vehicle->ride_subtype); rct_ride_type* rideEntry = get_ride_entry(vehicle->ride_subtype);
rct_ride_type_vehicle* vehicleEntry = &rideEntry->vehicles[vehicle->vehicle_type]; rct_ride_type_vehicle* vehicleEntry = &rideEntry->vehicles[vehicle->vehicle_type];
if (vehicleEntry->flags_b & VEHICLE_ENTRY_FLAG_B_SPINNING) { if (vehicleEntry->flags_b & VEHICLE_ENTRY_FLAG_B_SPINNING) {
@ -737,7 +737,7 @@ static void vehicle_update_measurements(rct_vehicle *vehicle)
{ {
rct_ride *ride; rct_ride *ride;
ride = GET_RIDE(vehicle->ride); ride = get_ride(vehicle->ride);
if (vehicle->status == VEHICLE_STATUS_TRAVELLING_BOAT){ if (vehicle->status == VEHICLE_STATUS_TRAVELLING_BOAT){
ride->lifecycle_flags |= RIDE_LIFECYCLE_TESTED; ride->lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
@ -1091,11 +1091,11 @@ static void vehicle_update(rct_vehicle *vehicle)
return; return;
} }
rideEntry = GET_RIDE_ENTRY(vehicle->ride_subtype); rideEntry = get_ride_entry(vehicle->ride_subtype);
rct_ride_type_vehicle* vehicleEntry = &rideEntry->vehicles[vehicle->vehicle_type]; rct_ride_type_vehicle* vehicleEntry = &rideEntry->vehicles[vehicle->vehicle_type];
ride = GET_RIDE(vehicle->ride); ride = get_ride(vehicle->ride);
if (vehicle->update_flags & VEHICLE_UPDATE_FLAG_TESTING) if (vehicle->update_flags & VEHICLE_UPDATE_FLAG_TESTING)
vehicle_update_measurements(vehicle); vehicle_update_measurements(vehicle);
@ -1193,7 +1193,7 @@ static void vehicle_update(rct_vehicle *vehicle)
* rct2: 0x006D7BCC * rct2: 0x006D7BCC
*/ */
static void vehicle_update_moving_to_end_of_station(rct_vehicle *vehicle){ static void vehicle_update_moving_to_end_of_station(rct_vehicle *vehicle){
rct_ride* ride = GET_RIDE(vehicle->ride); rct_ride* ride = get_ride(vehicle->ride);
int eax, ebx; int eax, ebx;
switch (ride->mode){ switch (ride->mode){
@ -1239,7 +1239,7 @@ static void vehicle_update_moving_to_end_of_station(rct_vehicle *vehicle){
break; break;
default: default:
{ {
rct_ride_type* rideEntry = GET_RIDE_ENTRY(vehicle->ride_subtype); rct_ride_type* rideEntry = get_ride_entry(vehicle->ride_subtype);
rct_ride_type_vehicle* vehicleEntry = &rideEntry->vehicles[vehicle->vehicle_type]; rct_ride_type_vehicle* vehicleEntry = &rideEntry->vehicles[vehicle->vehicle_type];
if (!(vehicleEntry->flags_b & VEHICLE_ENTRY_FLAG_B_3)){ if (!(vehicleEntry->flags_b & VEHICLE_ENTRY_FLAG_B_3)){
@ -1297,7 +1297,7 @@ static void train_ready_to_depart(rct_vehicle* vehicle, uint8 num_peeps_on_train
if (num_peeps_on_train != num_used_seats) if (num_peeps_on_train != num_used_seats)
return; return;
rct_ride* ride = GET_RIDE(vehicle->ride); rct_ride* ride = get_ride(vehicle->ride);
if (ride->status == RIDE_STATUS_OPEN && if (ride->status == RIDE_STATUS_OPEN &&
!(ride->lifecycle_flags & RIDE_LIFECYCLE_BROKEN_DOWN) && !(ride->lifecycle_flags & RIDE_LIFECYCLE_BROKEN_DOWN) &&
@ -1350,7 +1350,7 @@ static void train_ready_to_depart(rct_vehicle* vehicle, uint8 num_peeps_on_train
static void vehicle_update_waiting_for_passengers(rct_vehicle* vehicle){ static void vehicle_update_waiting_for_passengers(rct_vehicle* vehicle){
vehicle->velocity = 0; vehicle->velocity = 0;
rct_ride* ride = GET_RIDE(vehicle->ride); rct_ride* ride = get_ride(vehicle->ride);
if (vehicle->sub_state == 0){ if (vehicle->sub_state == 0){
if (vehicle_open_restraints(vehicle)) if (vehicle_open_restraints(vehicle))
@ -1529,8 +1529,8 @@ static void vehicle_update_waiting_for_passengers(rct_vehicle* vehicle){
* rct2: 0x006D91BF * rct2: 0x006D91BF
*/ */
static void vehicle_update_bumpcar_mode(rct_vehicle* vehicle) { static void vehicle_update_bumpcar_mode(rct_vehicle* vehicle) {
rct_ride* ride = GET_RIDE(vehicle->ride); rct_ride* ride = get_ride(vehicle->ride);
rct_ride_type* rideEntry = GET_RIDE_ENTRY(vehicle->ride_subtype); rct_ride_type* rideEntry = get_ride_entry(vehicle->ride_subtype);
rct_ride_type_vehicle* vehicleEntry = &rideEntry->vehicles[vehicle->vehicle_type]; rct_ride_type_vehicle* vehicleEntry = &rideEntry->vehicles[vehicle->vehicle_type];
if (vehicleEntry->flags_a & VEHICLE_ENTRY_FLAG_A_7 && vehicle->var_C5 != 1) { if (vehicleEntry->flags_a & VEHICLE_ENTRY_FLAG_A_7 && vehicle->var_C5 != 1) {
@ -1562,7 +1562,7 @@ static void vehicle_update_bumpcar_mode(rct_vehicle* vehicle) {
* rct2: 0x006D80BE * rct2: 0x006D80BE
*/ */
static void vehicle_update_waiting_to_depart(rct_vehicle* vehicle) { static void vehicle_update_waiting_to_depart(rct_vehicle* vehicle) {
rct_ride* ride = GET_RIDE(vehicle->ride); rct_ride* ride = get_ride(vehicle->ride);
bool shouldBreak = false; bool shouldBreak = false;
if (ride->lifecycle_flags & RIDE_LIFECYCLE_BROKEN_DOWN) { if (ride->lifecycle_flags & RIDE_LIFECYCLE_BROKEN_DOWN) {
switch (ride->breakdown_reason_pending) { switch (ride->breakdown_reason_pending) {
@ -1820,7 +1820,7 @@ static bool try_add_synchronised_station(int x, int y, int z)
} }
int rideIndex = mapElement->properties.track.ride_index; int rideIndex = mapElement->properties.track.ride_index;
rct_ride *ride = GET_RIDE(rideIndex); rct_ride *ride = get_ride(rideIndex);
if (!(ride->depart_flags & RIDE_DEPART_SYNCHRONISE_WITH_ADJACENT_STATIONS)) { if (!(ride->depart_flags & RIDE_DEPART_SYNCHRONISE_WITH_ADJACENT_STATIONS)) {
return false; return false;
} }
@ -1861,7 +1861,7 @@ static bool try_add_synchronised_station(int x, int y, int z)
*/ */
static bool vehicle_can_depart_synchronised(rct_vehicle *vehicle) static bool vehicle_can_depart_synchronised(rct_vehicle *vehicle)
{ {
rct_ride *ride = GET_RIDE(vehicle->ride); rct_ride *ride = get_ride(vehicle->ride);
int station = vehicle->current_station; int station = vehicle->current_station;
uint16 xy = ride->station_starts[station]; uint16 xy = ride->station_starts[station];
int x = (xy & 0xFF) * 32; int x = (xy & 0xFF) * 32;
@ -1907,7 +1907,7 @@ static bool vehicle_can_depart_synchronised(rct_vehicle *vehicle)
} }
} }
ride = GET_RIDE(rideId); ride = get_ride(rideId);
for (int i = 0; i < ride->num_vehicles; i++) { for (int i = 0; i < ride->num_vehicles; i++) {
rct_vehicle *v = GET_VEHICLE(ride->vehicles[i]); rct_vehicle *v = GET_VEHICLE(ride->vehicles[i]);
if (v->status != VEHICLE_STATUS_WAITING_TO_DEPART && v->velocity != 0) { if (v->status != VEHICLE_STATUS_WAITING_TO_DEPART && v->velocity != 0) {
@ -1931,7 +1931,7 @@ static bool vehicle_can_depart_synchronised(rct_vehicle *vehicle)
return true; return true;
} }
ride = GET_RIDE(someRideIndex); ride = get_ride(someRideIndex);
int numAdjacentTrainsAtStation = 0; int numAdjacentTrainsAtStation = 0;
int numTravelingTrains = 0; int numTravelingTrains = 0;
int currentStation = vehicle->current_station; int currentStation = vehicle->current_station;
@ -1998,7 +1998,7 @@ void vehicle_peep_easteregg_here_we_are(rct_vehicle* vehicle) {
* rct2: 0x006D7338 * rct2: 0x006D7338
*/ */
void vehicle_update_test_finish(rct_vehicle* vehicle) { void vehicle_update_test_finish(rct_vehicle* vehicle) {
rct_ride* ride = GET_RIDE(vehicle->ride); rct_ride* ride = get_ride(vehicle->ride);
ride->lifecycle_flags &= ~RIDE_LIFECYCLE_TEST_IN_PROGRESS; ride->lifecycle_flags &= ~RIDE_LIFECYCLE_TEST_IN_PROGRESS;
vehicle->update_flags &= ~VEHICLE_UPDATE_FLAG_TESTING; vehicle->update_flags &= ~VEHICLE_UPDATE_FLAG_TESTING;
ride->lifecycle_flags |= RIDE_LIFECYCLE_TESTED; ride->lifecycle_flags |= RIDE_LIFECYCLE_TESTED;
@ -2034,7 +2034,7 @@ void vehicle_update_test_finish(rct_vehicle* vehicle) {
void vehicle_test_reset(rct_vehicle* vehicle) { void vehicle_test_reset(rct_vehicle* vehicle) {
vehicle->update_flags |= VEHICLE_UPDATE_FLAG_TESTING; vehicle->update_flags |= VEHICLE_UPDATE_FLAG_TESTING;
rct_ride* ride = GET_RIDE(vehicle->ride); rct_ride* ride = get_ride(vehicle->ride);
ride->lifecycle_flags |= RIDE_LIFECYCLE_TEST_IN_PROGRESS; ride->lifecycle_flags |= RIDE_LIFECYCLE_TEST_IN_PROGRESS;
ride->lifecycle_flags &= ~RIDE_LIFECYCLE_NO_RAW_STATS; ride->lifecycle_flags &= ~RIDE_LIFECYCLE_NO_RAW_STATS;
ride->max_speed = 0; ride->max_speed = 0;
@ -2127,7 +2127,7 @@ static void vehicle_update_travelling_boat_hire_setup(rct_vehicle* vehicle) {
*/ */
static void vehicle_update_departing_boat_hire(rct_vehicle* vehicle) { static void vehicle_update_departing_boat_hire(rct_vehicle* vehicle) {
vehicle->lost_time_out = 0; vehicle->lost_time_out = 0;
rct_ride* ride = GET_RIDE(vehicle->ride); rct_ride* ride = get_ride(vehicle->ride);
ride->station_depart[vehicle->current_station] &= STATION_DEPART_FLAG; ride->station_depart[vehicle->current_station] &= STATION_DEPART_FLAG;
uint8 waitingTime = max(ride->min_waiting_time, 3); uint8 waitingTime = max(ride->min_waiting_time, 3);
@ -2141,8 +2141,8 @@ static void vehicle_update_departing_boat_hire(rct_vehicle* vehicle) {
* rct2: 0x006D845B * rct2: 0x006D845B
*/ */
static void vehicle_update_departing(rct_vehicle* vehicle) { static void vehicle_update_departing(rct_vehicle* vehicle) {
rct_ride* ride = GET_RIDE(vehicle->ride); rct_ride* ride = get_ride(vehicle->ride);
rct_ride_type* rideEntry = GET_RIDE_ENTRY(vehicle->ride_subtype); rct_ride_type* rideEntry = get_ride_entry(vehicle->ride_subtype);
if (vehicle->sub_state == 0) { if (vehicle->sub_state == 0) {
if (vehicle->update_flags & VEHICLE_UPDATE_FLAG_BROKEN_TRAIN) { if (vehicle->update_flags & VEHICLE_UPDATE_FLAG_BROKEN_TRAIN) {
@ -2354,7 +2354,7 @@ static void vehicle_update_departing(rct_vehicle* vehicle) {
* rct2: 0x006D8858 * rct2: 0x006D8858
*/ */
static void vehicle_finish_departing(rct_vehicle* vehicle) { static void vehicle_finish_departing(rct_vehicle* vehicle) {
rct_ride* ride = GET_RIDE(vehicle->ride); rct_ride* ride = get_ride(vehicle->ride);
if (ride->mode == RIDE_MODE_DOWNWARD_LAUNCH ) { if (ride->mode == RIDE_MODE_DOWNWARD_LAUNCH ) {
if (vehicle->var_CE >= 1 && (14 << 16) > vehicle->velocity) if (vehicle->var_CE >= 1 && (14 << 16) > vehicle->velocity)
@ -2406,7 +2406,7 @@ static void vehicle_finish_departing(rct_vehicle* vehicle) {
* rct2: 0x006DE5CB * rct2: 0x006DE5CB
*/ */
static void vehicle_check_if_missing(rct_vehicle* vehicle) { static void vehicle_check_if_missing(rct_vehicle* vehicle) {
rct_ride* ride = GET_RIDE(vehicle->ride); rct_ride* ride = get_ride(vehicle->ride);
if (ride->lifecycle_flags & (RIDE_LIFECYCLE_BROKEN_DOWN | RIDE_LIFECYCLE_CRASHED)) if (ride->lifecycle_flags & (RIDE_LIFECYCLE_BROKEN_DOWN | RIDE_LIFECYCLE_CRASHED))
return; return;
@ -2456,7 +2456,7 @@ static void vehicle_update_collision_setup(rct_vehicle* vehicle) {
vehicle->status = VEHICLE_STATUS_CRASHED; vehicle->status = VEHICLE_STATUS_CRASHED;
vehicle_invalidate_window(vehicle); vehicle_invalidate_window(vehicle);
rct_ride* ride = GET_RIDE(vehicle->ride); rct_ride* ride = get_ride(vehicle->ride);
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_CRASHED)) { if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_CRASHED)) {
rct_vehicle* frontVehicle = vehicle; rct_vehicle* frontVehicle = vehicle;
while (frontVehicle->is_child != 0)frontVehicle = GET_VEHICLE(frontVehicle->prev_vehicle_on_ride); while (frontVehicle->is_child != 0)frontVehicle = GET_VEHICLE(frontVehicle->prev_vehicle_on_ride);
@ -2593,7 +2593,7 @@ static void vehicle_update_crash_setup(rct_vehicle* vehicle) {
static void vehicle_update_travelling(rct_vehicle* vehicle) { static void vehicle_update_travelling(rct_vehicle* vehicle) {
vehicle_check_if_missing(vehicle); vehicle_check_if_missing(vehicle);
rct_ride* ride = GET_RIDE(vehicle->ride); rct_ride* ride = get_ride(vehicle->ride);
if (RCT2_GLOBAL(0x00F64E34, uint8) == 0 && ride->mode == RIDE_MODE_ROTATING_LIFT) if (RCT2_GLOBAL(0x00F64E34, uint8) == 0 && ride->mode == RIDE_MODE_ROTATING_LIFT)
return; return;
@ -2763,7 +2763,7 @@ static void vehicle_update_travelling(rct_vehicle* vehicle) {
*/ */
static void vehicle_update_arriving(rct_vehicle* vehicle) { static void vehicle_update_arriving(rct_vehicle* vehicle) {
RCT2_GLOBAL(0x00F64E35, uint8) = 1; RCT2_GLOBAL(0x00F64E35, uint8) = 1;
rct_ride* ride = GET_RIDE(vehicle->ride); rct_ride* ride = get_ride(vehicle->ride);
switch (ride->mode) { switch (ride->mode) {
case RIDE_MODE_SWING: case RIDE_MODE_SWING:
@ -2797,7 +2797,7 @@ static void vehicle_update_arriving(rct_vehicle* vehicle) {
ride->mechanic_status != RIDE_MECHANIC_STATUS_4) ride->mechanic_status != RIDE_MECHANIC_STATUS_4)
RCT2_GLOBAL(0x00F64E35, uint8) = 0; RCT2_GLOBAL(0x00F64E35, uint8) = 0;
rct_ride_type* rideEntry = GET_RIDE_ENTRY(vehicle->ride_subtype); rct_ride_type* rideEntry = get_ride_entry(vehicle->ride_subtype);
rct_ride_type_vehicle* vehicleEntry = &rideEntry->vehicles[vehicle->vehicle_type]; rct_ride_type_vehicle* vehicleEntry = &rideEntry->vehicles[vehicle->vehicle_type];
if (vehicle->sub_state == 0) { if (vehicle->sub_state == 0) {
@ -2977,7 +2977,7 @@ static void vehicle_update_unloading_passengers(rct_vehicle* vehicle) {
} }
} }
rct_ride* ride = GET_RIDE(vehicle->ride); rct_ride* ride = get_ride(vehicle->ride);
if (ride->mode == RIDE_MODE_FORWARD_ROTATION || if (ride->mode == RIDE_MODE_FORWARD_ROTATION ||
ride->mode == RIDE_MODE_BACKWARD_ROTATION) { ride->mode == RIDE_MODE_BACKWARD_ROTATION) {
uint8 seat = ((-vehicle->var_1F) >> 3) & 0xF; uint8 seat = ((-vehicle->var_1F) >> 3) & 0xF;
@ -3064,7 +3064,7 @@ static void vehicle_update_unloading_passengers(rct_vehicle* vehicle) {
*/ */
static void vehicle_update_waiting_for_cable_lift(rct_vehicle *vehicle) static void vehicle_update_waiting_for_cable_lift(rct_vehicle *vehicle)
{ {
rct_ride* ride = GET_RIDE(vehicle->ride); rct_ride* ride = get_ride(vehicle->ride);
rct_vehicle* cableLift = GET_VEHICLE(ride->cable_lift); rct_vehicle* cableLift = GET_VEHICLE(ride->cable_lift);
@ -3080,7 +3080,7 @@ static void vehicle_update_waiting_for_cable_lift(rct_vehicle *vehicle)
* rct2: 0x006D9D21 * rct2: 0x006D9D21
*/ */
static void vehicle_update_travelling_cable_lift(rct_vehicle* vehicle) { static void vehicle_update_travelling_cable_lift(rct_vehicle* vehicle) {
rct_ride* ride = GET_RIDE(vehicle->ride); rct_ride* ride = get_ride(vehicle->ride);
if (vehicle->sub_state == 0) { if (vehicle->sub_state == 0) {
if (vehicle->update_flags & VEHICLE_UPDATE_FLAG_BROKEN_TRAIN) { if (vehicle->update_flags & VEHICLE_UPDATE_FLAG_BROKEN_TRAIN) {
@ -3119,7 +3119,7 @@ static void vehicle_update_travelling_cable_lift(rct_vehicle* vehicle) {
} }
} }
rct_ride_type* rideEntry = GET_RIDE_ENTRY(vehicle->ride_subtype); rct_ride_type* rideEntry = get_ride_entry(vehicle->ride_subtype);
rct_ride_type_vehicle* vehicleEntry = &rideEntry->vehicles[vehicle->vehicle_type]; rct_ride_type_vehicle* vehicleEntry = &rideEntry->vehicles[vehicle->vehicle_type];
if (vehicle->velocity <= 439800) { if (vehicle->velocity <= 439800) {
@ -3181,7 +3181,7 @@ static void loc_6DA9F9(rct_vehicle *vehicle, int x, int y, int bx, int dx)
vehicle->track_z >> 3 vehicle->track_z >> 3
); );
rct_ride *ride = GET_RIDE(vehicle->ride); rct_ride *ride = get_ride(vehicle->ride);
vehicle->track_type = vehicle->track_type =
(mapElement->properties.track.type << 2) | (mapElement->properties.track.type << 2) |
(ride->boat_hire_return_direction & 3); (ride->boat_hire_return_direction & 3);
@ -3321,7 +3321,7 @@ static void vehicle_update_motion_boat_hire(rct_vehicle *vehicle)
if (bx != vehicle->track_x || dx != vehicle->track_y) { if (bx != vehicle->track_x || dx != vehicle->track_y) {
if (vehicle_is_boat_on_water(vehicle, x, y)) { if (vehicle_is_boat_on_water(vehicle, x, y)) {
// loc_6DA939: // loc_6DA939:
rct_ride *ride = GET_RIDE(vehicle->ride); rct_ride *ride = get_ride(vehicle->ride);
bool do_loc_6DAA97 = false; bool do_loc_6DAA97 = false;
if (vehicle->sub_state != 1) { if (vehicle->sub_state != 1) {
@ -3433,7 +3433,7 @@ static void vehicle_update_motion_boat_hire(rct_vehicle *vehicle)
*/ */
static void sub_6DA280(rct_vehicle *vehicle) static void sub_6DA280(rct_vehicle *vehicle)
{ {
rct_ride* ride = GET_RIDE(vehicle->ride); rct_ride* ride = get_ride(vehicle->ride);
rct_xy8 location = { rct_xy8 location = {
.x = (vehicle->x + RCT2_ADDRESS(0x00993CCC, sint16)[2 * (ride->boat_hire_return_direction & 3)]) / 32, .x = (vehicle->x + RCT2_ADDRESS(0x00993CCC, sint16)[2 * (ride->boat_hire_return_direction & 3)]) / 32,
@ -3450,7 +3450,7 @@ static void sub_6DA280(rct_vehicle *vehicle)
uint8 curDirection = ((vehicle->sprite_direction + 19) >> 3) & 3; uint8 curDirection = ((vehicle->sprite_direction + 19) >> 3) & 3;
uint8 randDirection = scenario_rand() & 3; uint8 randDirection = scenario_rand() & 3;
rct_ride_type* rideEntry = GET_RIDE_ENTRY(vehicle->ride_subtype); rct_ride_type* rideEntry = get_ride_entry(vehicle->ride_subtype);
if (scenario_rand() & 1 && (!(rideEntry->flags & RIDE_ENTRY_FLAG_7) || vehicle->lost_time_out > 1920)) { if (scenario_rand() & 1 && (!(rideEntry->flags & RIDE_ENTRY_FLAG_7) || vehicle->lost_time_out > 1920)) {
location = *((rct_xy8*)&ride->boat_hire_return_position); location = *((rct_xy8*)&ride->boat_hire_return_position);
rct_xy16 destLocation = { rct_xy16 destLocation = {
@ -3519,8 +3519,8 @@ static bool vehicle_is_boat_on_water(rct_vehicle *vehicle, int x, int y)
* rct2: 0x006D9249 * rct2: 0x006D9249
*/ */
static void vehicle_update_swinging(rct_vehicle* vehicle) { static void vehicle_update_swinging(rct_vehicle* vehicle) {
rct_ride* ride = GET_RIDE(vehicle->ride); rct_ride* ride = get_ride(vehicle->ride);
rct_ride_type* rideEntry = GET_RIDE_ENTRY(vehicle->ride_subtype); rct_ride_type* rideEntry = get_ride_entry(vehicle->ride_subtype);
// SubState for this ride means swinging state // SubState for this ride means swinging state
// 0 == first swing // 0 == first swing
@ -3584,7 +3584,7 @@ static void vehicle_update_ferris_wheel_rotating(rct_vehicle* vehicle) {
if (RCT2_GLOBAL(0x00F64E34, uint8) == 0) if (RCT2_GLOBAL(0x00F64E34, uint8) == 0)
return; return;
rct_ride* ride = GET_RIDE(vehicle->ride); rct_ride* ride = get_ride(vehicle->ride);
if ((vehicle->ferris_wheel_var_1 -= 1) != 0) if ((vehicle->ferris_wheel_var_1 -= 1) != 0)
return; return;
@ -3693,8 +3693,8 @@ static void vehicle_update_rotating(rct_vehicle* vehicle) {
if (RCT2_GLOBAL(0x00F64E34, uint8) == 0) if (RCT2_GLOBAL(0x00F64E34, uint8) == 0)
return; return;
rct_ride* ride = GET_RIDE(vehicle->ride); rct_ride* ride = get_ride(vehicle->ride);
rct_ride_type* rideEntry = GET_RIDE_ENTRY(vehicle->ride_subtype); rct_ride_type* rideEntry = get_ride_entry(vehicle->ride_subtype);
uint8* edi; uint8* edi;
if (rideEntry->flags & RIDE_ENTRY_FLAG_ALTERNATIVE_ROTATION_MODE_1) { if (rideEntry->flags & RIDE_ENTRY_FLAG_ALTERNATIVE_ROTATION_MODE_1) {
@ -4007,7 +4007,7 @@ static void vehicle_kill_all_passengers(rct_vehicle* vehicle) {
numFatalities += curVehicle->num_peeps; numFatalities += curVehicle->num_peeps;
} }
rct_ride* ride = GET_RIDE(vehicle->ride); rct_ride* ride = get_ride(vehicle->ride);
RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS, uint16) = numFatalities; RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS, uint16) = numFatalities;
uint8 crashType = numFatalities == 0 ? uint8 crashType = numFatalities == 0 ?
@ -4060,7 +4060,7 @@ static void vehicle_crash_on_land(rct_vehicle* vehicle) {
vehicle->status = VEHICLE_STATUS_CRASHED; vehicle->status = VEHICLE_STATUS_CRASHED;
vehicle_invalidate_window(vehicle); vehicle_invalidate_window(vehicle);
rct_ride* ride = GET_RIDE(vehicle->ride); rct_ride* ride = get_ride(vehicle->ride);
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_CRASHED)) { if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_CRASHED)) {
rct_vehicle* frontVehicle = vehicle; rct_vehicle* frontVehicle = vehicle;
@ -4111,7 +4111,7 @@ static void vehicle_crash_on_water(rct_vehicle* vehicle) {
vehicle->status = VEHICLE_STATUS_CRASHED; vehicle->status = VEHICLE_STATUS_CRASHED;
vehicle_invalidate_window(vehicle); vehicle_invalidate_window(vehicle);
rct_ride* ride = GET_RIDE(vehicle->ride); rct_ride* ride = get_ride(vehicle->ride);
if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_CRASHED)) { if (!(ride->lifecycle_flags & RIDE_LIFECYCLE_CRASHED)) {
rct_vehicle* frontVehicle = vehicle; rct_vehicle* frontVehicle = vehicle;
@ -4259,8 +4259,8 @@ static void vehicle_update_sound(rct_vehicle *vehicle)
uint8 screamId, screamVolume = 255; uint8 screamId, screamVolume = 255;
uint16 soundIdVolume; uint16 soundIdVolume;
ride = GET_RIDE(vehicle->ride); ride = get_ride(vehicle->ride);
rideEntry = GET_RIDE_ENTRY(vehicle->ride_subtype); rideEntry = get_ride_entry(vehicle->ride_subtype);
rct_ride_type_vehicle* vehicleEntry = &rideEntry->vehicles[vehicle->vehicle_type]; rct_ride_type_vehicle* vehicleEntry = &rideEntry->vehicles[vehicle->vehicle_type];
@ -4354,7 +4354,7 @@ static int vehicle_update_scream_sound(rct_vehicle *vehicle)
rct_ride_type *rideEntry; rct_ride_type *rideEntry;
rct_vehicle *vehicle2; rct_vehicle *vehicle2;
rideEntry = GET_RIDE_ENTRY(vehicle->ride_subtype); rideEntry = get_ride_entry(vehicle->ride_subtype);
rct_ride_type_vehicle* vehicleEntry = &rideEntry->vehicles[vehicle->vehicle_type]; rct_ride_type_vehicle* vehicleEntry = &rideEntry->vehicles[vehicle->vehicle_type];
@ -4961,7 +4961,7 @@ void vehicle_set_map_toolbar(rct_vehicle *vehicle)
rct_ride *ride; rct_ride *ride;
int vehicleIndex; int vehicleIndex;
ride = GET_RIDE(vehicle->ride); ride = get_ride(vehicle->ride);
while (vehicle->is_child) { while (vehicle->is_child) {
vehicle = GET_VEHICLE(vehicle->prev_vehicle_on_ride); vehicle = GET_VEHICLE(vehicle->prev_vehicle_on_ride);
@ -5020,7 +5020,7 @@ int vehicle_is_used_in_pairs(rct_vehicle *vehicle)
*/ */
static int vehicle_update_motion_bumper_car(rct_vehicle* vehicle) { static int vehicle_update_motion_bumper_car(rct_vehicle* vehicle) {
RCT2_GLOBAL(0x00F64E18, uint32) = 0; RCT2_GLOBAL(0x00F64E18, uint32) = 0;
rct_ride* ride = GET_RIDE(vehicle->ride); rct_ride* ride = get_ride(vehicle->ride);
sint32 nextVelocity = vehicle->velocity + vehicle->acceleration; sint32 nextVelocity = vehicle->velocity + vehicle->acceleration;
if (ride->lifecycle_flags & (RIDE_LIFECYCLE_BREAKDOWN_PENDING | RIDE_LIFECYCLE_BROKEN_DOWN) && if (ride->lifecycle_flags & (RIDE_LIFECYCLE_BREAKDOWN_PENDING | RIDE_LIFECYCLE_BROKEN_DOWN) &&
@ -5162,7 +5162,7 @@ static int vehicle_update_motion_bumper_car(rct_vehicle* vehicle) {
edx >>= 5; edx >>= 5;
eax += edx; eax += edx;
eax /= vehicle->friction; eax /= vehicle->friction;
rct_ride_type* rideEntry = GET_RIDE_ENTRY(vehicle->ride_subtype); rct_ride_type* rideEntry = get_ride_entry(vehicle->ride_subtype);
rct_ride_type_vehicle* vehicleEntry = &rideEntry->vehicles[vehicle->vehicle_type]; rct_ride_type_vehicle* vehicleEntry = &rideEntry->vehicles[vehicle->vehicle_type];
if (!(vehicleEntry->flags_b & VEHICLE_ENTRY_FLAG_B_3)) { if (!(vehicleEntry->flags_b & VEHICLE_ENTRY_FLAG_B_3)) {
@ -5310,7 +5310,7 @@ static void vehicle_update_track_motion_up_stop_check(rct_vehicle *vehicle)
*/ */
static void sub_6DAB4C_chunk_2(rct_vehicle *vehicle) static void sub_6DAB4C_chunk_2(rct_vehicle *vehicle)
{ {
rct_ride *ride = GET_RIDE(vehicle->ride); rct_ride *ride = get_ride(vehicle->ride);
rct_ride_type_vehicle *vehicleEntry = vehicle_get_vehicle_entry(vehicle); rct_ride_type_vehicle *vehicleEntry = vehicle_get_vehicle_entry(vehicle);
// Is chair lift type // Is chair lift type
@ -5437,7 +5437,7 @@ static void vehicle_update_block_breaks_open_previous_section(rct_vehicle *vehic
int trackType = mapElement->properties.track.type; int trackType = mapElement->properties.track.type;
if (trackType == TRACK_ELEM_BLOCK_BRAKES || trackType == TRACK_ELEM_END_STATION) { if (trackType == TRACK_ELEM_BLOCK_BRAKES || trackType == TRACK_ELEM_END_STATION) {
rct_ride *ride = GET_RIDE(vehicle->ride); rct_ride *ride = get_ride(vehicle->ride);
if (ride_is_block_sectioned(ride)) { if (ride_is_block_sectioned(ride)) {
audio_play_sound_at_location(SOUND_48, x, y, z); audio_play_sound_at_location(SOUND_48, x, y, z);
} }
@ -6084,7 +6084,7 @@ static void sub_6D63D4(rct_vehicle *vehicle)
al &= 0x02; al &= 0x02;
ah &= 0x02; ah &= 0x02;
if (al != ah) { if (al != ah) {
rct_ride *ride = GET_RIDE(vehicle->ride); rct_ride *ride = get_ride(vehicle->ride);
if (ride->entrance_style == RIDE_ENTRANCE_STYLE_PLAIN || if (ride->entrance_style == RIDE_ENTRANCE_STYLE_PLAIN ||
(vehicle->status != VEHICLE_STATUS_MOVING_TO_END_OF_STATION && (vehicle->status != VEHICLE_STATUS_MOVING_TO_END_OF_STATION &&
vehicle->status != VEHICLE_STATUS_ARRIVING) vehicle->status != VEHICLE_STATUS_ARRIVING)
@ -6359,7 +6359,7 @@ static void vehicle_update_play_water_splash_sound()
*/ */
static void vehicle_update_handle_water_splash(rct_vehicle *vehicle) static void vehicle_update_handle_water_splash(rct_vehicle *vehicle)
{ {
rct_ride_type *rideEntry = GET_RIDE_ENTRY(vehicle->ride_subtype); rct_ride_type *rideEntry = get_ride_entry(vehicle->ride_subtype);
int trackType = vehicle->track_type >> 2; int trackType = vehicle->track_type >> 2;
if (!(rideEntry->flags & RIDE_ENTRY_FLAG_8)) { if (!(rideEntry->flags & RIDE_ENTRY_FLAG_8)) {
@ -6769,7 +6769,7 @@ loc_6DB358:
// Update VEHICLE_UPDATE_FLAG_11 flag // Update VEHICLE_UPDATE_FLAG_11 flag
vehicle->update_flags &= ~VEHICLE_UPDATE_FLAG_11; vehicle->update_flags &= ~VEHICLE_UPDATE_FLAG_11;
int rideType = GET_RIDE(mapElement->properties.track.ride_index)->type; int rideType = get_ride(mapElement->properties.track.ride_index)->type;
if (RideData4[rideType].flags & RIDE_TYPE_FLAG4_3) { if (RideData4[rideType].flags & RIDE_TYPE_FLAG4_3) {
if (mapElement->properties.track.colour & 4) { if (mapElement->properties.track.colour & 4) {
vehicle->update_flags |= VEHICLE_UPDATE_FLAG_11; vehicle->update_flags |= VEHICLE_UPDATE_FLAG_11;
@ -7330,8 +7330,8 @@ loc_6DBE7F:
int vehicle_update_track_motion_mini_golf(rct_vehicle *vehicle, int* outStation) { int vehicle_update_track_motion_mini_golf(rct_vehicle *vehicle, int* outStation) {
registers regs = { 0 }; registers regs = { 0 };
rct_ride *ride = GET_RIDE(vehicle->ride); rct_ride *ride = get_ride(vehicle->ride);
rct_ride_type *rideEntry = GET_RIDE_ENTRY(vehicle->ride_subtype); rct_ride_type *rideEntry = get_ride_entry(vehicle->ride_subtype);
rct_ride_type_vehicle *vehicleEntry = vehicle_get_vehicle_entry(vehicle); rct_ride_type_vehicle *vehicleEntry = vehicle_get_vehicle_entry(vehicle);
rct_map_element *mapElement = NULL; rct_map_element *mapElement = NULL;
@ -7470,7 +7470,7 @@ loc_6DC476:
goto loc_6DC9BC; goto loc_6DC9BC;
} }
int rideType = GET_RIDE(mapElement->properties.track.ride_index)->type; int rideType = get_ride(mapElement->properties.track.ride_index)->type;
vehicle->update_flags &= ~VEHICLE_UPDATE_FLAG_11; vehicle->update_flags &= ~VEHICLE_UPDATE_FLAG_11;
if (RideData4[rideType].flags & RIDE_TYPE_FLAG4_3) { if (RideData4[rideType].flags & RIDE_TYPE_FLAG4_3) {
if (mapElement->properties.track.colour & (1 << 2)) { if (mapElement->properties.track.colour & (1 << 2)) {
@ -7682,7 +7682,7 @@ loc_6DCA9A:
goto loc_6DCD4A; goto loc_6DCD4A;
} }
rideType = GET_RIDE(mapElement->properties.track.ride_index)->type; rideType = get_ride(mapElement->properties.track.ride_index)->type;
vehicle->update_flags &= ~VEHICLE_UPDATE_FLAG_11; vehicle->update_flags &= ~VEHICLE_UPDATE_FLAG_11;
if (RideData4[rideType].flags & RIDE_TYPE_FLAG4_3) { if (RideData4[rideType].flags & RIDE_TYPE_FLAG4_3) {
if (mapElement->properties.track.colour & (1 << 2)) { if (mapElement->properties.track.colour & (1 << 2)) {
@ -7973,8 +7973,8 @@ int vehicle_update_track_motion(rct_vehicle *vehicle, int *outStation)
//return regs.eax; //return regs.eax;
////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////
rct_ride *ride = GET_RIDE(vehicle->ride); rct_ride *ride = get_ride(vehicle->ride);
rct_ride_type *rideEntry = GET_RIDE_ENTRY(vehicle->ride_subtype); rct_ride_type *rideEntry = get_ride_entry(vehicle->ride_subtype);
rct_ride_type_vehicle *vehicleEntry = vehicle_get_vehicle_entry(vehicle); rct_ride_type_vehicle *vehicleEntry = vehicle_get_vehicle_entry(vehicle);
rct_map_element *mapElement = NULL; rct_map_element *mapElement = NULL;
@ -8282,7 +8282,7 @@ loc_6DC316:
rct_ride_type_vehicle *vehicle_get_vehicle_entry(rct_vehicle *vehicle) rct_ride_type_vehicle *vehicle_get_vehicle_entry(rct_vehicle *vehicle)
{ {
rct_ride_type *rideEntry = GET_RIDE_ENTRY(vehicle->ride_subtype); rct_ride_type *rideEntry = get_ride_entry(vehicle->ride_subtype);
return &rideEntry->vehicles[vehicle->vehicle_type]; return &rideEntry->vehicles[vehicle->vehicle_type];
} }
@ -8316,7 +8316,7 @@ void vehicle_invalidate_window(rct_vehicle *vehicle)
if (w == NULL) if (w == NULL)
return; return;
ride = GET_RIDE(vehicle->ride); ride = get_ride(vehicle->ride);
viewVehicleIndex = w->ride.view - 1; viewVehicleIndex = w->ride.view - 1;
if (viewVehicleIndex < 0 || viewVehicleIndex >= ride->num_vehicles) if (viewVehicleIndex < 0 || viewVehicleIndex >= ride->num_vehicles)
return; return;

14
src/scenario.c
View File

@ -787,7 +787,7 @@ int scenario_get_num_packed_objects_to_write()
rct_object_entry_extended *entry = (rct_object_entry_extended*)0x00F3F03C; rct_object_entry_extended *entry = (rct_object_entry_extended*)0x00F3F03C;
for (i = 0; i < 721; i++, entry++) { for (i = 0; i < 721; i++, entry++) {
if (GET_RIDE_ENTRY(i) == (void *)0xFFFFFFFF || (entry->flags & 0xF0)) if (get_ride_entry(i) == (void *)0xFFFFFFFF || (entry->flags & 0xF0))
continue; continue;
count++; count++;
@ -805,7 +805,7 @@ int scenario_write_packed_objects(SDL_RWops* rw)
int i; int i;
rct_object_entry_extended *entry = (rct_object_entry_extended*)0x00F3F03C; rct_object_entry_extended *entry = (rct_object_entry_extended*)0x00F3F03C;
for (i = 0; i < 721; i++, entry++) { for (i = 0; i < 721; i++, entry++) {
if (GET_RIDE_ENTRY(i) == (void *)0xFFFFFFFF || (entry->flags & 0xF0)) if (get_ride_entry(i) == (void *)0xFFFFFFFF || (entry->flags & 0xF0))
continue; continue;
if (!write_object_file(rw, (rct_object_entry*)entry)) if (!write_object_file(rw, (rct_object_entry*)entry))
@ -845,7 +845,7 @@ int scenario_write_available_objects(FILE *file)
rct_object_entry_extended *srcEntry = (rct_object_entry_extended*)0x00F3F03C; rct_object_entry_extended *srcEntry = (rct_object_entry_extended*)0x00F3F03C;
rct_object_entry *dstEntry = (rct_object_entry*)buffer; rct_object_entry *dstEntry = (rct_object_entry*)buffer;
for (i = 0; i < 721; i++) { for (i = 0; i < 721; i++) {
if (GET_RIDE_ENTRY(i) == (void *)0xFFFFFFFF) if (get_ride_entry(i) == (void *)0xFFFFFFFF)
memset(dstEntry, 0xFF, sizeof(rct_object_entry)); memset(dstEntry, 0xFF, sizeof(rct_object_entry));
else else
*dstEntry = *((rct_object_entry*)srcEntry); *dstEntry = *((rct_object_entry*)srcEntry);
@ -993,7 +993,7 @@ int scenario_save(SDL_RWops* rw, int flags)
for (int i = 0; i < 721; i++) { for (int i = 0; i < 721; i++) {
rct_object_entry_extended *entry = &(RCT2_ADDRESS(0x00F3F03C, rct_object_entry_extended)[i]); rct_object_entry_extended *entry = &(RCT2_ADDRESS(0x00F3F03C, rct_object_entry_extended)[i]);
if (GET_RIDE_ENTRY(i) == (void *)0xFFFFFFFF) { if (get_ride_entry(i) == (void *)0xFFFFFFFF) {
memset(&s6->objects[i], 0xFF, sizeof(rct_object_entry)); memset(&s6->objects[i], 0xFF, sizeof(rct_object_entry));
} else { } else {
s6->objects[i] = *((rct_object_entry*)entry); s6->objects[i] = *((rct_object_entry*)entry);
@ -1066,7 +1066,7 @@ int scenario_save_network(SDL_RWops* rw)
for (int i = 0; i < 721; i++) { for (int i = 0; i < 721; i++) {
rct_object_entry_extended *entry = &(RCT2_ADDRESS(0x00F3F03C, rct_object_entry_extended)[i]); rct_object_entry_extended *entry = &(RCT2_ADDRESS(0x00F3F03C, rct_object_entry_extended)[i]);
if (GET_RIDE_ENTRY(i) == (void *)0xFFFFFFFF) { if (get_ride_entry(i) == (void *)0xFFFFFFFF) {
memset(&s6->objects[i], 0xFF, sizeof(rct_object_entry)); memset(&s6->objects[i], 0xFF, sizeof(rct_object_entry));
} else { } else {
s6->objects[i] = *((rct_object_entry*)entry); s6->objects[i] = *((rct_object_entry*)entry);
@ -1263,7 +1263,7 @@ static void scenario_objective_check_10_rollercoasters()
FOR_ALL_RIDES(i, ride) { FOR_ALL_RIDES(i, ride) {
uint8 subtype_id = ride->subtype; uint8 subtype_id = ride->subtype;
rct_ride_type *rideType = gRideTypeList[subtype_id]; rct_ride_type *rideType = get_ride_entry(subtype_id);
if ((rideType->category[0] == RIDE_GROUP_ROLLERCOASTER || rideType->category[1] == RIDE_GROUP_ROLLERCOASTER) && if ((rideType->category[0] == RIDE_GROUP_ROLLERCOASTER || rideType->category[1] == RIDE_GROUP_ROLLERCOASTER) &&
ride->status == RIDE_STATUS_OPEN && ride->status == RIDE_STATUS_OPEN &&
@ -1340,7 +1340,7 @@ static void scenario_objective_check_10_rollercoasters_length()
FOR_ALL_RIDES(i, ride) { FOR_ALL_RIDES(i, ride) {
uint8 subtype_id = ride->subtype; uint8 subtype_id = ride->subtype;
rct_ride_type *rideType = gRideTypeList[subtype_id]; rct_ride_type *rideType = get_ride_entry(subtype_id);
if ((rideType->category[0] == RIDE_GROUP_ROLLERCOASTER || rideType->category[1] == RIDE_GROUP_ROLLERCOASTER) && if ((rideType->category[0] == RIDE_GROUP_ROLLERCOASTER || rideType->category[1] == RIDE_GROUP_ROLLERCOASTER) &&
ride->status == RIDE_STATUS_OPEN && ride->status == RIDE_STATUS_OPEN &&
ride->excitement >= RIDE_RATING(7,00) && type_already_counted[subtype_id] == 0){ ride->excitement >= RIDE_RATING(7,00) && type_already_counted[subtype_id] == 0){

2
src/windows/demolish_ride_prompt.c
View File

@ -134,7 +134,7 @@ static void window_ride_demolish_paint(rct_window *w, rct_drawpixelinfo *dpi)
{ {
window_draw_widgets(w, dpi); window_draw_widgets(w, dpi);
rct_ride* ride = GET_RIDE(w->number); rct_ride* ride = get_ride(w->number);
RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS, uint16) = ride->name; RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS, uint16) = ride->name;
RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 2, uint32) = ride->name_arguments; RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 2, uint32) = ride->name_arguments;

8
src/windows/editor_inventions_list.c
View File

@ -179,7 +179,7 @@ static void research_rides_setup(){
// Set research required for rides in use // Set research required for rides in use
for (uint16 rideIndex = 0; rideIndex < 255; rideIndex++){ for (uint16 rideIndex = 0; rideIndex < 255; rideIndex++){
rct_ride* ride = &g_ride_list[rideIndex]; rct_ride* ride = get_ride(rideIndex);
if (ride->type == RIDE_TYPE_NULL)continue; if (ride->type == RIDE_TYPE_NULL)continue;
RCT2_ADDRESS(0x0098DA38, uint8*)[OBJECT_TYPE_RIDE][ride->subtype] |= 1; RCT2_ADDRESS(0x0098DA38, uint8*)[OBJECT_TYPE_RIDE][ride->subtype] |= 1;
} }
@ -195,13 +195,13 @@ static void research_rides_setup(){
uint8 ride_base_type = (research->entryIndex >> 8) & 0xFF; uint8 ride_base_type = (research->entryIndex >> 8) & 0xFF;
uint8 object_index = research->entryIndex & 0xFF; uint8 object_index = research->entryIndex & 0xFF;
rct_ride_type* ride_entry = GET_RIDE_ENTRY(object_index); rct_ride_type* ride_entry = get_ride_entry(object_index);
uint8 master_found = 0; uint8 master_found = 0;
if (!(ride_entry->flags & RIDE_ENTRY_FLAG_SEPARATE_RIDE)){ if (!(ride_entry->flags & RIDE_ENTRY_FLAG_SEPARATE_RIDE)){
for (uint8 rideType = 0; rideType < object_entry_group_counts[OBJECT_TYPE_RIDE]; rideType++){ for (uint8 rideType = 0; rideType < object_entry_group_counts[OBJECT_TYPE_RIDE]; rideType++){
rct_ride_type* master_ride = GET_RIDE_ENTRY(rideType); rct_ride_type* master_ride = get_ride_entry(rideType);
if (master_ride == NULL || (uint32)master_ride == 0xFFFFFFFF) if (master_ride == NULL || (uint32)master_ride == 0xFFFFFFFF)
continue; continue;
@ -316,7 +316,7 @@ static rct_string_id research_item_get_name(uint32 researchItem)
return sceneryEntry->name; return sceneryEntry->name;
} }
rideEntry = GET_RIDE_ENTRY(researchItem & 0xFF); rideEntry = get_ride_entry(researchItem & 0xFF);
if (rideEntry == NULL || rideEntry == (rct_ride_type*)0xFFFFFFFF) if (rideEntry == NULL || rideEntry == (rct_ride_type*)0xFFFFFFFF)
return 0; return 0;

4
src/windows/editor_object_selection.c
View File

@ -629,7 +629,7 @@ static void setup_in_use_selection_flags(){
} while (map_element_iterator_next(&iter)); } while (map_element_iterator_next(&iter));
for (uint8 ride_index = 0; ride_index < 0xFF; ride_index++){ for (uint8 ride_index = 0; ride_index < 0xFF; ride_index++){
rct_ride* ride = GET_RIDE(ride_index); rct_ride* ride = get_ride(ride_index);
if (ride->type == RIDE_TYPE_NULL) if (ride->type == RIDE_TYPE_NULL)
continue; continue;
@ -1955,7 +1955,7 @@ static void window_editor_object_selection_manage_tracks()
RCT2_GLOBAL(0xF44157, uint8) = entry_index; RCT2_GLOBAL(0xF44157, uint8) = entry_index;
rct_ride_type* ride_entry = GET_RIDE_ENTRY(entry_index); rct_ride_type* ride_entry = get_ride_entry(entry_index);
uint8* ride_type_array = &ride_entry->ride_type[0]; uint8* ride_type_array = &ride_entry->ride_type[0];
int ride_type; int ride_type;

4
src/windows/editor_objective_options.c
View File

@ -1118,7 +1118,7 @@ static void window_editor_objective_options_rides_scrollmousedown(rct_window *w,
if (i < 0 || i >= w->no_list_items) if (i < 0 || i >= w->no_list_items)
return; return;
ride = GET_RIDE(i); ride = get_ride(i);
ride->lifecycle_flags ^= RIDE_LIFECYCLE_INDESTRUCTIBLE; ride->lifecycle_flags ^= RIDE_LIFECYCLE_INDESTRUCTIBLE;
window_invalidate(w); window_invalidate(w);
} }
@ -1208,7 +1208,7 @@ static void window_editor_objective_options_rides_scrollpaint(rct_window *w, rct
} }
// Checkbox mark // Checkbox mark
ride = GET_RIDE(i); ride = get_ride(i);
if (ride->lifecycle_flags & RIDE_LIFECYCLE_INDESTRUCTIBLE) { if (ride->lifecycle_flags & RIDE_LIFECYCLE_INDESTRUCTIBLE) {
RCT2_GLOBAL(RCT2_ADDRESS_CURRENT_FONT_SPRITE_BASE, uint16) = stringId == 1193 ? 0xFFFE : 0xFFFF; RCT2_GLOBAL(RCT2_ADDRESS_CURRENT_FONT_SPRITE_BASE, uint16) = stringId == 1193 ? 0xFFFE : 0xFFFF;
gfx_draw_string(dpi, (char*)CheckBoxMarkString, w->colours[1] & 0x7F, 2, y); gfx_draw_string(dpi, (char*)CheckBoxMarkString, w->colours[1] & 0x7F, 2, y);

2
src/windows/finances.c
View File

@ -1189,7 +1189,7 @@ static void window_finances_marketing_paint(rct_window *w, rct_drawpixelinfo *dp
switch (i) { switch (i) {
case ADVERTISING_CAMPAIGN_RIDE_FREE: case ADVERTISING_CAMPAIGN_RIDE_FREE:
case ADVERTISING_CAMPAIGN_RIDE: case ADVERTISING_CAMPAIGN_RIDE:
ride = GET_RIDE(gMarketingCampaignRideIndex[i]); ride = get_ride(gMarketingCampaignRideIndex[i]);
RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS, uint16) = ride->name; RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS, uint16) = ride->name;
RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 2, uint32) = ride->name_arguments; RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 2, uint32) = ride->name_arguments;
break; break;

16
src/windows/guest.c
View File

@ -1593,7 +1593,7 @@ void window_guest_rides_update(rct_window *w)
uint8 ride_id_bit = ride_id % 8; uint8 ride_id_bit = ride_id % 8;
uint8 ride_id_offset = ride_id / 8; uint8 ride_id_offset = ride_id / 8;
if (peep->rides_been_on[ride_id_offset] & (1 << ride_id_bit)){ if (peep->rides_been_on[ride_id_offset] & (1 << ride_id_bit)){
rct_ride* ride = GET_RIDE(ride_id); rct_ride* ride = get_ride(ride_id);
if (RCT2_ADDRESS(0x97C3AF, uint8)[ride->type] == 0){ if (RCT2_ADDRESS(0x97C3AF, uint8)[ride->type] == 0){
w->list_item_positions[curr_list_position] = ride_id; w->list_item_positions[curr_list_position] = ride_id;
curr_list_position++; curr_list_position++;
@ -1737,7 +1737,7 @@ void window_guest_rides_paint(rct_window *w, rct_drawpixelinfo *dpi)
int ride_string_id = 3094; int ride_string_id = 3094;
int ride_string_arguments = 0; int ride_string_arguments = 0;
if (peep->favourite_ride != 0xFF){ if (peep->favourite_ride != 0xFF){
rct_ride* ride = GET_RIDE(peep->favourite_ride); rct_ride* ride = get_ride(peep->favourite_ride);
ride_string_arguments = ride->name_arguments; ride_string_arguments = ride->name_arguments;
ride_string_id = ride->name; ride_string_id = ride->name;
} }
@ -1772,7 +1772,7 @@ void window_guest_rides_scroll_paint(rct_window *w, rct_drawpixelinfo *dpi, int
gfx_fill_rect(dpi, 0, y, 800, y + 9, 0x2000031); gfx_fill_rect(dpi, 0, y, 800, y + 9, 0x2000031);
string_format = 1193; string_format = 1193;
} }
rct_ride* ride = GET_RIDE(w->list_item_positions[list_index]); rct_ride* ride = get_ride(w->list_item_positions[list_index]);
gfx_draw_string_left(dpi, string_format, (void*)&ride->name, 0, 0, y - 1); gfx_draw_string_left(dpi, string_format, (void*)&ride->name, 0, 0, y - 1);
} }
@ -2098,7 +2098,7 @@ static rct_string_id window_guest_inventory_format_item(rct_peep *peep, int item
RCT2_GLOBAL(args + 0, uint32) |= 0x20000000 | peep->balloon_colour << 19; RCT2_GLOBAL(args + 0, uint32) |= 0x20000000 | peep->balloon_colour << 19;
break; break;
case SHOP_ITEM_PHOTO: case SHOP_ITEM_PHOTO:
ride = GET_RIDE(peep->photo1_ride_ref); ride = get_ride(peep->photo1_ride_ref);
RCT2_GLOBAL(args + 6, uint16) = ride->name; RCT2_GLOBAL(args + 6, uint16) = ride->name;
RCT2_GLOBAL(args + 8, uint32) = ride->name_arguments; RCT2_GLOBAL(args + 8, uint32) = ride->name_arguments;
break; break;
@ -2113,7 +2113,7 @@ static rct_string_id window_guest_inventory_format_item(rct_peep *peep, int item
RCT2_GLOBAL(args + 10, uint32) = RCT2_GLOBAL(RCT2_ADDRESS_PARK_NAME_ARGS, uint32); RCT2_GLOBAL(args + 10, uint32) = RCT2_GLOBAL(RCT2_ADDRESS_PARK_NAME_ARGS, uint32);
break; break;
case VOUCHER_TYPE_RIDE_FREE: case VOUCHER_TYPE_RIDE_FREE:
ride = GET_RIDE(peep->voucher_arguments); ride = get_ride(peep->voucher_arguments);
RCT2_GLOBAL(args + 6, uint16) = 2419; RCT2_GLOBAL(args + 6, uint16) = 2419;
RCT2_GLOBAL(args + 8, uint16) = ride->name; RCT2_GLOBAL(args + 8, uint16) = ride->name;
RCT2_GLOBAL(args + 10, uint32) = ride->name_arguments; RCT2_GLOBAL(args + 10, uint32) = ride->name_arguments;
@ -2136,17 +2136,17 @@ static rct_string_id window_guest_inventory_format_item(rct_peep *peep, int item
RCT2_GLOBAL(args + 0, uint32) |= 0x20000000 | peep->tshirt_colour << 19; RCT2_GLOBAL(args + 0, uint32) |= 0x20000000 | peep->tshirt_colour << 19;
break; break;
case SHOP_ITEM_PHOTO2: case SHOP_ITEM_PHOTO2:
ride = GET_RIDE(peep->photo2_ride_ref); ride = get_ride(peep->photo2_ride_ref);
RCT2_GLOBAL(args + 6, uint16) = ride->name; RCT2_GLOBAL(args + 6, uint16) = ride->name;
RCT2_GLOBAL(args + 8, uint32) = ride->name_arguments; RCT2_GLOBAL(args + 8, uint32) = ride->name_arguments;
break; break;
case SHOP_ITEM_PHOTO3: case SHOP_ITEM_PHOTO3:
ride = GET_RIDE(peep->photo3_ride_ref); ride = get_ride(peep->photo3_ride_ref);
RCT2_GLOBAL(args + 6, uint16) = ride->name; RCT2_GLOBAL(args + 6, uint16) = ride->name;
RCT2_GLOBAL(args + 8, uint32) = ride->name_arguments; RCT2_GLOBAL(args + 8, uint32) = ride->name_arguments;
break; break;
case SHOP_ITEM_PHOTO4: case SHOP_ITEM_PHOTO4:
ride = GET_RIDE(peep->photo4_ride_ref); ride = get_ride(peep->photo4_ride_ref);
RCT2_GLOBAL(args + 6, uint16) = ride->name; RCT2_GLOBAL(args + 6, uint16) = ride->name;
RCT2_GLOBAL(args + 8, uint32) = ride->name_arguments; RCT2_GLOBAL(args + 8, uint32) = ride->name_arguments;
break; break;

2
src/windows/guest_list.c
View File

@ -205,7 +205,7 @@ void window_guest_list_open_with_filter(int type, int index)
rct_ride *ride = NULL; rct_ride *ride = NULL;
if (type != 3) { // common for cases 0, 1, 2 if (type != 3) { // common for cases 0, 1, 2
ride = GET_RIDE(index & 0x000000FF); ride = get_ride(index & 0x000000FF);
eax = ride->name; eax = ride->name;
edx = ride->name_arguments; edx = ride->name_arguments;
} }

2
src/windows/map.c
View File

@ -1588,7 +1588,7 @@ static uint16 map_window_get_pixel_colour_ride(int x, int y)
break; break;
// fall-through // fall-through
case MAP_ELEMENT_TYPE_TRACK: case MAP_ELEMENT_TYPE_TRACK:
ride = GET_RIDE(mapElement->properties.track.ride_index); ride = get_ride(mapElement->properties.track.ride_index);
colour = RideKeyColours[RideColourKey[ride->type]]; colour = RideKeyColours[RideColourKey[ride->type]];
break; break;
} }

6
src/windows/maze_construction.c
View File

@ -176,7 +176,7 @@ static void window_maze_construction_close(rct_window *w)
hide_gridlines(); hide_gridlines();
uint8 rideIndex = _currentRideIndex; uint8 rideIndex = _currentRideIndex;
rct_ride* ride = GET_RIDE(rideIndex); rct_ride* ride = get_ride(rideIndex);
if (ride->overall_view == 0xFFFF) { if (ride->overall_view == 0xFFFF) {
int savedPausedState = RCT2_GLOBAL(RCT2_ADDRESS_GAME_PAUSED, uint8); int savedPausedState = RCT2_GLOBAL(RCT2_ADDRESS_GAME_PAUSED, uint8);
RCT2_GLOBAL(RCT2_ADDRESS_GAME_PAUSED, uint8) = 0; RCT2_GLOBAL(RCT2_ADDRESS_GAME_PAUSED, uint8) = 0;
@ -377,7 +377,7 @@ static void window_maze_construction_entrance_tooldown(int x, int y, rct_window*
RCT2_GLOBAL(RCT2_ADDRESS_COMMAND_MAP_Y, sint16), RCT2_GLOBAL(RCT2_ADDRESS_COMMAND_MAP_Y, sint16),
RCT2_GLOBAL(RCT2_ADDRESS_COMMAND_MAP_Z, uint16)); RCT2_GLOBAL(RCT2_ADDRESS_COMMAND_MAP_Z, uint16));
rct_ride* ride = GET_RIDE(rideIndex); rct_ride* ride = get_ride(rideIndex);
if (ride_are_all_possible_entrances_and_exits_built(ride)){ if (ride_are_all_possible_entrances_and_exits_built(ride)){
tool_cancel(); tool_cancel();
if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_15)) if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_15))
@ -413,7 +413,7 @@ static void window_maze_construction_tooldown(rct_window* w, int widgetIndex, in
*/ */
static void window_maze_construction_invalidate(rct_window *w) static void window_maze_construction_invalidate(rct_window *w)
{ {
rct_ride *ride = GET_RIDE(_currentRideIndex); rct_ride *ride = get_ride(_currentRideIndex);
// Set window title arguments // Set window title arguments
RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 4, rct_string_id) = ride->name; RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 4, rct_string_id) = ride->name;

14
src/windows/new_campaign.c
View File

@ -106,8 +106,8 @@ int ride_value_compare(const void *a, const void *b)
{ {
rct_ride *rideA, *rideB; rct_ride *rideA, *rideB;
rideA = GET_RIDE(*((uint8*)a)); rideA = get_ride(*((uint8*)a));
rideB = GET_RIDE(*((uint8*)b)); rideB = get_ride(*((uint8*)b));
return rideB->value - rideA->value; return rideB->value - rideA->value;
} }
@ -116,8 +116,8 @@ int ride_name_compare(const void *a, const void *b)
char rideAName[256], rideBName[256]; char rideAName[256], rideBName[256];
rct_ride *rideA, *rideB; rct_ride *rideA, *rideB;
rideA = GET_RIDE(*((uint8*)a)); rideA = get_ride(*((uint8*)a));
rideB = GET_RIDE(*((uint8*)b)); rideB = get_ride(*((uint8*)b));
format_string(rideAName, rideA->name, &rideA->name_arguments); format_string(rideAName, rideA->name, &rideA->name_arguments);
format_string(rideBName, rideB->name, &rideB->name_arguments); format_string(rideBName, rideB->name, &rideB->name_arguments);
@ -199,7 +199,7 @@ static void window_new_campaign_get_shop_items()
uint64 items = 0; uint64 items = 0;
FOR_ALL_RIDES(i, ride) { FOR_ALL_RIDES(i, ride) {
rct_ride_type *rideType = gRideTypeList[ride->subtype]; rct_ride_type *rideType = get_ride_entry(ride->subtype);
uint8 itemType = rideType->shop_item; uint8 itemType = rideType->shop_item;
if (itemType != 255) if (itemType != 255)
items |= 1LL << itemType; items |= 1LL << itemType;
@ -274,7 +274,7 @@ static void window_new_campaign_mousedown(int widgetIndex, rct_window *w, rct_wi
if (window_new_campaign_rides[i] == 255) if (window_new_campaign_rides[i] == 255)
break; break;
rct_ride *ride = GET_RIDE(window_new_campaign_rides[i]); rct_ride *ride = get_ride(window_new_campaign_rides[i]);
gDropdownItemsFormat[i] = 1142; gDropdownItemsFormat[i] = 1142;
gDropdownItemsArgs[i] = ((uint64)ride->name_arguments << 16ULL) | ride->name; gDropdownItemsArgs[i] = ((uint64)ride->name_arguments << 16ULL) | ride->name;
numItems++; numItems++;
@ -341,7 +341,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_DROPDOWN_BUTTON].type = WWT_DROPDOWN_BUTTON;
window_new_campaign_widgets[WIDX_RIDE_LABEL].image = STR_MARKETING_RIDE; window_new_campaign_widgets[WIDX_RIDE_LABEL].image = STR_MARKETING_RIDE;
if (w->campaign.ride_id != SELECTED_RIDE_UNDEFINED) { if (w->campaign.ride_id != SELECTED_RIDE_UNDEFINED) {
rct_ride *ride = GET_RIDE(w->campaign.ride_id); rct_ride *ride = get_ride(w->campaign.ride_id);
window_new_campaign_widgets[WIDX_RIDE_DROPDOWN].image = ride->name; window_new_campaign_widgets[WIDX_RIDE_DROPDOWN].image = ride->name;
RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS, uint32) = ride->name_arguments; RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS, uint32) = ride->name_arguments;
} }

8
src/windows/new_ride.c
View File

@ -325,7 +325,7 @@ static void window_new_ride_populate_list()
continue; continue;
// Ride entries // Ride entries
rct_ride_type *rideEntry = GET_RIDE_ENTRY(rideEntryIndex); rct_ride_type *rideEntry = get_ride_entry(rideEntryIndex);
// Check if ride is in this category // Check if ride is in this category
if (!gConfigInterface.select_by_track_type && (currentCategory != rideEntry->category[0] && currentCategory != rideEntry->category[1])) if (!gConfigInterface.select_by_track_type && (currentCategory != rideEntry->category[0] && currentCategory != rideEntry->category[1]))
@ -479,7 +479,7 @@ void window_new_ride_focus(ride_list_item rideItem)
if (w == NULL) if (w == NULL)
return; return;
rideType = GET_RIDE_ENTRY(rideItem.entry_index); rideType = get_ride_entry(rideItem.entry_index);
if(!gConfigInterface.select_by_track_type) if(!gConfigInterface.select_by_track_type)
window_new_ride_set_page(w, rideType->category[0]); window_new_ride_set_page(w, rideType->category[0]);
@ -790,7 +790,7 @@ static void window_new_ride_scrollpaint(rct_window *w, rct_drawpixelinfo *dpi, i
gfx_fill_rect_inset(dpi, x, y, x + 115, y + 115, w->colours[1], 0x80 | flags); gfx_fill_rect_inset(dpi, x, y, x + 115, y + 115, w->colours[1], 0x80 | flags);
// Draw ride image with feathered border // Draw ride image with feathered border
rideEntry = GET_RIDE_ENTRY(listItem->entry_index); rideEntry = get_ride_entry(listItem->entry_index);
int image_id = rideEntry->images_offset; int image_id = rideEntry->images_offset;
if (listItem->type != rideEntry->ride_type[0]) { if (listItem->type != rideEntry->ride_type[0]) {
image_id++; image_id++;
@ -860,7 +860,7 @@ static int get_num_track_designs(ride_list_item item)
*/ */
static void window_new_ride_paint_ride_information(rct_window *w, rct_drawpixelinfo *dpi, ride_list_item item, int x, int y, int width) static void window_new_ride_paint_ride_information(rct_window *w, rct_drawpixelinfo *dpi, ride_list_item item, int x, int y, int width)
{ {
rct_ride_type *rideEntry = GET_RIDE_ENTRY(item.entry_index); rct_ride_type *rideEntry = get_ride_entry(item.entry_index);
// Ride name and description // Ride name and description
rct_string_id rideName = rideEntry->name; rct_string_id rideName = rideEntry->name;

4
src/windows/research.c
View File

@ -350,7 +350,7 @@ void window_research_development_page_paint(rct_window *w, rct_drawpixelinfo *dp
if (RCT2_GLOBAL(RCT2_ADDRESS_RESEARH_PROGRESS_STAGE, uint8) != RESEARCH_STAGE_DESIGNING) { if (RCT2_GLOBAL(RCT2_ADDRESS_RESEARH_PROGRESS_STAGE, uint8) != RESEARCH_STAGE_DESIGNING) {
uint32 typeId = RCT2_GLOBAL(RCT2_ADDRESS_NEXT_RESEARCH_ITEM, uint32); uint32 typeId = RCT2_GLOBAL(RCT2_ADDRESS_NEXT_RESEARCH_ITEM, uint32);
if (typeId >= 0x10000) { if (typeId >= 0x10000) {
rct_ride_type *rideEntry = GET_RIDE_ENTRY(typeId & 0xFF); rct_ride_type *rideEntry = get_ride_entry(typeId & 0xFF);
stringId = (rideEntry->flags & RIDE_ENTRY_FLAG_SEPARATE_RIDE_NAME) ? stringId = (rideEntry->flags & RIDE_ENTRY_FLAG_SEPARATE_RIDE_NAME) ?
rideEntry->name : rideEntry->name :
((typeId >> 8) & 0xFF) + 2; ((typeId >> 8) & 0xFF) + 2;
@ -388,7 +388,7 @@ void window_research_development_page_paint(rct_window *w, rct_drawpixelinfo *dp
int lastDevelopmentFormat; int lastDevelopmentFormat;
if (typeId != 0xFFFFFFFF) { if (typeId != 0xFFFFFFFF) {
if (typeId >= 0x10000) { if (typeId >= 0x10000) {
rct_ride_type *rideEntry = GET_RIDE_ENTRY(typeId & 0xFF); rct_ride_type *rideEntry = get_ride_entry(typeId & 0xFF);
stringId = (rideEntry->flags & RIDE_ENTRY_FLAG_SEPARATE_RIDE_NAME) ? stringId = (rideEntry->flags & RIDE_ENTRY_FLAG_SEPARATE_RIDE_NAME) ?
rideEntry->name : rideEntry->name :
((typeId >> 8) & 0xFF) + 2; ((typeId >> 8) & 0xFF) + 2;

158
src/windows/ride.c
View File

@ -978,7 +978,7 @@ static void window_ride_draw_tab_main(rct_drawpixelinfo *dpi, rct_window *w)
if (!(w->disabled_widgets & (1LL << widgetIndex))) { if (!(w->disabled_widgets & (1LL << widgetIndex))) {
int spriteIndex; int spriteIndex;
int rideType = GET_RIDE(w->number)->type; int rideType = get_ride(w->number)->type;
switch (gRideClassifications[rideType]) { switch (gRideClassifications[rideType]) {
case RIDE_CLASS_RIDE: case RIDE_CLASS_RIDE:
@ -1036,7 +1036,7 @@ static void window_ride_draw_tab_vehicle(rct_drawpixelinfo *dpi, rct_window *w)
x = (widget->right - widget->left) / 2; x = (widget->right - widget->left) / 2;
y = (widget->bottom - widget->top) - 12; y = (widget->bottom - widget->top) - 12;
ride = GET_RIDE(w->number); ride = get_ride(w->number);
uint8 trainLayout[16]; uint8 trainLayout[16];
ride_entry_get_train_layout(ride->subtype, ride->num_cars_per_train, trainLayout); ride_entry_get_train_layout(ride->subtype, ride->num_cars_per_train, trainLayout);
@ -1119,7 +1119,7 @@ static void window_ride_draw_tab_images(rct_drawpixelinfo *dpi, rct_window *w)
void window_ride_disable_tabs(rct_window *w) void window_ride_disable_tabs(rct_window *w)
{ {
uint32 disabled_tabs = 0; uint32 disabled_tabs = 0;
rct_ride *ride = GET_RIDE(w->number & 0xFF); rct_ride *ride = get_ride(w->number & 0xFF);
uint8 ride_type = ride->type; // ecx uint8 ride_type = ride->type; // ecx
@ -1157,7 +1157,7 @@ void window_ride_disable_tabs(rct_window *w)
if ((RCT2_GLOBAL(RCT2_ADDRESS_SCREEN_FLAGS, uint32) & SCREEN_FLAGS_TRACK_DESIGNER) != 0) if ((RCT2_GLOBAL(RCT2_ADDRESS_SCREEN_FLAGS, uint32) & SCREEN_FLAGS_TRACK_DESIGNER) != 0)
disabled_tabs |= (1 << WIDX_TAB_4 | 1 << WIDX_TAB_6 | 1 << WIDX_TAB_9 | 1 << WIDX_TAB_10); // 0x3280 disabled_tabs |= (1 << WIDX_TAB_4 | 1 << WIDX_TAB_6 | 1 << WIDX_TAB_9 | 1 << WIDX_TAB_10); // 0x3280
rct_ride_type *type = GET_RIDE_ENTRY(ride->subtype); rct_ride_type *type = get_ride_entry(ride->subtype);
if ((type->flags & RIDE_ENTRY_FLAG_19) != 0) if ((type->flags & RIDE_ENTRY_FLAG_19) != 0)
disabled_tabs |= (1 << WIDX_TAB_5); // 0x100 disabled_tabs |= (1 << WIDX_TAB_5); // 0x100
@ -1193,7 +1193,7 @@ rct_window *window_ride_open(int rideIndex)
w->max_width = 500; w->max_width = 500;
w->max_height = 450; w->max_height = 450;
ride = GET_RIDE(rideIndex); ride = get_ride(rideIndex);
numSubTypes = 0; numSubTypes = 0;
rideEntryIndexPtr = get_ride_entry_indices_for_ride_type(ride->type); rideEntryIndexPtr = get_ride_entry_indices_for_ride_type(ride->type);
for (; *rideEntryIndexPtr != 0xFF; rideEntryIndexPtr++) { for (; *rideEntryIndexPtr != 0xFF; rideEntryIndexPtr++) {
@ -1257,7 +1257,7 @@ rct_window *window_ride_open_station(int rideIndex, int stationIndex)
rct_ride *ride; rct_ride *ride;
rct_window *w; rct_window *w;
ride = GET_RIDE(rideIndex); ride = get_ride(rideIndex);
if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_13)) if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_13))
return window_ride_main_open(rideIndex); return window_ride_main_open(rideIndex);
@ -1331,7 +1331,7 @@ rct_window *window_ride_open_vehicle(rct_vehicle *vehicle)
headVehicle = vehicle_get_head(vehicle); headVehicle = vehicle_get_head(vehicle);
headVehicleSpriteIndex = headVehicle->sprite_index; headVehicleSpriteIndex = headVehicle->sprite_index;
rideIndex = headVehicle->ride; rideIndex = headVehicle->ride;
ride = GET_RIDE(rideIndex); ride = get_ride(rideIndex);
// Get view index // Get view index
view = 1; view = 1;
@ -1481,7 +1481,7 @@ static void window_ride_init_viewport(rct_window *w)
{ {
if (w->page != WINDOW_RIDE_PAGE_MAIN) return; if (w->page != WINDOW_RIDE_PAGE_MAIN) return;
rct_ride* ride = GET_RIDE(w->number); rct_ride* ride = get_ride(w->number);
int eax = w->viewport_focus_coordinates.var_480 - 1; int eax = w->viewport_focus_coordinates.var_480 - 1;
union{ union{
@ -1615,7 +1615,7 @@ static void window_ride_rename(rct_window *w)
{ {
rct_ride *ride; rct_ride *ride;
ride = GET_RIDE(w->number); ride = get_ride(w->number);
RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 16, uint32) = ride->name_arguments; RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 16, uint32) = ride->name_arguments;
window_text_input_open(w, WIDX_RENAME, STR_RIDE_ATTRACTION_NAME, STR_ENTER_NEW_NAME_FOR_THIS_RIDE_ATTRACTION, ride->name, ride->name_arguments, 32); window_text_input_open(w, WIDX_RENAME, STR_RIDE_ATTRACTION_NAME, STR_ENTER_NEW_NAME_FOR_THIS_RIDE_ATTRACTION, ride->name, ride->name_arguments, 32);
} }
@ -1661,7 +1661,7 @@ static void window_ride_main_mouseup(rct_window *w, int widgetIndex)
case WIDX_TEST_LIGHT: case WIDX_TEST_LIGHT:
case WIDX_OPEN_LIGHT: case WIDX_OPEN_LIGHT:
ride = GET_RIDE(w->number); ride = get_ride(w->number);
switch (widgetIndex - WIDX_CLOSE_LIGHT) { switch (widgetIndex - WIDX_CLOSE_LIGHT) {
case 0: case 0:
@ -1697,7 +1697,7 @@ static void window_ride_main_resize(rct_window *w)
w->flags |= WF_RESIZABLE; w->flags |= WF_RESIZABLE;
int minHeight = 180; int minHeight = 180;
if (theme_get_preset()->features.rct1_ride_lights) if (theme_get_preset()->features.rct1_ride_lights)
minHeight = 200 + RCT1_LIGHT_OFFSET - (ride_type_has_flag(GET_RIDE(w->number)->type, RIDE_TYPE_FLAG_NO_TEST_MODE) ? 14 : 0); minHeight = 200 + RCT1_LIGHT_OFFSET - (ride_type_has_flag(get_ride(w->number)->type, RIDE_TYPE_FLAG_NO_TEST_MODE) ? 14 : 0);
window_set_resize(w, 316, minHeight, 500, 450); window_set_resize(w, 316, minHeight, 500, 450);
viewport = w->viewport; viewport = w->viewport;
@ -1726,7 +1726,7 @@ static void window_ride_show_view_dropdown(rct_window *w, rct_widget *widget)
int numItems, currentItem, i, j, name; int numItems, currentItem, i, j, name;
dropdownWidget = widget - 1; dropdownWidget = widget - 1;
ride = GET_RIDE(w->number); ride = get_ride(w->number);
numItems = 1; numItems = 1;
if (!ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_13)) { if (!ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_13)) {
@ -1787,7 +1787,7 @@ static void window_ride_show_open_dropdown(rct_window *w, rct_widget *widget)
rct_ride *ride; rct_ride *ride;
int numItems, highlightedIndex, checkedIndex; int numItems, highlightedIndex, checkedIndex;
ride = GET_RIDE(w->number); ride = get_ride(w->number);
numItems = 0; numItems = 0;
gDropdownItemsFormat[numItems] = 1142; gDropdownItemsFormat[numItems] = 1142;
@ -1883,7 +1883,7 @@ static void window_ride_main_dropdown(rct_window *w, int widgetIndex, int dropdo
case WIDX_VIEW_DROPDOWN: case WIDX_VIEW_DROPDOWN:
if (dropdownIndex == -1) { if (dropdownIndex == -1) {
dropdownIndex = w->ride.view; dropdownIndex = w->ride.view;
ride = GET_RIDE(w->number); ride = get_ride(w->number);
dropdownIndex++; dropdownIndex++;
if (dropdownIndex != 0 && dropdownIndex <= ride->num_vehicles && !(ride->lifecycle_flags & RIDE_LIFECYCLE_ON_TRACK)) if (dropdownIndex != 0 && dropdownIndex <= ride->num_vehicles && !(ride->lifecycle_flags & RIDE_LIFECYCLE_ON_TRACK))
dropdownIndex = ride->num_vehicles + 1; dropdownIndex = ride->num_vehicles + 1;
@ -1900,7 +1900,7 @@ static void window_ride_main_dropdown(rct_window *w, int widgetIndex, int dropdo
if (dropdownIndex == -1) if (dropdownIndex == -1)
dropdownIndex = gDropdownHighlightedIndex; dropdownIndex = gDropdownHighlightedIndex;
ride = GET_RIDE(w->number); ride = get_ride(w->number);
if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_NO_TEST_MODE) && dropdownIndex != 0) if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_NO_TEST_MODE) && dropdownIndex != 0)
dropdownIndex++; dropdownIndex++;
@ -1943,7 +1943,7 @@ static void window_ride_main_update(rct_window *w)
widget_invalidate(w, WIDX_TAB_1); widget_invalidate(w, WIDX_TAB_1);
// Update status // Update status
ride = GET_RIDE(w->number); ride = get_ride(w->number);
if (!(ride->window_invalidate_flags & RIDE_INVALIDATE_RIDE_MAIN)) { if (!(ride->window_invalidate_flags & RIDE_INVALIDATE_RIDE_MAIN)) {
if (w->ride.view == 0) if (w->ride.view == 0)
return; return;
@ -2010,7 +2010,7 @@ static void window_ride_main_invalidate(rct_window *w)
window_ride_set_pressed_tab(w); window_ride_set_pressed_tab(w);
rct_ride *ride = GET_RIDE(w->number); rct_ride *ride = get_ride(w->number);
w->disabled_widgets &= ~((1 << 22) | (1 << 19)); w->disabled_widgets &= ~((1 << 22) | (1 << 19));
if (ride->lifecycle_flags & (RIDE_LIFECYCLE_INDESTRUCTIBLE | RIDE_LIFECYCLE_INDESTRUCTIBLE_TRACK)) if (ride->lifecycle_flags & (RIDE_LIFECYCLE_INDESTRUCTIBLE | RIDE_LIFECYCLE_INDESTRUCTIBLE_TRACK))
w->disabled_widgets |= (1 << 22); w->disabled_widgets |= (1 << 22);
@ -2107,7 +2107,7 @@ static rct_string_id window_ride_get_status_vehicle(rct_window *w, void *argumen
uint16 vehicleSpriteIndex; uint16 vehicleSpriteIndex;
rct_string_id stringId; rct_string_id stringId;
ride = GET_RIDE(w->number); ride = get_ride(w->number);
vehicleIndex = w->ride.view - 1; vehicleIndex = w->ride.view - 1;
vehicleSpriteIndex = ride->vehicles[vehicleIndex]; vehicleSpriteIndex = ride->vehicles[vehicleIndex];
@ -2160,7 +2160,7 @@ static rct_string_id window_ride_get_status_station(rct_window *w, void *argumen
int stationIndex, count, queueLength; int stationIndex, count, queueLength;
rct_string_id stringId; rct_string_id stringId;
ride = GET_RIDE(w->number); ride = get_ride(w->number);
count = w->ride.view - ride->num_vehicles - 1; count = w->ride.view - ride->num_vehicles - 1;
stationIndex = -1; stationIndex = -1;
@ -2204,7 +2204,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) static rct_string_id window_ride_get_status(rct_window *w, void *arguments)
{ {
rct_ride *ride = GET_RIDE(w->number); rct_ride *ride = get_ride(w->number);
if (w->ride.view == 0) if (w->ride.view == 0)
return window_ride_get_status_overall_view(w, arguments); return window_ride_get_status_overall_view(w, arguments);
@ -2236,7 +2236,7 @@ static void window_ride_main_paint(rct_window *w, rct_drawpixelinfo *dpi)
} }
// View dropdown // View dropdown
ride = GET_RIDE(w->number); ride = get_ride(w->number);
stringId = STR_OVERALL_VIEW; stringId = STR_OVERALL_VIEW;
if (w->ride.view != 0) { if (w->ride.view != 0) {
stringId = RideNameConvention[ride->type].vehicle_name + 6; stringId = RideNameConvention[ride->type].vehicle_name + 6;
@ -2284,7 +2284,7 @@ static void window_ride_vehicle_mouseup(rct_window *w, int widgetIndex)
{ {
rct_ride *ride; rct_ride *ride;
ride = GET_RIDE(w->number); ride = get_ride(w->number);
switch (widgetIndex) { switch (widgetIndex) {
case WIDX_CLOSE: case WIDX_CLOSE:
@ -2328,7 +2328,7 @@ static void window_ride_vehicle_mousedown(int widgetIndex, rct_window *w, rct_wi
uint8 *rideEntryIndexPtr; uint8 *rideEntryIndexPtr;
bool selectionShouldBeExpanded; bool selectionShouldBeExpanded;
ride = GET_RIDE(w->number); ride = get_ride(w->number);
rideEntry = ride_get_entry(ride); rideEntry = ride_get_entry(ride);
if(gCheatsShowVehiclesFromOtherTrackTypes && !(ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_FLAT_RIDE) || ride->type==RIDE_TYPE_MAZE || ride->type==RIDE_TYPE_MINI_GOLF)) { if(gCheatsShowVehiclesFromOtherTrackTypes && !(ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_FLAT_RIDE) || ride->type==RIDE_TYPE_MAZE || ride->type==RIDE_TYPE_MINI_GOLF)) {
@ -2359,7 +2359,7 @@ static void window_ride_vehicle_mousedown(int widgetIndex, rct_window *w, rct_wi
for (uint8 *currentRideEntryIndex = rideEntryIndexPtr; *currentRideEntryIndex != 0xFF; currentRideEntryIndex++) { for (uint8 *currentRideEntryIndex = rideEntryIndexPtr; *currentRideEntryIndex != 0xFF; currentRideEntryIndex++) {
rideEntryIndex = *currentRideEntryIndex; rideEntryIndex = *currentRideEntryIndex;
currentRideEntry = GET_RIDE_ENTRY(rideEntryIndex); currentRideEntry = get_ride_entry(rideEntryIndex);
// Skip if vehicle has the same track type, but not same subtype, unless subtype switching is enabled // Skip if vehicle has the same track type, but not same subtype, unless subtype switching is enabled
if ((currentRideEntry->flags & (RIDE_ENTRY_FLAG_SEPARATE_RIDE | RIDE_ENTRY_FLAG_SEPARATE_RIDE_NAME)) && !(gConfigInterface.select_by_track_type || selectionShouldBeExpanded)) if ((currentRideEntry->flags & (RIDE_ENTRY_FLAG_SEPARATE_RIDE | RIDE_ENTRY_FLAG_SEPARATE_RIDE_NAME)) && !(gConfigInterface.select_by_track_type || selectionShouldBeExpanded))
continue; continue;
@ -2452,7 +2452,7 @@ static void window_ride_vehicle_dropdown(rct_window *w, int widgetIndex, int dro
if (dropdownIndex == -1) if (dropdownIndex == -1)
return; return;
ride = GET_RIDE(w->number); ride = get_ride(w->number);
rideEntry = ride_get_entry(ride); rideEntry = ride_get_entry(ride);
switch (widgetIndex) { switch (widgetIndex) {
@ -2502,7 +2502,7 @@ static void window_ride_vehicle_invalidate(rct_window *w)
window_ride_set_pressed_tab(w); window_ride_set_pressed_tab(w);
ride = GET_RIDE(w->number); ride = get_ride(w->number);
rideEntry = ride_get_entry(ride); rideEntry = ride_get_entry(ride);
RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 0, uint16) = ride->name; RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 0, uint16) = ride->name;
@ -2569,7 +2569,7 @@ static void window_ride_vehicle_paint(rct_window *w, rct_drawpixelinfo *dpi)
window_draw_widgets(w, dpi); window_draw_widgets(w, dpi);
window_ride_draw_tab_images(dpi, w); window_ride_draw_tab_images(dpi, w);
ride = GET_RIDE(w->number); ride = get_ride(w->number);
rideEntry = ride_get_entry(ride); rideEntry = ride_get_entry(ride);
x = w->x + 8; x = w->x + 8;
@ -2630,7 +2630,7 @@ static void window_ride_vehicle_scrollpaint(rct_window *w, rct_drawpixelinfo *dp
rct_vehichle_paintinfo *nextSpriteToDraw, *current, tmp; rct_vehichle_paintinfo *nextSpriteToDraw, *current, tmp;
vehicle_colour vehicleColour; vehicle_colour vehicleColour;
ride = GET_RIDE(w->number); ride = get_ride(w->number);
rideEntry = ride_get_entry(ride); rideEntry = ride_get_entry(ride);
// Background // Background
@ -2718,7 +2718,7 @@ static void set_operating_setting(int rideNumber, uint8 setting, uint8 value)
static void window_ride_mode_tweak_set(rct_window *w, uint8 value) static void window_ride_mode_tweak_set(rct_window *w, uint8 value)
{ {
rct_ride *ride = GET_RIDE(w->number); rct_ride *ride = get_ride(w->number);
RCT2_GLOBAL(RCT2_ADDRESS_GAME_COMMAND_ERROR_TITLE, uint16) = 1362; RCT2_GLOBAL(RCT2_ADDRESS_GAME_COMMAND_ERROR_TITLE, uint16) = 1362;
if (ride->mode == RIDE_MODE_STATION_TO_STATION) if (ride->mode == RIDE_MODE_STATION_TO_STATION)
@ -2749,7 +2749,7 @@ static void window_ride_mode_tweak_set(rct_window *w, uint8 value)
*/ */
static void window_ride_mode_tweak_increase(rct_window *w) static void window_ride_mode_tweak_increase(rct_window *w)
{ {
rct_ride *ride = GET_RIDE(w->number); rct_ride *ride = get_ride(w->number);
uint8 value = ride->operation_option; uint8 value = ride->operation_option;
//fast_lift_hill is the cheat that allows maxing out many limits on the Operating tab. //fast_lift_hill is the cheat that allows maxing out many limits on the Operating tab.
uint8 max_value = gConfigCheat.fast_lift_hill ? 255 : RCT2_GLOBAL(RCT2_ADDRESS_RIDE_FLAGS + (ride->type * 8) + 5, uint8); uint8 max_value = gConfigCheat.fast_lift_hill ? 255 : RCT2_GLOBAL(RCT2_ADDRESS_RIDE_FLAGS + (ride->type * 8) + 5, uint8);
@ -2770,7 +2770,7 @@ static void window_ride_mode_tweak_increase(rct_window *w)
*/ */
static void window_ride_mode_tweak_decrease(rct_window *w) static void window_ride_mode_tweak_decrease(rct_window *w)
{ {
rct_ride *ride = GET_RIDE(w->number); rct_ride *ride = get_ride(w->number);
uint8 value = ride->operation_option; uint8 value = ride->operation_option;
//fast_lift_hill is the cheat that allows maxing many limits on the Operating tab. //fast_lift_hill is the cheat that allows maxing many limits on the Operating tab.
uint8 min_value = gConfigCheat.fast_lift_hill ? 0 : RCT2_GLOBAL(RCT2_ADDRESS_RIDE_FLAGS + (ride->type * 8) + 4, uint8); uint8 min_value = gConfigCheat.fast_lift_hill ? 0 : RCT2_GLOBAL(RCT2_ADDRESS_RIDE_FLAGS + (ride->type * 8) + 4, uint8);
@ -2794,7 +2794,7 @@ static void window_ride_mode_dropdown(rct_window *w, rct_widget *widget)
int i, numAvailableModes; int i, numAvailableModes;
dropdownWidget = widget - 1; dropdownWidget = widget - 1;
ride = GET_RIDE(w->number); ride = get_ride(w->number);
rideEntry = ride_get_entry(ride); rideEntry = ride_get_entry(ride);
// Seek to available modes for this ride // Seek to available modes for this ride
@ -2850,7 +2850,7 @@ static void window_ride_load_dropdown(rct_window *w, rct_widget *widget)
int i; int i;
dropdownWidget = widget - 1; dropdownWidget = widget - 1;
rct_ride *ride = GET_RIDE(w->number); rct_ride *ride = get_ride(w->number);
for (i = 0; i < 5; i++) { for (i = 0; i < 5; i++) {
gDropdownItemsFormat[i] = 1142; gDropdownItemsFormat[i] = 1142;
@ -2877,7 +2877,7 @@ static void window_ride_operating_mouseup(rct_window *w, int widgetIndex)
{ {
rct_ride *ride; rct_ride *ride;
ride = GET_RIDE(w->number); ride = get_ride(w->number);
switch (widgetIndex) { switch (widgetIndex) {
case WIDX_CLOSE: case WIDX_CLOSE:
@ -2928,7 +2928,7 @@ static void window_ride_operating_resize(rct_window *w)
*/ */
static void window_ride_operating_mousedown(int widgetIndex, rct_window *w, rct_widget *widget) static void window_ride_operating_mousedown(int widgetIndex, rct_window *w, rct_widget *widget)
{ {
rct_ride *ride = GET_RIDE(w->number); rct_ride *ride = get_ride(w->number);
uint8 parameter_check; uint8 parameter_check;
switch (widgetIndex) { switch (widgetIndex) {
@ -2986,7 +2986,7 @@ static void window_ride_operating_dropdown(rct_window *w, int widgetIndex, int d
if (dropdownIndex == -1) if (dropdownIndex == -1)
return; return;
ride = GET_RIDE(w->number); ride = get_ride(w->number);
switch (widgetIndex) { switch (widgetIndex) {
case WIDX_MODE_DROPDOWN: case WIDX_MODE_DROPDOWN:
@ -3013,7 +3013,7 @@ static void window_ride_operating_update(rct_window *w)
window_event_invalidate_call(w); window_event_invalidate_call(w);
widget_invalidate(w, WIDX_TAB_3); widget_invalidate(w, WIDX_TAB_3);
ride = GET_RIDE(w->number); ride = get_ride(w->number);
if (ride->window_invalidate_flags & RIDE_INVALIDATE_RIDE_OPERATING) { if (ride->window_invalidate_flags & RIDE_INVALIDATE_RIDE_OPERATING) {
ride->window_invalidate_flags &= ~RIDE_INVALIDATE_RIDE_OPERATING; ride->window_invalidate_flags &= ~RIDE_INVALIDATE_RIDE_OPERATING;
window_invalidate(w); window_invalidate(w);
@ -3041,7 +3041,7 @@ static void window_ride_operating_invalidate(rct_window *w)
window_ride_set_pressed_tab(w); window_ride_set_pressed_tab(w);
ride = GET_RIDE(w->number); ride = get_ride(w->number);
rideEntry = ride_get_entry(ride); rideEntry = ride_get_entry(ride);
RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 0, uint16) = ride->name; RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 0, uint16) = ride->name;
@ -3240,7 +3240,7 @@ static void window_ride_operating_paint(rct_window *w, rct_drawpixelinfo *dpi)
window_draw_widgets(w, dpi); window_draw_widgets(w, dpi);
window_ride_draw_tab_images(dpi, w); window_ride_draw_tab_images(dpi, w);
ride = GET_RIDE(w->number); ride = get_ride(w->number);
// Horizontal rule between mode settings and depart settings // Horizontal rule between mode settings and depart settings
gfx_fill_rect_inset( gfx_fill_rect_inset(
@ -3273,7 +3273,7 @@ static void window_ride_locate_mechanic(rct_window *w)
rct_ride *ride; rct_ride *ride;
rct_peep *mechanic; rct_peep *mechanic;
ride = GET_RIDE(w->number); ride = get_ride(w->number);
// First check if there is a mechanic assigned // First check if there is a mechanic assigned
mechanic = ride_get_assigned_mechanic(ride); mechanic = ride_get_assigned_mechanic(ride);
@ -3358,8 +3358,8 @@ static void window_ride_maintenance_mousedown(int widgetIndex, rct_window *w, rc
dropdownWidget = widget; dropdownWidget = widget;
ride = GET_RIDE(w->number); ride = get_ride(w->number);
ride_type = gRideTypeList[ride->subtype]; ride_type = get_ride_entry(ride->subtype);
switch (widgetIndex) { switch (widgetIndex) {
case WIDX_INSPECTION_INTERVAL_DROPDOWN: case WIDX_INSPECTION_INTERVAL_DROPDOWN:
@ -3456,8 +3456,8 @@ static void window_ride_maintenance_dropdown(rct_window *w, int widgetIndex, int
if (dropdownIndex == -1) if (dropdownIndex == -1)
return; return;
ride = GET_RIDE(w->number); ride = get_ride(w->number);
ride_type = gRideTypeList[ride->subtype]; ride_type = get_ride_entry(ride->subtype);
switch (widgetIndex) { switch (widgetIndex) {
case WIDX_INSPECTION_INTERVAL_DROPDOWN: case WIDX_INSPECTION_INTERVAL_DROPDOWN:
@ -3541,7 +3541,7 @@ static void window_ride_maintenance_update(rct_window *w)
window_event_invalidate_call(w); window_event_invalidate_call(w);
widget_invalidate(w, WIDX_TAB_4); widget_invalidate(w, WIDX_TAB_4);
ride = GET_RIDE(w->number); ride = get_ride(w->number);
if (ride->window_invalidate_flags & RIDE_INVALIDATE_RIDE_MAINTENANCE) { if (ride->window_invalidate_flags & RIDE_INVALIDATE_RIDE_MAINTENANCE) {
ride->window_invalidate_flags &= ~RIDE_INVALIDATE_RIDE_MAINTENANCE; ride->window_invalidate_flags &= ~RIDE_INVALIDATE_RIDE_MAINTENANCE;
window_invalidate(w); window_invalidate(w);
@ -3566,7 +3566,7 @@ static void window_ride_maintenance_invalidate(rct_window *w)
window_ride_set_pressed_tab(w); window_ride_set_pressed_tab(w);
rct_ride *ride = GET_RIDE(w->number); rct_ride *ride = get_ride(w->number);
RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 0, uint16) = ride->name; RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 0, uint16) = ride->name;
RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 2, uint32) = ride->name_arguments; RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 2, uint32) = ride->name_arguments;
@ -3600,7 +3600,7 @@ static void window_ride_maintenance_paint(rct_window *w, rct_drawpixelinfo *dpi)
window_draw_widgets(w, dpi); window_draw_widgets(w, dpi);
window_ride_draw_tab_images(dpi, w); window_ride_draw_tab_images(dpi, w);
ride = GET_RIDE(w->number); ride = get_ride(w->number);
// Locate mechanic button image // Locate mechanic button image
widget = &window_ride_maintenance_widgets[WIDX_LOCATE_MECHANIC]; widget = &window_ride_maintenance_widgets[WIDX_LOCATE_MECHANIC];
@ -3818,7 +3818,7 @@ static void window_ride_colour_mousedown(int widgetIndex, rct_window *w, rct_wid
int i, numItems; int i, numItems;
rct_string_id stringId; rct_string_id stringId;
ride = GET_RIDE(w->number); ride = get_ride(w->number);
rideEntry = ride_get_entry(ride); rideEntry = ride_get_entry(ride);
colourSchemeIndex = w->ride_colour; colourSchemeIndex = w->ride_colour;
dropdownWidget = widget - 1; dropdownWidget = widget - 1;
@ -4053,7 +4053,7 @@ static void window_ride_colour_invalidate(rct_window *w)
window_ride_set_pressed_tab(w); window_ride_set_pressed_tab(w);
ride = GET_RIDE(w->number); ride = get_ride(w->number);
rideEntry = ride_get_entry(ride); rideEntry = ride_get_entry(ride);
RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 0, uint16) = ride->name; RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 0, uint16) = ride->name;
@ -4218,7 +4218,7 @@ static void window_ride_colour_paint(rct_window *w, rct_drawpixelinfo *dpi)
int x, y, spriteIndex, terniaryColour; int x, y, spriteIndex, terniaryColour;
track_colour trackColour; track_colour trackColour;
ride = GET_RIDE(w->number); ride = get_ride(w->number);
rideEntry = ride_get_entry(ride); rideEntry = ride_get_entry(ride);
window_draw_widgets(w, dpi); window_draw_widgets(w, dpi);
@ -4316,7 +4316,7 @@ static void window_ride_colour_scrollpaint(rct_window *w, rct_drawpixelinfo *dpi
int trainCarIndex, x, y, spriteIndex; int trainCarIndex, x, y, spriteIndex;
vehicle_colour vehicleColour; vehicle_colour vehicleColour;
ride = GET_RIDE(w->number); ride = get_ride(w->number);
rideEntry = ride_get_entry(ride); rideEntry = ride_get_entry(ride);
vehiclePreviewWidget = &window_ride_colour_widgets[WIDX_VEHICLE_PREVIEW]; vehiclePreviewWidget = &window_ride_colour_widgets[WIDX_VEHICLE_PREVIEW];
vehicleColour = ride_get_vehicle_colour(ride, w->var_48C); vehicleColour = ride_get_vehicle_colour(ride, w->var_48C);
@ -4393,7 +4393,7 @@ static uint8 window_ride_current_music_style_order[42];
*/ */
static void window_ride_toggle_music(rct_window *w) static void window_ride_toggle_music(rct_window *w)
{ {
rct_ride *ride = GET_RIDE(w->number); rct_ride *ride = get_ride(w->number);
int activateMusic = (ride->lifecycle_flags & RIDE_LIFECYCLE_MUSIC) ? 0 : 1; int activateMusic = (ride->lifecycle_flags & RIDE_LIFECYCLE_MUSIC) ? 0 : 1;
@ -4452,7 +4452,7 @@ static void window_ride_music_mousedown(int widgetIndex, rct_window *w, rct_widg
return; return;
dropdownWidget = widget - 1; dropdownWidget = widget - 1;
rct_ride *ride = GET_RIDE(w->number); rct_ride *ride = get_ride(w->number);
int numItems = 0; int numItems = 0;
if (ride->type == RIDE_TYPE_MERRY_GO_ROUND) { if (ride->type == RIDE_TYPE_MERRY_GO_ROUND) {
@ -4501,7 +4501,7 @@ static void window_ride_music_dropdown(rct_window *w, int widgetIndex, int dropd
if (widgetIndex != WIDX_MUSIC_DROPDOWN || dropdownIndex == -1) if (widgetIndex != WIDX_MUSIC_DROPDOWN || dropdownIndex == -1)
return; return;
ride = GET_RIDE(w->number); ride = get_ride(w->number);
musicStyle = window_ride_current_music_style_order[dropdownIndex]; musicStyle = window_ride_current_music_style_order[dropdownIndex];
RCT2_GLOBAL(RCT2_ADDRESS_GAME_COMMAND_ERROR_TITLE, uint16) = STR_CANT_CHANGE_OPERATING_MODE; RCT2_GLOBAL(RCT2_ADDRESS_GAME_COMMAND_ERROR_TITLE, uint16) = STR_CANT_CHANGE_OPERATING_MODE;
game_do_command(0, (musicStyle << 8) | 1, 0, (7 << 8) | w->number, GAME_COMMAND_SET_RIDE_SETTING, 0, 0); game_do_command(0, (musicStyle << 8) | 1, 0, (7 << 8) | w->number, GAME_COMMAND_SET_RIDE_SETTING, 0, 0);
@ -4537,7 +4537,7 @@ static void window_ride_music_invalidate(rct_window *w)
window_ride_set_pressed_tab(w); window_ride_set_pressed_tab(w);
rct_ride *ride = GET_RIDE(w->number); rct_ride *ride = get_ride(w->number);
RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 0, uint16) = ride->name; RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 0, uint16) = ride->name;
RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 2, uint32) = ride->name_arguments; RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 2, uint32) = ride->name_arguments;
@ -4598,7 +4598,7 @@ static void cancel_scenery_selection(){
* rct2: 0x006D27A3 * rct2: 0x006D27A3
*/ */
static void setup_scenery_selection(rct_window* w){ static void setup_scenery_selection(rct_window* w){
rct_ride* ride = GET_RIDE(w->number); rct_ride* ride = get_ride(w->number);
if (RCT2_GLOBAL(0x009DEA6F, uint8) & 1){ if (RCT2_GLOBAL(0x009DEA6F, uint8) & 1){
cancel_scenery_selection(); cancel_scenery_selection();
@ -4727,7 +4727,7 @@ static void window_ride_measurements_mousedown(int widgetIndex, rct_window *w, r
if (widgetIndex != WIDX_SAVE_TRACK_DESIGN) if (widgetIndex != WIDX_SAVE_TRACK_DESIGN)
return; return;
rct_ride *ride = GET_RIDE(w->number); rct_ride *ride = get_ride(w->number);
gDropdownItemsFormat[0] = STR_SAVE_TRACK_DESIGN_ITEM; gDropdownItemsFormat[0] = STR_SAVE_TRACK_DESIGN_ITEM;
gDropdownItemsFormat[1] = STR_SAVE_TRACK_DESIGN_WITH_SCENERY_ITEM; gDropdownItemsFormat[1] = STR_SAVE_TRACK_DESIGN_WITH_SCENERY_ITEM;
@ -4822,7 +4822,7 @@ static void window_ride_measurements_invalidate(rct_window *w)
window_ride_set_pressed_tab(w); window_ride_set_pressed_tab(w);
rct_ride *ride = GET_RIDE(w->number); rct_ride *ride = get_ride(w->number);
RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 0, uint16) = ride->name; RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 0, uint16) = ride->name;
RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 2, uint32) = ride->name_arguments; RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 2, uint32) = ride->name_arguments;
@ -4882,7 +4882,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; 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], 0x20); gfx_fill_rect_inset(dpi, x, y, w->x + 312, y + 1, w->colours[1], 0x20);
} else { } else {
ride = GET_RIDE(w->number); ride = get_ride(w->number);
x = w->x + window_ride_measurements_widgets[WIDX_PAGE_BACKGROUND].left + 4; x = w->x + window_ride_measurements_widgets[WIDX_PAGE_BACKGROUND].left + 4;
y = w->y + window_ride_measurements_widgets[WIDX_PAGE_BACKGROUND].top + 4; y = w->y + window_ride_measurements_widgets[WIDX_PAGE_BACKGROUND].top + 4;
@ -5192,7 +5192,7 @@ static void window_ride_graphs_tooltip(rct_window* w, int widgetIndex, rct_strin
measurement = ride_get_measurement(w->number, &message); measurement = ride_get_measurement(w->number, &message);
if (measurement != NULL && (measurement->flags & RIDE_MEASUREMENT_FLAG_RUNNING)) { if (measurement != NULL && (measurement->flags & RIDE_MEASUREMENT_FLAG_RUNNING)) {
RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 4, uint16) = measurement->vehicle_index + 1; RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 4, uint16) = measurement->vehicle_index + 1;
ride = GET_RIDE(w->number); ride = get_ride(w->number);
RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 2, uint16) = RideNameConvention[ride->type].vehicle_name + 6; RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 2, uint16) = RideNameConvention[ride->type].vehicle_name + 6;
} else { } else {
*stringId = message; *stringId = message;
@ -5222,7 +5222,7 @@ static void window_ride_graphs_invalidate(rct_window *w)
window_ride_set_pressed_tab(w); window_ride_set_pressed_tab(w);
ride = GET_RIDE(w->number); ride = get_ride(w->number);
RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 0, uint16) = ride->name; RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 0, uint16) = ride->name;
RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 2, uint32) = ride->name_arguments; RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 2, uint32) = ride->name_arguments;
@ -5406,8 +5406,8 @@ static void window_ride_income_toggle_primary_price(rct_window *w)
uint32 newFlags, shop_item; uint32 newFlags, shop_item;
money16 price; money16 price;
ride = GET_RIDE(w->number); ride = get_ride(w->number);
ride_type = gRideTypeList[ride->subtype]; ride_type = get_ride_entry(ride->subtype);
if (ride->type == RIDE_TYPE_TOILETS) { if (ride->type == RIDE_TYPE_TOILETS) {
shop_item = 0x1F; shop_item = 0x1F;
@ -5453,8 +5453,8 @@ static void window_ride_income_toggle_secondary_price(rct_window *w)
uint32 newFlags, shop_item; uint32 newFlags, shop_item;
money16 price; money16 price;
ride = GET_RIDE(w->number); ride = get_ride(w->number);
ride_type = gRideTypeList[ride->subtype]; ride_type = get_ride_entry(ride->subtype);
shop_item = ride_type->shop_item_secondary; shop_item = ride_type->shop_item_secondary;
if (shop_item == 0xFF) if (shop_item == 0xFF)
@ -5494,8 +5494,8 @@ static void window_ride_income_increase_primary_price(rct_window *w)
rct_ride *ride; rct_ride *ride;
rct_ride_type *ride_type; rct_ride_type *ride_type;
ride = GET_RIDE(w->number); ride = get_ride(w->number);
ride_type = gRideTypeList[ride->subtype]; ride_type = get_ride_entry(ride->subtype);
if ((RCT2_GLOBAL(RCT2_ADDRESS_PARK_FLAGS, uint32) & PARK_FLAGS_PARK_FREE_ENTRY) == 0) { if ((RCT2_GLOBAL(RCT2_ADDRESS_PARK_FLAGS, uint32) & PARK_FLAGS_PARK_FREE_ENTRY) == 0) {
if (ride->type != RIDE_TYPE_TOILETS && ride_type->shop_item == 0xFF) { if (ride->type != RIDE_TYPE_TOILETS && ride_type->shop_item == 0xFF) {
@ -5519,8 +5519,8 @@ static void window_ride_income_decrease_primary_price(rct_window *w)
rct_ride *ride; rct_ride *ride;
rct_ride_type *ride_type; rct_ride_type *ride_type;
ride = GET_RIDE(w->number); ride = get_ride(w->number);
ride_type = gRideTypeList[ride->subtype]; ride_type = get_ride_entry(ride->subtype);
if ((RCT2_GLOBAL(RCT2_ADDRESS_PARK_FLAGS, uint32) & PARK_FLAGS_PARK_FREE_ENTRY) == 0) { if ((RCT2_GLOBAL(RCT2_ADDRESS_PARK_FLAGS, uint32) & PARK_FLAGS_PARK_FREE_ENTRY) == 0) {
if (ride->type != RIDE_TYPE_TOILETS && ride_type->shop_item == 0xFF) { if (ride->type != RIDE_TYPE_TOILETS && ride_type->shop_item == 0xFF) {
@ -5544,8 +5544,8 @@ static void window_ride_income_increase_secondary_price(rct_window *w)
rct_ride *ride; rct_ride *ride;
rct_ride_type *ride_type; rct_ride_type *ride_type;
ride = GET_RIDE(w->number); ride = get_ride(w->number);
ride_type = gRideTypeList[ride->subtype]; ride_type = get_ride_entry(ride->subtype);
money16 price = ride->price_secondary; money16 price = ride->price_secondary;
if (price < MONEY(20, 00)) if (price < MONEY(20, 00))
@ -5563,8 +5563,8 @@ static void window_ride_income_decrease_secondary_price(rct_window *w)
rct_ride *ride; rct_ride *ride;
rct_ride_type *ride_type; rct_ride_type *ride_type;
ride = GET_RIDE(w->number); ride = get_ride(w->number);
ride_type = gRideTypeList[ride->subtype]; ride_type = get_ride_entry(ride->subtype);
money16 price = ride->price_secondary; money16 price = ride->price_secondary;
if (price > MONEY(0, 00)) if (price > MONEY(0, 00))
@ -5647,7 +5647,7 @@ static void window_ride_income_update(rct_window *w)
window_event_invalidate_call(w); window_event_invalidate_call(w);
widget_invalidate(w, WIDX_TAB_9); widget_invalidate(w, WIDX_TAB_9);
ride = GET_RIDE(w->number); ride = get_ride(w->number);
if (ride->window_invalidate_flags & RIDE_INVALIDATE_RIDE_INCOME) { if (ride->window_invalidate_flags & RIDE_INVALIDATE_RIDE_INCOME) {
ride->window_invalidate_flags &= ~RIDE_INVALIDATE_RIDE_INCOME; ride->window_invalidate_flags &= ~RIDE_INVALIDATE_RIDE_INCOME;
window_invalidate(w); window_invalidate(w);
@ -5675,7 +5675,7 @@ static void window_ride_income_invalidate(rct_window *w)
window_ride_set_pressed_tab(w); window_ride_set_pressed_tab(w);
rct_ride *ride = GET_RIDE(w->number); rct_ride *ride = get_ride(w->number);
RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 0, uint16) = ride->name; RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 0, uint16) = ride->name;
RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 2, uint32) = ride->name_arguments; RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 2, uint32) = ride->name_arguments;
@ -5786,7 +5786,7 @@ static void window_ride_income_paint(rct_window *w, rct_drawpixelinfo *dpi)
window_draw_widgets(w, dpi); window_draw_widgets(w, dpi);
window_ride_draw_tab_images(dpi, w); window_ride_draw_tab_images(dpi, w);
ride = GET_RIDE(w->number); ride = get_ride(w->number);
rideEntry = ride_get_entry(ride); rideEntry = ride_get_entry(ride);
x = w->x + window_ride_income_widgets[WIDX_PAGE_BACKGROUND].left + 4; x = w->x + window_ride_income_widgets[WIDX_PAGE_BACKGROUND].left + 4;
@ -5917,7 +5917,7 @@ static void window_ride_customer_update(rct_window *w)
window_event_invalidate_call(w); window_event_invalidate_call(w);
widget_invalidate(w, WIDX_TAB_10); widget_invalidate(w, WIDX_TAB_10);
ride = GET_RIDE(w->number); ride = get_ride(w->number);
if (ride->window_invalidate_flags & RIDE_INVALIDATE_RIDE_CUSTOMER) { if (ride->window_invalidate_flags & RIDE_INVALIDATE_RIDE_CUSTOMER) {
ride->window_invalidate_flags &= ~RIDE_INVALIDATE_RIDE_CUSTOMER; ride->window_invalidate_flags &= ~RIDE_INVALIDATE_RIDE_CUSTOMER;
window_invalidate(w); window_invalidate(w);
@ -5942,7 +5942,7 @@ static void window_ride_customer_invalidate(rct_window *w)
window_ride_set_pressed_tab(w); window_ride_set_pressed_tab(w);
rct_ride *ride = GET_RIDE(w->number); rct_ride *ride = get_ride(w->number);
RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 0, uint16) = ride->name; RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 0, uint16) = ride->name;
RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 2, uint32) = ride->name_arguments; RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 2, uint32) = ride->name_arguments;
@ -5975,7 +5975,7 @@ static void window_ride_customer_paint(rct_window *w, rct_drawpixelinfo *dpi)
window_draw_widgets(w, dpi); window_draw_widgets(w, dpi);
window_ride_draw_tab_images(dpi, w); window_ride_draw_tab_images(dpi, w);
ride = GET_RIDE(w->number); ride = get_ride(w->number);
x = w->x + window_ride_customer_widgets[WIDX_PAGE_BACKGROUND].left + 4; x = w->x + window_ride_customer_widgets[WIDX_PAGE_BACKGROUND].left + 4;
y = w->y + window_ride_customer_widgets[WIDX_PAGE_BACKGROUND].top + 4; y = w->y + window_ride_customer_widgets[WIDX_PAGE_BACKGROUND].top + 4;

32
src/windows/ride_construction.c
View File

@ -506,7 +506,7 @@ rct_window *window_ride_construction_open()
sub_6B2FA9(rideIndex); sub_6B2FA9(rideIndex);
rct_window *w; rct_window *w;
rct_ride* ride = GET_RIDE(rideIndex); rct_ride* ride = get_ride(rideIndex);
if (ride->type == RIDE_TYPE_MAZE) if (ride->type == RIDE_TYPE_MAZE)
return window_maze_construction_open(); return window_maze_construction_open();
@ -583,7 +583,7 @@ static void window_ride_construction_close(rct_window *w)
uint8 rideIndex = _currentRideIndex; uint8 rideIndex = _currentRideIndex;
if (ride_try_get_origin_element(rideIndex, NULL)) { if (ride_try_get_origin_element(rideIndex, NULL)) {
rct_ride *ride = GET_RIDE(rideIndex); rct_ride *ride = get_ride(rideIndex);
if (ride->mode == RIDE_MODE_SHOP_STALL && gConfigGeneral.auto_open_shops) { if (ride->mode == RIDE_MODE_SHOP_STALL && gConfigGeneral.auto_open_shops) {
ride->status = RIDE_STATUS_OPEN; ride->status = RIDE_STATUS_OPEN;
} }
@ -648,7 +648,7 @@ static void window_ride_construction_resize(rct_window *w)
w->enabled_widgets |= (1 << WIDX_CONSTRUCT); w->enabled_widgets |= (1 << WIDX_CONSTRUCT);
} }
rct_ride *ride = GET_RIDE(_currentRideIndex); rct_ride *ride = get_ride(_currentRideIndex);
int rideType = ride_get_alternative_type(ride); int rideType = ride_get_alternative_type(ride);
uint64 disabledWidgets = 0; uint64 disabledWidgets = 0;
@ -1208,7 +1208,7 @@ static void window_ride_construction_resize(rct_window *w)
*/ */
static void window_ride_construction_mousedown(int widgetIndex, rct_window *w, rct_widget *widget) static void window_ride_construction_mousedown(int widgetIndex, rct_window *w, rct_widget *widget)
{ {
rct_ride *ride = GET_RIDE(_currentRideIndex); rct_ride *ride = get_ride(_currentRideIndex);
int rideType; int rideType;
window_ride_construction_update_enabled_track_pieces(); window_ride_construction_update_enabled_track_pieces();
@ -2064,7 +2064,7 @@ static void window_ride_construction_invalidate(rct_window *w)
rct_ride *ride; rct_ride *ride;
rct_string_id stringId; rct_string_id stringId;
ride = GET_RIDE(_currentRideIndex); ride = get_ride(_currentRideIndex);
stringId = STR_RIDE_CONSTRUCTION_SPECIAL; stringId = STR_RIDE_CONSTRUCTION_SPECIAL;
if (_currentTrackCurve >= 256) { if (_currentTrackCurve >= 256) {
@ -2140,7 +2140,7 @@ static void window_ride_construction_draw_track_piece(
const rct_preview_track *trackBlock; const rct_preview_track *trackBlock;
rct_ride *ride; rct_ride *ride;
ride = GET_RIDE(rideIndex); ride = get_ride(rideIndex);
trackBlock = get_track_def_from_ride(ride, trackType); trackBlock = get_track_def_from_ride(ride, trackType);
while ((trackBlock + 1)->index != 0xFF) while ((trackBlock + 1)->index != 0xFF)
@ -2240,7 +2240,7 @@ static void sub_6CBCE2(
RCT2_GLOBAL(0x00EE7880, uint32) = 0x00F1A4CC; RCT2_GLOBAL(0x00EE7880, uint32) = 0x00F1A4CC;
painter_setup(); painter_setup();
ride = GET_RIDE(rideIndex); ride = get_ride(rideIndex);
preserve_map_size_vars = RCT2_GLOBAL(RCT2_ADDRESS_MAP_SIZE_UNITS, uint64); preserve_map_size_vars = RCT2_GLOBAL(RCT2_ADDRESS_MAP_SIZE_UNITS, uint64);
@ -2404,7 +2404,7 @@ static bool sub_6CA2DF(int *trackType, int *trackDirection, int *rideIndex, int
*/ */
static void window_ride_construction_update_enabled_track_pieces() static void window_ride_construction_update_enabled_track_pieces()
{ {
rct_ride *ride = GET_RIDE(_currentRideIndex); rct_ride *ride = get_ride(_currentRideIndex);
rct_ride_type *rideEntry = ride_get_entry(ride); rct_ride_type *rideEntry = ride_get_entry(ride);
int rideType = _currentTrackCovered & 2 ? RCT2_ADDRESS(0x0097D4F5, uint8)[ride->type * 8] : ride->type; int rideType = _currentTrackCovered & 2 ? RCT2_ADDRESS(0x0097D4F5, uint8)[ride->type * 8] : ride->type;
@ -2422,7 +2422,7 @@ money32 sub_6CA162(int rideIndex, int trackType, int trackDirection, int edxRS16
money32 result; money32 result;
sub_6C96C0(); sub_6C96C0();
ride = GET_RIDE(rideIndex); ride = get_ride(rideIndex);
if (ride->type == RIDE_TYPE_MAZE) { if (ride->type == RIDE_TYPE_MAZE) {
result = game_do_command(x, 105 | (4 << 8), y, rideIndex | (trackType << 8) | (edxRS16 << 16), GAME_COMMAND_SET_MAZE_TRACK, z, 0); result = game_do_command(x, 105 | (4 << 8), y, rideIndex | (trackType << 8) | (edxRS16 << 16), GAME_COMMAND_SET_MAZE_TRACK, z, 0);
if (result == MONEY32_UNDEFINED) if (result == MONEY32_UNDEFINED)
@ -2594,7 +2594,7 @@ static void window_ride_construction_update_map_selection()
break; break;
} }
ride = GET_RIDE(_currentRideIndex); ride = get_ride(_currentRideIndex);
window_ride_construction_select_map_tiles(ride, trackType, trackDirection, x, y); window_ride_construction_select_map_tiles(ride, trackType, trackDirection, x, y);
map_invalidate_map_selection_tiles(); map_invalidate_map_selection_tiles();
} }
@ -2609,7 +2609,7 @@ static void window_ride_construction_update_possible_ride_configurations()
int trackType; int trackType;
int edx, edi; int edx, edi;
ride = GET_RIDE(_currentRideIndex); ride = get_ride(_currentRideIndex);
RCT2_GLOBAL(0x00F440D3, uint8) = 0; RCT2_GLOBAL(0x00F440D3, uint8) = 0;
if (_currentTrackCovered & 2) if (_currentTrackCovered & 2)
@ -2697,7 +2697,7 @@ static void window_ride_construction_update_possible_ride_configurations()
static void window_ride_construction_update_widgets(rct_window *w) static void window_ride_construction_update_widgets(rct_window *w)
{ {
uint8 rideIndex = _currentRideIndex; uint8 rideIndex = _currentRideIndex;
rct_ride *ride = GET_RIDE(rideIndex); rct_ride *ride = get_ride(rideIndex);
int rideType = ride_get_alternative_type(ride); int rideType = ride_get_alternative_type(ride);
w->hold_down_widgets = 0; w->hold_down_widgets = 0;
@ -3194,7 +3194,7 @@ static void window_ride_construction_show_special_track_dropdown(rct_window *w,
uint8 trackPiece = _currentPossibleRideConfigurations[i]; uint8 trackPiece = _currentPossibleRideConfigurations[i];
rct_string_id trackPieceStringId = RideConfigurationStringIds[trackPiece]; rct_string_id trackPieceStringId = RideConfigurationStringIds[trackPiece];
if (trackPieceStringId == STR_RAPIDS) { if (trackPieceStringId == STR_RAPIDS) {
rct_ride *ride = GET_RIDE(_currentRideIndex); rct_ride *ride = get_ride(_currentRideIndex);
if (ride->type == RIDE_TYPE_CAR_RIDE) if (ride->type == RIDE_TYPE_CAR_RIDE)
trackPieceStringId = STR_LOG_BUMPS; trackPieceStringId = STR_LOG_BUMPS;
} }
@ -3314,7 +3314,7 @@ void ride_construction_toolupdate_construct(int screenX, int screenY)
return; return;
} }
_currentTrackPieceType = trackType; _currentTrackPieceType = trackType;
ride = GET_RIDE(_currentRideIndex); ride = get_ride(_currentRideIndex);
// Re-using this other code, very slight difference from original // Re-using this other code, very slight difference from original
// - Original code checks for MSB mask instead of 255 on trackPart->var_00 // - Original code checks for MSB mask instead of 255 on trackPart->var_00
@ -3502,7 +3502,7 @@ void ride_construction_tooldown_construct(int screenX, int screenY)
tool_cancel(); tool_cancel();
rct_ride *ride = GET_RIDE(_currentRideIndex); rct_ride *ride = get_ride(_currentRideIndex);
if (_trackPlaceZ == 0) { if (_trackPlaceZ == 0) {
const rct_preview_track *trackBlock = get_track_def_from_ride(ride, _currentTrackPieceType); const rct_preview_track *trackBlock = get_track_def_from_ride(ride, _currentTrackPieceType);
int bx = 0; int bx = 0;
@ -3696,7 +3696,7 @@ static void ride_construction_tooldown_entrance_exit(int screenX, int screenY)
RCT2_GLOBAL(RCT2_ADDRESS_COMMAND_MAP_Z, uint16) RCT2_GLOBAL(RCT2_ADDRESS_COMMAND_MAP_Z, uint16)
); );
rct_ride *ride = GET_RIDE(RCT2_GLOBAL(0x00F44192, uint8)); rct_ride *ride = get_ride(RCT2_GLOBAL(0x00F44192, uint8));
if (ride_are_all_possible_entrances_and_exits_built(ride)) { if (ride_are_all_possible_entrances_and_exits_built(ride)) {
tool_cancel(); tool_cancel();
if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_15)) { if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_15)) {

20
src/windows/ride_list.c
View File

@ -464,7 +464,7 @@ static void window_ride_list_scrollpaint(rct_window *w, rct_drawpixelinfo *dpi,
} }
// Get ride // Get ride
ride = &g_ride_list[w->list_item_positions[i]]; ride = get_ride(w->list_item_positions[i]);
// Ride name // Ride name
gfx_draw_string_left_clipped(dpi, format, &ride->name, 0, 0, y - 1, 159); gfx_draw_string_left_clipped(dpi, format, &ride->name, 0, 0, y - 1, 159);
@ -613,7 +613,7 @@ static void window_ride_list_refresh_list(rct_window *w)
bufferB = (char*)0x0141EF68; bufferB = (char*)0x0141EF68;
format_string_to_upper(bufferA, ride->name, &ride->name_arguments); format_string_to_upper(bufferA, ride->name, &ride->name_arguments);
while (--current_list_position >= 0) { while (--current_list_position >= 0) {
otherRide = &g_ride_list[w->list_item_positions[current_list_position]]; otherRide = get_ride(w->list_item_positions[current_list_position]);
format_string_to_upper(bufferB, otherRide->name, &otherRide->name_arguments); format_string_to_upper(bufferB, otherRide->name, &otherRide->name_arguments);
if (strcmp(bufferA, bufferB) >= 0) if (strcmp(bufferA, bufferB) >= 0)
break; break;
@ -623,7 +623,7 @@ static void window_ride_list_refresh_list(rct_window *w)
break; break;
case INFORMATION_TYPE_POPULARITY: case INFORMATION_TYPE_POPULARITY:
while (--current_list_position >= 0) { while (--current_list_position >= 0) {
otherRide = &g_ride_list[w->list_item_positions[current_list_position]]; otherRide = get_ride(w->list_item_positions[current_list_position]);
if (ride->popularity * 4 <= otherRide->popularity * 4) if (ride->popularity * 4 <= otherRide->popularity * 4)
break; break;
@ -632,7 +632,7 @@ static void window_ride_list_refresh_list(rct_window *w)
break; break;
case INFORMATION_TYPE_SATISFACTION: case INFORMATION_TYPE_SATISFACTION:
while (--current_list_position >= 0) { while (--current_list_position >= 0) {
otherRide = &g_ride_list[w->list_item_positions[current_list_position]]; otherRide = get_ride(w->list_item_positions[current_list_position]);
if (ride->satisfaction * 5 <= otherRide->satisfaction * 5) if (ride->satisfaction * 5 <= otherRide->satisfaction * 5)
break; break;
@ -641,7 +641,7 @@ static void window_ride_list_refresh_list(rct_window *w)
break; break;
case INFORMATION_TYPE_PROFIT: case INFORMATION_TYPE_PROFIT:
while (--current_list_position >= 0) { while (--current_list_position >= 0) {
otherRide = &g_ride_list[w->list_item_positions[current_list_position]]; otherRide = get_ride(w->list_item_positions[current_list_position]);
if (ride->profit <= otherRide->profit) if (ride->profit <= otherRide->profit)
break; break;
@ -650,7 +650,7 @@ static void window_ride_list_refresh_list(rct_window *w)
break; break;
case INFORMATION_TYPE_QUEUE_LENGTH: case INFORMATION_TYPE_QUEUE_LENGTH:
while (--current_list_position >= 0) { while (--current_list_position >= 0) {
otherRide = &g_ride_list[w->list_item_positions[current_list_position]]; otherRide = get_ride(w->list_item_positions[current_list_position]);
if (ride_get_total_queue_length(ride) <= ride_get_total_queue_length(otherRide)) if (ride_get_total_queue_length(ride) <= ride_get_total_queue_length(otherRide))
break; break;
@ -659,7 +659,7 @@ static void window_ride_list_refresh_list(rct_window *w)
break; break;
case INFORMATION_TYPE_QUEUE_TIME: case INFORMATION_TYPE_QUEUE_TIME:
while (--current_list_position >= 0) { while (--current_list_position >= 0) {
otherRide = &g_ride_list[w->list_item_positions[current_list_position]]; otherRide = get_ride(w->list_item_positions[current_list_position]);
if (ride_get_max_queue_time(ride) <= ride_get_max_queue_time(otherRide)) if (ride_get_max_queue_time(ride) <= ride_get_max_queue_time(otherRide))
break; break;
@ -668,7 +668,7 @@ static void window_ride_list_refresh_list(rct_window *w)
break; break;
case INFORMATION_TYPE_RELIABILITY: case INFORMATION_TYPE_RELIABILITY:
while (--current_list_position >= 0) { while (--current_list_position >= 0) {
otherRide = &g_ride_list[w->list_item_positions[current_list_position]]; otherRide = get_ride(w->list_item_positions[current_list_position]);
if (ride->reliability >> 8 <= otherRide->reliability >> 8) if (ride->reliability >> 8 <= otherRide->reliability >> 8)
break; break;
@ -677,7 +677,7 @@ static void window_ride_list_refresh_list(rct_window *w)
break; break;
case INFORMATION_TYPE_DOWN_TIME: case INFORMATION_TYPE_DOWN_TIME:
while (--current_list_position >= 0) { while (--current_list_position >= 0) {
otherRide = &g_ride_list[w->list_item_positions[current_list_position]]; otherRide = get_ride(w->list_item_positions[current_list_position]);
if (ride->downtime <= otherRide->downtime) if (ride->downtime <= otherRide->downtime)
break; break;
@ -686,7 +686,7 @@ static void window_ride_list_refresh_list(rct_window *w)
break; break;
case INFORMATION_TYPE_GUESTS_FAVOURITE: case INFORMATION_TYPE_GUESTS_FAVOURITE:
while (--current_list_position >= 0) { while (--current_list_position >= 0) {
otherRide = &g_ride_list[w->list_item_positions[current_list_position]]; otherRide = get_ride(w->list_item_positions[current_list_position]);
if (ride->guests_favourite <= otherRide->guests_favourite) if (ride->guests_favourite <= otherRide->guests_favourite)
break; break;

4
src/windows/sign.c
View File

@ -257,7 +257,7 @@ static void window_sign_mouseup(rct_window *w, int widgetIndex)
break; break;
case WIDX_SIGN_TEXT: case WIDX_SIGN_TEXT:
if (banner->flags&BANNER_FLAG_2){ if (banner->flags&BANNER_FLAG_2){
rct_ride* ride = GET_RIDE(banner->colour); rct_ride* ride = get_ride(banner->colour);
RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 16, uint32) = ride->name_arguments; RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 16, uint32) = ride->name_arguments;
string_id = ride->name; string_id = ride->name;
} }
@ -521,7 +521,7 @@ static void window_sign_small_mouseup(rct_window *w, int widgetIndex)
break; break;
case WIDX_SIGN_TEXT: case WIDX_SIGN_TEXT:
if (banner->flags&BANNER_FLAG_2){ if (banner->flags&BANNER_FLAG_2){
rct_ride* ride = GET_RIDE(banner->colour); rct_ride* ride = get_ride(banner->colour);
RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 16, uint32) = ride->name_arguments; RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 16, uint32) = ride->name_arguments;
string_id = ride->name; string_id = ride->name;
} }

2
src/windows/tile_inspector.c
View File

@ -561,7 +561,7 @@ static void window_tile_inspector_scrollpaint(rct_window *w, rct_drawpixelinfo *
sprintf( sprintf(
buffer, buffer,
"Track (%s)", "Track (%s)",
language_get_string(2 + GET_RIDE(element->properties.track.ride_index)->type) language_get_string(2 + get_ride(element->properties.track.ride_index)->type)
); );
type_name = buffer; type_name = buffer;
break; break;

2
src/windows/track_list.c
View File

@ -342,7 +342,7 @@ static void window_track_list_invalidate(rct_window *w)
colour_scheme_update(w); colour_scheme_update(w);
entry = GET_RIDE_ENTRY(_window_track_list_item.entry_index); entry = get_ride_entry(_window_track_list_item.entry_index);
stringId = entry->name; stringId = entry->name;
if (!(entry->flags & RIDE_ENTRY_FLAG_SEPARATE_RIDE_NAME) || rideTypeShouldLoseSeparateFlag(entry)) if (!(entry->flags & RIDE_ENTRY_FLAG_SEPARATE_RIDE_NAME) || rideTypeShouldLoseSeparateFlag(entry))

2
src/world/banner.c
View File

@ -101,7 +101,7 @@ static int banner_get_ride_index_at(int x, int y, int z)
continue; continue;
rideIndex = mapElement->properties.track.ride_index; rideIndex = mapElement->properties.track.ride_index;
ride = GET_RIDE(rideIndex); ride = get_ride(rideIndex);
if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_IS_SHOP)) if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_IS_SHOP))
continue; continue;

8
src/world/footpath.c
View File

@ -1122,7 +1122,7 @@ static void loc_6A6D7E(
break; break;
case MAP_ELEMENT_TYPE_TRACK: case MAP_ELEMENT_TYPE_TRACK:
if (z == mapElement->base_height) { if (z == mapElement->base_height) {
rct_ride *ride = GET_RIDE(mapElement->properties.track.ride_index); rct_ride *ride = get_ride(mapElement->properties.track.ride_index);
if (!ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_FLAT_RIDE)) { if (!ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_FLAT_RIDE)) {
continue; continue;
} }
@ -1213,7 +1213,7 @@ static void loc_6A6C85(
} }
if (map_element_get_type(mapElement) == MAP_ELEMENT_TYPE_TRACK) { if (map_element_get_type(mapElement) == MAP_ELEMENT_TYPE_TRACK) {
rct_ride *ride = GET_RIDE(mapElement->properties.track.ride_index); rct_ride *ride = get_ride(mapElement->properties.track.ride_index);
if (!ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_FLAT_RIDE)) { if (!ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_FLAT_RIDE)) {
return; return;
} }
@ -1406,7 +1406,7 @@ void sub_6A759F()
for (esi = (uint8*)0x00F3EFF8; esi < RCT2_GLOBAL(0x00F3EFF4, uint8*); esi++) { for (esi = (uint8*)0x00F3EFF8; esi < RCT2_GLOBAL(0x00F3EFF4, uint8*); esi++) {
rideIndex = *esi; rideIndex = *esi;
ride = GET_RIDE(rideIndex); ride = get_ride(rideIndex);
if (ride->type == RIDE_TYPE_NULL) if (ride->type == RIDE_TYPE_NULL)
continue; continue;
@ -1967,7 +1967,7 @@ void footpath_remove_edges_at(int x, int y, rct_map_element *mapElement)
if (map_element_get_type(mapElement) == MAP_ELEMENT_TYPE_TRACK) { if (map_element_get_type(mapElement) == MAP_ELEMENT_TYPE_TRACK) {
int rideIndex = mapElement->properties.track.ride_index; int rideIndex = mapElement->properties.track.ride_index;
ride = GET_RIDE(rideIndex); ride = get_ride(rideIndex);
if (!ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_FLAT_RIDE)) if (!ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_FLAT_RIDE))
return; return;
} }

10
src/world/map.c
View File

@ -1635,9 +1635,9 @@ static money32 map_set_land_height(int flags, int x, int y, int height, int styl
if(map_element_get_type(mapElement) != MAP_ELEMENT_TYPE_TRACK) if(map_element_get_type(mapElement) != MAP_ELEMENT_TYPE_TRACK)
continue; continue;
int rideIndex = mapElement->properties.track.ride_index; int rideIndex = mapElement->properties.track.ride_index;
int maxHeight = GET_RIDE_ENTRY(GET_RIDE(rideIndex)->subtype)->max_height; int maxHeight = get_ride_entry(get_ride(rideIndex)->subtype)->max_height;
if(maxHeight == 0) if(maxHeight == 0)
maxHeight = RCT2_GLOBAL(0x97D218 + 8 * GET_RIDE(rideIndex)->type, uint8); maxHeight = RCT2_GLOBAL(0x97D218 + 8 * get_ride(rideIndex)->type, uint8);
int zDelta = mapElement->clearance_height - height; int zDelta = mapElement->clearance_height - height;
if(zDelta >= 0 && zDelta/2 > maxHeight) if(zDelta >= 0 && zDelta/2 > maxHeight)
{ {
@ -2886,7 +2886,7 @@ static bool map_place_fence_check_obstruction_with_track(rct_scenery_entry *wall
int sequence = trackElement->properties.track.sequence & 0x0F; int sequence = trackElement->properties.track.sequence & 0x0F;
int typeAndSequence = (trackType << 4) | sequence; int typeAndSequence = (trackType << 4) | sequence;
direction = (edge - trackElement->type) & 3; direction = (edge - trackElement->type) & 3;
rct_ride *ride = GET_RIDE(trackElement->properties.track.ride_index); rct_ride *ride = get_ride(trackElement->properties.track.ride_index);
if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_FLAT_RIDE)) { if (ride_type_has_flag(ride->type, RIDE_TYPE_FLAG_FLAT_RIDE)) {
if (RCT2_ADDRESS(0x0099AA94, uint8)[typeAndSequence] & (1 << direction)) { if (RCT2_ADDRESS(0x0099AA94, uint8)[typeAndSequence] & (1 << direction)) {
@ -2910,7 +2910,7 @@ static bool map_place_fence_check_obstruction_with_track(rct_scenery_entry *wall
return false; return false;
} }
rct_ride_type *rideEntry = GET_RIDE_ENTRY(ride->subtype); rct_ride_type *rideEntry = get_ride_entry(ride->subtype);
if (rideEntry->flags & RIDE_ENTRY_FLAG_16) { if (rideEntry->flags & RIDE_ENTRY_FLAG_16) {
return false; return false;
} }
@ -3796,7 +3796,7 @@ static void map_obstruction_set_error_text(rct_map_element *mapElement)
errorStringId = STR_FOOTPATH_IN_THE_WAY; errorStringId = STR_FOOTPATH_IN_THE_WAY;
break; break;
case MAP_ELEMENT_TYPE_TRACK: case MAP_ELEMENT_TYPE_TRACK:
ride = GET_RIDE(mapElement->properties.track.ride_index); ride = get_ride(mapElement->properties.track.ride_index);
errorStringId = STR_X_IN_THE_WAY; errorStringId = STR_X_IN_THE_WAY;
RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 0, uint16) = ride->name; RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 0, uint16) = ride->name;
RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 2, uint32) = ride->name_arguments; RCT2_GLOBAL(RCT2_ADDRESS_COMMON_FORMAT_ARGS + 2, uint32) = ride->name_arguments;

2
src/world/map_animation.c
View File

@ -125,7 +125,7 @@ static bool map_animation_invalidate_ride_entrance(int x, int y, int baseZ)
if (mapElement->properties.entrance.type != ENTRANCE_TYPE_RIDE_ENTRANCE) if (mapElement->properties.entrance.type != ENTRANCE_TYPE_RIDE_ENTRANCE)
continue; continue;
ride = GET_RIDE(mapElement->properties.entrance.ride_index); ride = get_ride(mapElement->properties.entrance.ride_index);
entranceDefinition = &RideEntranceDefinitions[ride->entrance_style]; entranceDefinition = &RideEntranceDefinitions[ride->entrance_style];
int height = (mapElement->base_height * 8) + entranceDefinition->height + 8; int height = (mapElement->base_height * 8) + entranceDefinition->height + 8;

2
src/world/park.c
View File

@ -302,7 +302,7 @@ money32 calculate_park_value()
// Sum ride values // Sum ride values
result = 0; result = 0;
for (i = 0; i < 255; i++) { for (i = 0; i < 255; i++) {
ride = &g_ride_list[i]; ride = get_ride(i);
result += calculate_ride_value(ride); result += calculate_ride_value(ride);
} }